semvec/pypi-packages huggingface dataset:
vardelta-jacobzufall 1.0
A package used to track the history of a variable.
Requires Python: >3.12

# VarDelta
VarDelta is a library that allows you to easily track and access the history of a variable.

## Purpose
The purpose of VarDelta is to make arrays more user-friendly to those using Python as a tool rather than a programming
language. VarDelta was built to be used in PyActy, which is a library designed for accountants. By using VarDelta, it
makes it easier for an accountant to understand what the code is doing.

### Example
Without VarDelta, you could just as easily give a variable a history like so:
```python
# Create a variable with an initial value of 10.
x: list[int] = [10]
# Change the value of the variable to 5.
x.append(5)
# Access the current value of the variable.
print(x[-1])
# Access the previous value of the variable.
print(x[-2])
```
While this works perfectly fine, it may not be as easily understood by people with no prior familiarity with a
programming language. We can use VarDelta to do the exact same thing.
```python
from vardelta import Delta

# Create a variable with an initial value of 10.
x: Delta = Delta(10)
# Change the value of the variable to 5.
x.change_value(5)
# Access the current value of the variable.
print(x.get_value())
# Access the previous value of the variable.
print(x.get_value(1))
# You could also do:
print(x.value)
```
The two code snippets above do the exact same thing. The logic behind the `get_value()` function is that it retrieves
the value of the variable `n` amount of changes ago. By default, it'll get the value of the variable 0 changes ago, or
the current value. If we pass 1 in as an argument, we get the variable as it were 1 change ago.

Similar to an array, negative numbers retrieve from the opposite end of the array that positive numbers do, except the
opposite end is the beginning, and not the end of the array.
```python
# Retrieves the first value that the variable ever was.
print(x.get_value(-1))
```
This still sort of makes sense, as -1 retrieves the first value the variable was, -2 retrieves the second value the
variable was, and so on.

*Remember, it's not intended to make sense from a programmer's perspective.*
LangChainKaltura 0.0.1rc2
Collects captions from media in Kaltura and produces LangChain `Document` objects.
Requires Python: >=3.11.8

# LangChainKaltura

A LangChain vector store loader for captions of videos hosted in Kaltura (the basis of UMich's MiVideo service).

## Installation

```shell
pip install LangChainKaltura
```

## Usage

Instantiate `KalturaCaptionLoader` with all the required parameters, then invoke its `load()` method…

```python
import os

from LangChainKaltura import \
    KalturaCaptionLoader

captionLoader = KalturaCaptionLoader(
    os.getenv('PARTNERID'),
    os.getenv('APPTOKENID'),
    os.getenv('APPTOKENVALUE'),
    KalturaCaptionLoader.FilterType(
        os.getenv('FILTERTYPE')),
    os.getenv('FILTERVALUE'),
    os.getenv('URLTEMPLATE'))

documents = captionLoader.load()
print(documents)
```

See the repo for `example.py`, a more detailed example which reads parameters from `.env` (based on `.env.example`) and prints the results as JSON.

## Features

(See issue [#1](https://github.com/umich-its-ai/langchain_kaltura/issues/1) for the most current list of requirements and their completion status.)

* Connecting to Kaltura requires an app token.
* It works only with captioned media, which was presumably written by or approved by media owners.  At this time, only SRT captions are supported.
* Captions from media are reorganized into chunks.  The chunk duration is configurable, with a default of two minutes.
* It returns a list of LangChain `Document` object(s), each containing a caption chunk and metadata.
* Caption chunks' metadata contains source URLs to the media, which includes timestamps to the specific chunk of the video.

## Test Suite

Run the `testing` submodule to see a complete test of the `KalturaCaptionLoader`, which includes mocking of the Kaltura API.

```shell
python -m tests
```

## Credits

* Mr. Lance E Sloan (@lsloan) - Development
* Melinda Kraft - Kaltura advising
gradio-clickable-arrow-dropdown 0.0.3
Dropdown component where clicking arrow on the side displays dropdown options
Requires Python: >=3.8
Keywords: gradio-custom-component, gradio-template-Dropdown


# `gradio_clickable_arrow_dropdown`
Dropdown component where clicking arrow on the side displays dropdown options

## Installation

```bash
pip install gradio_clickable_arrow_dropdown
```

## Usage

```python

import gradio as gr
from gradio_clickable_arrow_dropdown import ClickableArrowDropdown

def handle_inputs(reg_dropdown_val, custom_dropdown_val):
    res = f"""
    Regular dropdown value: {reg_dropdown_val}
    Custom dropdown value: {custom_dropdown_val}
    """

    return res

choices = ["Option 1", "Option 2", "Option 3"]

demo = gr.Interface(
    handle_inputs,
    [
        gr.Dropdown(choices=choices, value=choices[0], filterable=False), 
        ClickableArrowDropdown(choices=choices, value=choices[0], filterable=False)
    ],
    gr.Textbox(),
)

if __name__ == "__main__":
    demo.launch()

```