semvec/pypi-packages huggingface dataset:
django-migration-inspector 0.0.3
Django extension to inspect validity of migration files
Requires Python: >=3.6

# Django-Migration-Inspector

[![License](https://img.shields.io/badge/License-BSD_3--Clause-blue.svg)](https://opensource.org/licenses/BSD-3-Clause)

Django-Migration-Inspector is a Python package that allows you to validate Django migrations in the command line. 

## Features

- Validates whether Django migration files refer to valid files when defining dependencies or run-after.
- Validates the dependency graph of the migration tree.
- Ensured that migration history for the project on DB is linear.
- Easy to integrate into your Django project.

## Installation

You can install Django-Migration-Inspector using pip:

```bash
pip install django-migration-inspector
```

## Usage
Add `inspector` to the INSTALLED_APPS inside the Django settings.


To use Django-Migration-Inspector, run the following command in your Django project:

```bash
python manage.py inspectmigrations
```
To run all the migration checks.


```bash
python manage.py inspectmigrations --skip-history-check
```
To skip the validation of applied migrations add flag `--skip-history-check`.


```bash
python manage.py inspectmigrations --database=alias
```
Optionally you can provide the alias for the configured database in the Django settings under `DATABASES`.
This ensures that inspection for the consistency of the already applied migrations is run from that particular Database.

## Support and Issues
For bug reports, feature requests, or general questions, please use the [GitHub Issues](https://github.com/SamarthParnami/django-migration-inspector/issues).
pyhagl 0.0.1
Library to describe Gymnasium spaces as Python objects
Requires Python: >=3.8

# Human Abstraction Gymnasium Language (HAGL)
Goal of this library is to simplify work with environment. In some times when you create environment there are 
necessity to use Box space because of library support, simplicity and etc. For example
```
Box(-1, 1, (20,))
```
And then, when implementing step method work with observation as numerical array:
```
position = observation[0:2]
```
Such work could be very uncomfortable. One of the existed solution is to use Dict space:
```
Dict({
    "position": Box(-1, 1, (2,)),
    "velocity": Box(-1, 1, (2,))
})
```
Dict can be transformed in Box space with flatten, unflatten and flatten_space functions from Gymnasium.
With HAGL it can be written in such way:
```
class Observation:
    position = Position()
    velocity = Velocity()
```
This allows to use objects in step function:
```
position = observation.position
```
And then, using compile_type function or HAGLWrapper (for Gymnasium), HAGLParallelWrapper (for PettingZoo) this will be
transformed to Box space. Difference of HAGL and Dict is that:
* Can add method to class and use it in step function
* Can use inheritance
* When describe spaces with HAGL there are possibility to use usual python types for float, bool and arrays
* There are some built-in types, for example Position and Velocity. 

As a result: HAGL can be used to automate transformation of Gymnasium space representation to Python object
gradio-iframe 0.0.10
Experimental empowered iFrame component based on existing HTML gradio component.
Requires Python: >=3.8
Keywords: HTML,gradio-custom-component,gradio-template-HTML,iFrame

# gradio_iframe
A custom gradio component to embed an iframe in a gradio interface. This component is based on the [HTML]() component.
It's currently still a work in progress.

## Usage

The usage is similar to the HTML component. You can pass valid html and it will be rendered in the interface as an iframe, meaning you can embed any website or webapp that supports iframes.
Also, JavaScript should run normal. You can even pass an iframe inside an iframe (see below!), i.e. a youtube or spotify embed.

The size will adjust to the size of the iframe (onload), **this is gonna be a bit delayed**. The width is default at 100%. 
You can also set the height and width manually. 

### Example

```python
import gradio as gr
from gradio_iframe import iFrame

gr.Interface(
    iFrame(
        label="iFrame Example",
        value=("""
        <iframe width="560" 
            height="315" 
            src="https://www.youtube.com/embed/dQw4w9WgXcQ?si=QfHLpHZsI98oZT1G" 
            title="YouTube video player" 
            frameborder="0" 
            allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" 
            allowfullscreen>
        </iframe>"""),
        show_label=True)
)
```

## Roadmap

- [ ] Add manual hand over of other iFrame options.
- [ ] Explore switch between src and srcdoc through variable.

## Known Issues

**There are many reason why it's not a good idea to embed websites in an iframe.**
See [this](https://blog.bitsrc.io/4-security-concerns-with-iframes-every-web-developer-should-know-24c73e6a33e4), or just google "iframe security concerns" for more information. Also, iFrames will use additional computing power and memory, which can slow down the interface.

Also, this component is still a work in progress and not fully tested. Use at your own risk.

### Other Issues

- Height sometimes does not grow according to the inner component.
- The component is not completely responsive yet and struggles with variable heigth.
- ...