semvec/pypi-packages huggingface dataset:
better-dash-callback 0.1.5
Runs clientside callback functions in Dash applications using Python syntax, eliminating the need for inline JavaScript.

# better-dash-callback

A library that enables running clientside callback functions in Dash applications using Python syntax, eliminating the need for inline JavaScript.

## Problem

When building Dash applications, you often need to write clientside callback functions using inline JavaScript. This can be cumbersome and error-prone, especially for complex logic. Moreover, inline JavaScript code lacks syntax highlighting and debugging capabilities.

## Solution

`better-dash-callback` provides a solution to this problem by allowing you to write clientside callback functions using Python syntax. This makes your code more readable, maintainable, and efficient.

## Dependencies

`better-dash-callback` depends on `metapensiero.pj`, a Python-to-JavaScript compiler that allows you to write Python code that can be executed in a JavaScript environment.

## Supported Python-to-JavaScript Syntax

The supported Python-to-JavaScript syntax is listed in the [metapensiero.pj documentation](https://github.com/metapensiero/metapensiero.pj). This includes support for many Python features, such as functions, classes, loops, and conditional statements.

## Example

Let's consider a simple example where we want to update the text of a component based on the value of an input component.

**Using Dash's `clientside_callback`**

```python
from dash import clientside_callback

clientside_callback(
    """
    function(value) {
        return 'You entered: ' + value;
    }
    """,
    Output("output", "children"),
    Input("input", "value")
)
```

**Using `better-dash-callback`**

```python
from better_dash_callback import callback

@callback(
    Output("output", "children"),
    Input("input", "value"),
    clientside=True
)
def update_output(value):
    return f"You entered: {value}"
```

As you can see, the `better-dash-callback` example is more elegant and easier to read. You can write your callback function using Python syntax, without having to worry about inline JavaScript code, and the code you write also includes all the python syntax highlighting rather than being javascript code inside of a python string.

The `callback` function takes the following additional arguments:

* `clientside`: A boolean indicating whether the callback should be executed on the client-side (default is `False`).
* `disable_es6`: A boolean indicating whether to disable ES6 syntax in the generated JavaScript code and revert back to ES5 support (default is `False`).
* `enable_stage3`: A boolean indicating whether to enable Stage 3 syntax in the generated JavaScript code (default is `False`).
* Any arguments and keyword-arguments supported by `dash.callback` are also supported by `better-dash-callback.callback`

## Installation

To install `better-dash-callback`, you can use `pip`:

```bash
pip3 install better-dash-callback
```

## License

`better-dash-callback` is licensed under the MIT License.
ironbeam 0.1.2
Add your description here
Requires Python: >=3.11

# Ironbeam

The provides an unofficial python wrapper around [Ironbeam's](https://www.ironbeam.com/) API for
futures.

**This is a work in progress.**

Key features include:

- Account Information
- Orders, both Live orders on your Ironbeam account or use a Demo account that can be created
  with the API.
- Historical Data
- Streaming Data.

## Documentation

Make sure you are familiar with the [Ironbeam Official API Docs](https://docs.ironbeamapi.com/).
There are some typos and stuff with the docs so it took a little detective work to figure this
out. If you see something that doesn't look in this library it might be because the docs are
wrong.

## Roadmap

- Async support
- Documentation
- Community

## Requirements

- httpx = '>=0.28.1'
- pandas = '>=2.2.3'
- pydantic = '>=2.10.4'

## Installation

To install the latest stable version of the package from PyPi:

```bash
pip install -U ironbeam
```

## Usage

```python
# Basic usage
import ironbeam as ib

client = ib.Ironbeam(apikey='<API KEY>')
client.authorize(username='<USERNAME>')
print(client.token)

# Use client...

client.logout()

# Context manager usage
with ib.Ironbeam(apikey='<API KEY>') as client:
  client.authorize(username='<USERNAME>')
```

## Contact

Feel free to [contact us](mail_to:davidmckim@gmail.com) with any questions.
aircheck 0.1.2
Tool and pre-commit hook airflow DAG integrity validation
Requires Python: <3.13

# aircheck

A tool for airflow DAG integrity validation.

The aim of the project is two-fold:

- enable the users to run checks that would fail locally, before they fail in the airflow UI
- allow to enforce standards related to certain DAG properties.

The first part involves:
- checking if modules containing DAGs are properly loaded (i.e. no `ImportErrors` etc.)
- checking for cycles in DAGs
- checking for duplicated DAGs

The latter allows users to enforce that:
- all DAGs have IDs starting with a certain prefix (e.g. indicating the team developing the DAG)
- DAG IDs don't contain whitespaces (those can confuse the airflow UI)
- every DAG has at least one task associated with it (i.e. there are no 'empty' DAGs).

## Installation

### PyPI

`aircheck` can be installed with `pip`.

```bash
pip install aircheck
```

### From source

Another option is to install `aircheck` from the source GitHub repo.

```bash
git clone https://github.com/AleksanderWWW/aircheck.git
cd aircheck && pip install .
```

Optionally install `dev` requirements, like `pytest`, `ruff` etc.
```bash
cd aircheck && pip install .[dev]
```

## Usage

After a successful installation, the project can be used in three main ways.

### Commandline tool

```bash
aircheck ./dags/dag1.py ./dags/dag2.py --check-whitespace --dag-id-prefix <prefix>
```

### Pre-commit hook

```yaml
- repo: https://github.com/AleksanderWWW/aircheck
  rev: v0.1.2
  hooks:
    - id: aircheck
      args: ["--check-empty-dags", "--dag-path" "<non-standard path>"]
```

### Python package

```python
from aircheck.core.checks import check_for_duplicated_dags, check_for_empty_dag
from aircheck.core.load import load_dags

dags = load_dags(["./dags/dag1.py", "./dags/dag2.py"])

check_for_duplicated_dags(dags)

for dag in dags:
    check_for_empty_dag(dag)
```