semvec/pypi-packages huggingface dataset:
hypline 0.2.5
Data Cleaning and Analysis Pipeline for Hyperscanning Research
Requires Python: >=3.10

# Hypline

[![Python](https://img.shields.io/badge/Python-3.9%20%7C%203.10%20%7C%203.11-3776AB.svg?style=flat&logo=python&logoColor=white)](https://www.python.org)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
[![CI](https://github.com/princeton-ddss/hypline/actions/workflows/ci.yml/badge.svg)](https://github.com/princeton-ddss/hypline/actions/workflows/ci.yml)
[![CD](https://github.com/princeton-ddss/hypline/actions/workflows/cd.yml/badge.svg)](https://github.com/princeton-ddss/hypline/actions/workflows/cd.yml)

Hypline is a Python package that provides a CLI tool for cleaning and analyzing data from hyperscanning studies involving dyadic conversations.

## Installation

Hypline can be installed using `pip`:

```bash
pip install hypline
```

It can also be installed using other package managers such as [`uv`](https://docs.astral.sh/uv/) and [`poetry`](https://python-poetry.org/docs/).

## Quick Start

Once the package is installed, `hypline` command will be available, like so:

```bash
hypline --help
```

Running the above will display an overview of the tool, including supported subcommands.

For instance, `clean` is a subcommand for performing confound regression to clean BOLD outputs from [fMRIPrep](https://fmriprep.org/en/stable/index.html), and its details can be viewed by running:

```bash
hypline clean --help
```

## What Next

If you want to learn more about Hypline, please check out the official project [documentation](https://princeton-ddss.github.io/hypline/latest/).
gpsoauth-compat 0.1.0rc1
gpsoauth compatibility layer for google-api-python-client
Requires Python: <4,>=3.9

# GPSOauth Compatibility Layer 
`gpsoauth` compatibility layer for `google-api-python-client`

Use Google Play Services authentication provided by [gpsoauth](https://github.com/simon-weber/gpsoauth) with public Google APIs provided by [google-api-python-client](https://github.com/googleapis/google-api-python-client).

Google Play Services authenticated accounts are sometimes given special permissions, even on public APIs. This project thus aims to reduce the need for maintaining scattered wrappers around privileged private APIs when public APIs give the same privileges with `gpsoauth`-provided tokens.

This mini-library aims to pose as the many Android apps that Google allows access to its API. Unfortunately, not all API scopes are available for consumption on Android applications. A comprehensive list of unavailable scopes is being worked on. In the meantime, consider using Google's recommended flow of authentication for the scopes that are unavailable on any of Google's Android applications.

## Usage

See https://github.com/rukins/gpsoauth-java#receiving-an-authentication-token for obtaining your account's oauth token.

```python
from googleapiclient.discovery import build
from gpsoauth_compat import GPLogin

SCOPES = ['https://www.googleapis.com/auth/drive.metadata.readonly']
API_SERVICE_NAME = 'drive'
API_VERSION = 'v3'

OAUTH_TOKEN = 'SECRET_GOES_HERE'

flow = GPLogin.from_oauth_token(OAUTH_TOKEN, SCOPES)
# alternatively use the following line if you already have authenticated before
# flow = GPLogin.from_master_token(MASTER_TOKEN, SCOPES)

credentials = flow.credentials
service = build(API_SERVICE_NAME, API_VERSION, credentials = credentials)
print(service.files().list().execute())
```

> [!WARNING]
> To log-out and disable this token and all its derivatives, visit https://myaccount.google.com/device-activity and navigate to your desired account. From there, you will find a device with a small caption on it saying "Android device". Click on it and log out from it.
>
> It may be associated with your browser's login session, so you will have to use a private/ incognito browsing session to access that webpage and log yourself out from your main browser. You may have to log in into your main browser again to continue using your account on it.
ildev-db 0.0.14
Reusable SQLite + SQLAlchemy and MongoDB + Beanie async repository module
Requires Python: >=3.8

# ildev_db

A reusable Python module that integrates SQLite, SQLAlchemy (async), and the repository pattern.

## Features

- Async database access using SQLite and SQLAlchemy.
- Implements the repository pattern.
- Fully tested and reusable.


## Installation

```bash
pip install ildev_db
```

## Usage locally
```
python -m venv local-venv
./local-venv/Scripts/activate
pip install -r requirements.txt 
OR
pip install .[build]      # Install build tools
pip install .[test]       # Install test tools
pip install .[dev]        # Install all dev tools

if python.exe access denied: Remove-Item -Recurse -Force \ildev_db\local-venv
```
fundi-scopegen 0.0.1
Generate scope type that can be used to safely inject values using FunDIs scope values resolution
Requires Python: >=3.10

# _# fundi-scopegen_

**Type-safe scope declaration generator for `fundi` dependency injection**

`fundi-codegen` generates `TypedDict` classes that describe the expected `scope` structure for `fundi`-based functions.  
This allows you to call `inject(scope, scan(...), stack)` with full type checking, autocomplete, and IDE support — no plugins or runtime introspection needed.

------------------------

## HOW IT WORKS

`fundi-scopegen` analyzes a function (and its dependency tree) via `scan(...)`, extracts all `from_(...)` and outputs:

- a full list of all keys required in the `scope`
- expected types (supporting `FromType`, `Literal`, `Optional`, `Union`, `Annotated`, `Parameter`, etc.)
- import statements for required symbols
- a `TypedDict` class that serves as a contract for what the `scope` must contain

---

**How it works:**

1. Recursively walks the dependency tree using `scan(...)`
2. Detects all `from_(...)`-based dependencies
3. Builds a `TypedDict` based on flattened parameter annotations
4. Outputs a ready-to-use Python type declaration

------------------------

## USAGE EXAMPLES

### Generate a scope for a function

```bash
fundi-scopegen play.application
```

Output:

```python
from typing import Any, TypedDict, NotRequired
from fundi import FromType
from fundi.types import Parameter

class ApplicationScope(TypedDict):
    parameter: NotRequired[FromType[None | Parameter]]
    app_name: NotRequired[str | None]
    some: NotRequired[str]
    username: Any
```

---

### With terminal color (for CLI readability)

```bash
fundi-scopegen play.application --colored
```

---

### Without imports

```bash
fundi-scopegen play.application --no-imports
```

Output:

```python
class ApplicationScope(TypedDict):
    parameter: NotRequired[FromType[None | Parameter]]
    app_name: NotRequired[str | None]
    some: NotRequired[str]
    username: Any
```

---

### Using it in code

```python
from contextlib import ExitStack

from fundi import inject, scan

from play import application
from scopes import ApplicationScope

scope: ApplicationScope = {
    "username": "kuyugama",
    "some": "waffel",
}

with ExitStack() as stack:
    result = inject(scope, scan(application), stack)
```

---

### Benefits

* Full IDE autocomplete
* Type-checking with `mypy` or `pyright`
* Lightweight: no runtime cost or decorators
* Easy to regenerate on dependency changes

---

> 🐾 Stop guessing your scope shape.
> Generate it once, and type it forever 😼
latexit 0.2.0
Render LaTeX code to PNG images with transparent background (no math mode required)
Requires Python: >=3.7

# latexit

Render LaTeX math formulas to PNG images from the command line, using pure Python and matplotlib's mathtext engine.

## Features
- **Pure Python**: No system LaTeX required, cross-platform.
- **CLI tool**: Convert LaTeX math snippets to PNG images.
- **Transparent background** and customizable DPI, font size, and padding.

## Limitations
- Only a subset of LaTeX math is supported (see [matplotlib mathtext documentation](https://matplotlib.org/stable/tutorials/text/mathtext.html)).
- The output may not look exactly like real LaTeX (TeX/Computer Modern), but you can get close by using the Computer Modern font (see below).

## Installation

### Option 1 Install via pip

   ```sh
   $ pip install latexit
   ```

### Option 2 Install manually
1. Clone the repository:
```sh
$ git clone https://github.com/yourusername/latexit.git
$ cd latexit
```
2. Install dependencies:
```sh
pip install -r requirements.txt
# or, if using pyproject.toml:
pip install .
```

## Usage

   ```sh
   latexit "\\frac{1}{2}" output.png
   ```

Options:
- `--dpi`: Set output DPI (default: 300)
- `--fontsize`: Set font size (default: 24)
- `--padding`: Set padding in pixels (default: 10)

## Example

```sh
latexit "x^2 + y^2 = z^2" pythagoras.png
```

## License
MIT

## Acknowledgments
This project was developed with guidance and code suggestions from an AI assistant Cursor (powered by OpenAI's GPT-4).