semvec/pypi-packages huggingface dataset:
fastapi-repository 0.1.0
A base repository for FastAPI projects, inspired by Ruby on Rails' Active Record and Ransack.
Requires Python: >=3.8

# FastAPI Repository

A base repository for FastAPI projects, inspired by Ruby on Rails' [Active Record](https://github.com/rails/rails/tree/main/activerecord) and [Ransack](https://github.com/activerecord-hackery/ransack). It provides a simple, intuitive, and asynchronous interface for data access using SQLAlchemy.

## Key Features

- **Async-first:** Designed for modern asynchronous Python.
- **Simple CRUD:** `find`, `create`, `update`, `destroy` methods out of the box.
- **Powerful Filtering:** Use Ransack-style operators (`__icontains`, `__gt`, etc.) for complex queries.
- **Relationship Loading:** Control eager (`joinedload`) and lazy (`lazyload`) loading.
- **Default Scoping:** Apply default conditions to all queries.

## Installation

```bash
pip install fastapi-repository
```

## Quick Start

1.  **Define a repository for your SQLAlchemy model:**

    ```python
    # repositories.py
    from fastapi_repository import BaseRepository
    from sqlalchemy.ext.asyncio import AsyncSession
    from .models import User  # Your SQLAlchemy model

    class UserRepository(BaseRepository):
        def __init__(self, session: AsyncSession):
            super().__init__(session, model=User)
    ```

2.  **Use it in your FastAPI application:**

    ```python
    # main.py
    from fastapi import FastAPI, Depends
    from sqlalchemy.ext.asyncio import AsyncSession
    from .database import get_session
    from .repositories import UserRepository

    app = FastAPI()

    @app.get("/users/{user_id}")
    async def get_user(user_id: int, session: AsyncSession = Depends(get_session)):
        repo = UserRepository(session)
        user = await repo.find(user_id)
        return user
    ```

## Documentation

For a complete guide, including a full tutorial, API reference, and advanced usage, please see the [**Full Documentation**](https://github.com/PeterTakahashi/fastapi-repository/blob/main/docs/index.md).
dte-adj 0.1.8
This is a Python library for estimating distributional treatment effects
Requires Python: >=3.10

## Overview

`dte_adj` is a Python package for estimating distribution treatment effects. It provides APIs for conducting regression adjustment to estimate precise distribution functions as well as convenient utils. For the details of this package, see [the documentation](https://cyberagentailab.github.io/python-dte-adjustment/).

## Installation

1. **Install from PyPI**
    ```sh
    pip install dte_adj
    ```

2. **Install from source**

    ```sh
    git clone https://github.com/CyberAgentAILab/python-dte-adjustment
    cd python-dte-adjustment
    pip install -e .
    ```

## Basic Usage
Examples of how to use this package are available in [this Get-started Guide](https://cyberagentailab.github.io/python-dte-adjustment/get_started.html).

## Theoretical Foundations

This package implements methods from the following research papers:

### Simple Randomization
- **Byambadalai, U., Oka, T., & Yasui, S.** (2024). *Estimating Distributional Treatment Effects in Randomized Experiments: Machine Learning for Variance Reduction*. [arXiv:2407.16037](https://arxiv.org/abs/2407.16037)

### Covariate-Adaptive Randomization
- **Byambadalai, U., Hirata, T., Oka, T., & Yasui, S.** (2025). *On Efficient Estimation of Distributional Treatment Effects under Covariate-Adaptive Randomization*. [arXiv:2506.05945](https://arxiv.org/abs/2506.05945)

### Multi-Task Learning
- **Hirata, T., Byambadalai, U., Oka, T., Yasui, S., & Uto, S.** (2025). *Efficient and Scalable Estimation of Distributional Treatment Effects with Multi-Task Neural Networks*. [arXiv:2507.07738](https://arxiv.org/abs/2507.07738)

## Citation

If you use this software in your research, please cite our work:

```bibtex
@article{byambadalai2024estimating,
  title={Estimating Distributional Treatment Effects in Randomized Experiments: Machine Learning for Variance Reduction},
  author={Byambadalai, Undral and Oka, Tatsushi and Yasui, Shota},
  journal={arXiv preprint arXiv:2407.16037},
  year={2024}
}
```

For other citation formats, see our [CITATION.cff](CITATION.cff) file.

## Development
We welcome contributions to the project! Please review our [Contribution Guide](CONTRIBUTING.md) for details on how to get started.

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

## Maintainers
- [Tomu Hirata](https://github.com/TomeHirata)
episode-monitor 1.2.0
Monitor wikipedia pages of tv shows and send a notification when new episodes are detected
Requires Python: >=3.12

# episode-monitor

Send desktop notifications when new episodes are detected for a list ov tv shows.

## Installation

### From PyPI

```console
pipx install episode-monitor
```

### From source

```console
git clone https://github.com/laszloszurok/episode-monitor
cd episode-monitor
python -m build
pipx install dist/episode-monitor-0.0.1-py3-none-any.whl
```

## Usage

Frist run creates a config file on `$XDG_CONFIG_HOME/episode_monitor/config.yaml` (defaults to `~/.config/episode_monitor/config.yaml`).
The default config file:
```yaml
interval: 300
shows:
- The Simpsons
- Family Guy
- South Park
```
Without any parameters the script will run continously and poll the configured pages evry `interval` seconds.

```console
episode-monitor
```
If the `--once` flag is given to the script, it will run a check for the configured pages and exit.
```console
episode-monitor --once
```

Episode counts will be stored at `$XDG_STATE_HOME/episode_monitor/episode_counts.json` (`~/.local/state/episode_monitor/episode_counts.json` by default).

Logs will be stored at `$XDG_CACHE_HOME/episode_monitor/episode_log.txt` (`~/.cache/episode_monitor/episode_log.txt` by default).

## License

`episode-monitor` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.