semvec/pypi-packages huggingface dataset:
prefixdate 0.5.0
Parse and process date string of varied precision as prefixes in Python.
License: MIT
Requires Python: >=3.9
Keywords: date, iso8601, partial date, rfc3339

# Prefix date parser

This is a helper class to parse dates with varied degrees of precision. For
example, a data source might state a date as `2001`, `2001-4` or `2001-04-02`,
with the implication that only the year, month or day is known. This library
will process such partial dates into a structured format and allow their
validation and re-formatting (e.g. turning `2001-4` into `2001-04` above).

The library does not support the complexities of the ISO 8601 and RFC 3339
standards including date ranges and calendar-week/day-of-year notations.

## Installation

Install `prefixdate` using PyPI:

```bash
$ pip install prefixdate
```

## Usage

The library provides a variety of helper functions to parse and format
partial dates:

```python
from prefixdate import parse, normalize_date, Precision

# Parse returns a `DatePrefix` object:
date = parse('2001-3')
assert date.text == '2001-03'
date = parse(2001)
assert date.text == '2001'
assert date.precision == Precision.YEAR

date = parse(None)
assert date.text is None
assert date.precision == Precision.EMPTY
# This will also be the outcome for invalid dates!

# Normalize to a standard string:
assert normalize_date('2001-1') == '2001-01'
assert normalize_date('2001-00-00') == '2001'
assert normalize_date('Boo!') is None

# This also works for datetimes:
from datetime import datetime
now = datetime.utcnow().isoformat()
minute = normalize_date(now, precision=Precision.MINUTE)

# You can also feed in None, date and datetime:
normalize_date(datetime.utcnow())
normalize_date(datetime.date())
normalize_date(None)
```

You can also use the `parse_parts` helper, which is similar to the constructor
for a `datetime`:

```python
from prefixdate import parse_parts, Precision

date = parse_parts(2001, '3', None)
assert date.precision == Precision.MONTH
assert date.text == '2001-03'
```

### Format strings

For dates which are not already stored in an ISO 8601-like string format, you
can supply one or many format strings for `datetime.strptime`. The format strings
will be analysed to determine how precise the resulting dates are expected to be.

```python 
from prefixdate import parse_format, parse_formats, Precision

date = parse_format('YEAR 2021', 'YEAR %Y')
assert date.precision == Precision.YEAR
assert date.text == '2021'

# You can try out multiple formats in sequence. The first non-empty prefix
# will be returned:
date = parse_formats('2021', ['%Y-%m-%d', '%Y-%m', '%Y'])
assert date.precision == Precision.YEAR
assert date.text == '2021'
```

## Caveats

* Datetimes are always converted to UTC and made naive (tzinfo stripped)
* Does not process milliseconds yet.
* Does not process invalid dates, like Feb 31st.
pychanio 0.1.3
Go-style channels and select blocks for asyncio in Python.
License: MIT
Requires Python: >=3.12

# pychanio

Go-style **channels** and **select blocks** for Python’s `asyncio`.

**pychanio** brings structured concurrency to Python, inspired by Go. It provides `chan`, `select`, `go`, and control signals like `DONE` and `CANCEL`.

## ✅ Features

- Full-duplex and directional channels
- Buffered and unbuffered behavior
- `<<` and `>>` DSL syntax for send/receive
- Go-style `select()` block with timeout and default
- Background goroutines with `go(fn)`
- Built-in sentinels for clean signalling such as shutdown, heartbeat etc.
- Works with native `asyncio`

## 📦 Installation

```bash
pip install pychanio
```

## 🔁 Example

```python
import asyncio
from pychanio import chan, go, close

async def producer(ch):
    for i in range(3):
        ch << i
    close(ch)

async def consumer(ch):
    async for val in ch:
        print(val)

async def main():
    ch = chan()
    go(producer, ch)
    await consumer(ch)

asyncio.run(main())
```

## 📚 Docs

Find the docs here at: 
[harsh-mishra.gitbook.io/pychanio](https://harsh-mishra.gitbook.io/pychanio)

## 🛠 Requirements

* Python 3.8+
* `asyncio`

## 📄 License

MIT © 2025 Harsh Mishra
base-ouro 12.0
Conversor utilizado para a geração da Base Ouro
License: MIT
Keywords: conversor base_ouro

## Relatório do vínculo de todos os alunos e disciplinas.

#### Recebe como entrada os seguintes relatórios extraídos do sistema Prime:
 - Relatório de Alunos / Pais exportação; 
 - Relatório de Disciplinas (Consulta SQL); 
 - Relatório de Carga Horária por turma / disciplina.
#### Utilizado diariamente durante o período de Ajuste Acadêmico
adbauto 1.0.9
A Python ADB automation library for Android emulators.
License: MIT
Requires Python: >=3.8


# adbauto

**ADB-based automation for Android emulators like LDPlayer**

`adbauto` is a Python library that simplifies automation for Android games and apps running in emulators. It provides tools to connect to an emulator, capture screenshots, match UI elements visually, and simulate input like taps and scrolls.

---

## 🚀 Features

- Connect to LDPlayer or other Android emulators via ADB  
- Capture screenshots directly from the device  
- Locate UI elements via OpenCV template matching  
- Simulate taps and scrolling actions  
- Designed for building automation scripts for games  

---

## 📦 Installation

```
pip install adbauto
```

> **Note:** Make sure [ADB](https://developer.android.com/tools/adb) is installed and available in your system's PATH.

---

## 🧪 Example Usage

```python
from adbauto import adb, screen, input

# Connect to emulator
device_id = adb.get_ldplayer_device()

# Take a screenshot
img = screen.capture_screenshot(device_id)

# Find a button on screen
center = screen.find_template(img, "button_template.png")

# Tap it if found
if center:
    input.tap(device_id, *center)
```

---

## 📂 Project Structure

```
adbauto/
├── adb.py       # ADB device connection and shell utilities
├── screen.py    # Screenshot capture and template matching (OpenCV)
├── input.py     # Tap and scroll input simulation
└── __init__.py  # Module exports
```

---

## ✅ Requirements

- Python 3.8+  
- ADB installed and on PATH  
- `opencv-python`  
- `numpy`  

---

## 📃 License

MIT License © Thomas Knoops