semvec/pypi-packages huggingface dataset:
central-das-emendas-teste 0.1.0
Baixa e carrega em DataFrame o CSV de emendas do Google Drive
Requires Python: >=3.9

\# central\_das\_emendas\_teste



Pequena biblioteca que baixa o CSV da \*\*Central das Emendas\*\* (hospedado

no Google Drive) e devolve um `pandas.DataFrame`.



\## Instalação para desenvolvedores



```bash

git clone https://github.com/SEU\_USUARIO/central\_das\_emendas\_teste.git

cd central\_das\_emendas\_teste

pip install -e .

#
llm-tools-yt-transcript 0.1
Make YouTube transcripts available to llm
Requires Python: >=3.9

# llm-tools-yt-transcript

[![PyPI](https://img.shields.io/pypi/v/llm-tools-yt-transcript.svg)](https://pypi.org/project/llm-tools-yt-transcript/)
[![Changelog](https://img.shields.io/github/v/release/rupello/llm-tools-yt-transcript?include_prereleases&label=changelog)](https://github.com/rupello/llm-tools-yt-transcript/releases)
[![Tests](https://github.com/rupello/llm-tools-yt-transcript/actions/workflows/test.yml/badge.svg)](https://github.com/rupello/llm-tools-yt-transcript/actions/workflows/test.yml)
[![License](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](https://github.com/rupello/llm-tools-yt-transcript/blob/main/LICENSE)

Makes YouTube transcripts available to [LLM](https://llm.datasette.io/)

This is useful for generating a quick overview of a YouTube video before deciding to watch it

Note: this uses [the youtube-transcript-api library](https://pypi.org/project/youtube-transcript-api/) with this caveat:

    This code uses an undocumented part of the YouTube API, which is called by the YouTube web-client. So there is no guarantee that it won't stop working tomorrow, if they change how things work. I will however do my best to make things working again as soon as possible if that happens. So if it stops working, let me know!

## Installation

Install this plugin in the same environment as [LLM](https://llm.datasette.io/).
```bash
llm install llm-tools-yt-transcript
```
## Usage

To use this with the [LLM command-line tool](https://llm.datasette.io/en/stable/usage.html):

```bash

# basic example
llm --tool yt_transcript "summarize this video: https://www.youtube.com/watch?v=kaMKInkV7Vs"  --tools-debug

# a more sophisticated report
cat yt-digest-prompt-template.txt | llm --save yt-digest
llm -t yt-digest "https://www.youtube.com/watch?v=kaMKInkV7Vs" -T yt_transcript -x > example-report.html

```

With the [LLM Python API](https://llm.datasette.io/en/stable/python-api.html):

```python
import llm
from llm_tools_yt_transcript import yt_transcript

model = llm.get_model("gpt-4.1-mini")

result = model.chain(
    "Example prompt goes here",
    tools=[yt_transcript]
).text()
```

## Development

To set up this plugin locally, first checkout the code. Then create a new virtual environment:
```bash
cd llm-tools-yt-transcript
python -m venv venv
source venv/bin/activate
```
Now install the dependencies and test dependencies:
```bash
llm install -e '.[test]'
```
To run the tests:
```bash
python -m pytest
```
torch-bessel 0.0.8
PyTorch extension package for Bessel functions with arbitrary real order and complex inputs
Requires Python: >=3.9

# About
PyTorch extension package for modified Bessel functions of the second kind with complex inputs

# Install
Currently only supports Linux (with CUDA 12.4) or MacOS (Apple silicon, cpu only) with python >= 3.9, <= 3.12.
```
pip install torch-bessel
```

# Example
```
import torch_bessel

real, imag = torch.randn(2, 5, device="cuda")
z = torch.complex(real.abs(), imag)  # correctness for inputs in the left-half complex plane is not gauranteed.
torch_bessel.ops.modified_bessel_k0(z)
```

# Implemented functions
- `modified_bessel_k0`: Same as `torch.special.modified_bessel_k0`, but also handles backpropagation and complex inputs on cpu and cuda. Correctness is guaranteed on the right-half complex plane for double types, and almost guaranteed for float types, though it appears there are a very small handful of inputs which result in NaNs which needs to be fixed. On cuda, `torch.chalf` inputs are also supported, though the underlying cuda kernel just upcasts `chalf` to `cfloat` (note that this uses no extra GPU memory, as opposed to manually casting torch.chalf to torch.cfloat before calling `modified_bessel_k0` which doubles the GPU memory used). On the left-half complex plane, function output appears mostly correct, but with small numerical errors for certain inputs. On the negative real line, output is NaN.
- `modified_bessel_k1`: Same as `torch.special.modified_bessel_k1`, but also handles complex inputs on cpu and cuda. Backpropagation not implemented, but this can be easily manually implemented yourself by writing a torch.autograd.Function using the recurrence properties of bessel functions. Same caveats as `modified_bessel_k0` apply.

# WIP
- `modified_bessel_kv`: Analogue of `scipy.special.kv`.

# Benchmarks
Benchmarking performed with the `asv` package. Results can be viewed at https://hchau630.github.io/torch-bessel.