semvec/pypi-packages huggingface dataset:
qtforms 0.1.0
pydantic powered forms for Qt
Requires Python: >=3.8

# mikro

[![codecov](https://codecov.io/gh/jhnnsrs/qtforms/branch/master/graph/badge.svg?token=UGXEA2THBV)](https://codecov.io/gh/jhnnsrs/qtforms)
[![PyPI version](https://badge.fury.io/py/qtforms.svg)](https://pypi.org/project/qtforms/)
[![Maintenance](https://img.shields.io/badge/Maintained%3F-yes-green.svg)](https://pypi.org/project/qtforms/)
![Maintainer](https://img.shields.io/badge/maintainer-jhnnsrs-blue)
[![PyPI pyversions](https://img.shields.io/pypi/pyversions/qtforms.svg)](https://pypi.python.org/pypi/qtforms/)
[![PyPI status](https://img.shields.io/pypi/status/qtforms.svg)](https://pypi.python.org/pypi/qtforms/)
[![PyPI download month](https://img.shields.io/pypi/dm/qtforms.svg)](https://pypi.python.org/pypi/qtforms/)

qtforms is a library that allows you to create simple forms in Qt for Python with the help of
pydantic.



### Installation

```bash
pip install qtforms
```


# Quick Start

```python
from qtpy import QtWidgets
from pydantic import BaseModel, validator, Field
import sys

from qtforms.labeled_registry import LabeledWidgetRegistry
from qtforms.form import Form


class MyModel(BaseModel):
    name: str = Field("hundi", min_length=3, max_length=50, description="Your name")
    number: int = Field(1, ge=0, le=100, description="A number between 0 and 100")

    @validator("name")
    def name_must_contain_space(cls, v):
        if " " not in v:
            raise ValueError("Name must have a space")
        return v.title()



if __name__ == "__main__":
    app = QtWidgets.QApplication(sys.argv)

    model = MyModel(name="hello world")
    ##model.events.name.connect(lambda x: print(x))

    form = Form(LabeledWidgetRegistry(), MyModel, initial_data=dict(name="hello world"), auto_validate=True)
    form.submit.connect(lambda x: print(x))

    form.show()
    sys.exit(app.exec_())

```


### Design

For the design of qtform, we use the following design:

`Form` is the container and controller for the form. It calls the widget registry to spawn the widgets for the fields.
These widgets need to follow the `FormWidget` interface, and implement functions to set values and report errors.

`Form` also handles the validation of the form, and emits a `submit` signal when the form is valid and the submit button is pressed
(or when auto_submit is enabled on each valid change). Validation is done by pydantic, and the validated values are immediately
reported to the widgets.
pyliara 1.4.3
This is an unofficial library for Liara Host
Requires Python: ~=3.7


## pyliara

> pyliara library for managing Liara hosts


**Example:**
```python
from pyliara import Liara

app = Liara("liara") #session name


print(app.getMe())
```



### Installing

``` bash
pip3 install -U pyliara
```
quillix 1.0.1
A Database Management System based on Python 3.0 and JSON which stores the data directly on your local computer.

Quillix is a Python package designed for local database management using JSON as the underlying storage format. With Quillix, users can seamlessly create, manage, and query databases through a simplified interface. The package provides a convenient way to perform basic database operations, execute SQL-like queries, and manage data with ease.

Usage

import quillix as qx, then just call the query() function like, qx.query("your query").

    Note: 1. "Alter table" has only column based operations which include "drop", "rename", "add".
          2. In "update table" syntax, "column1 = column1 + value" is written as "column1 + value".
          3. Syntax does not include semi-colon(;) in the end.
          4. Enclose conditions after "where" keyword with brackets.
                Example, "select * from table_name where ((column1 > 5) or (column2 == hello world))"
          5. while using "group by" or "order by" clause, no need to mention the grouping or sorting columns in the column details between "select" and "from" keyword.
          6. "Join" does not work, however you can use object based syntax.
                Example, "select count(b.col4) from a testTable, b testTable2 where (a.col2 == b.col5) group by a.col1"

When you create a database, you will find a data.json file being created in your project directory. It will store all the data that you put in your database.


Complete documentation will be available in a few days.
tti-power-supply 1.0.2
Driver for the TTI QL355P power supply, via USB or LAN
Requires Python: >=3.9,<3.13

TTI Power supply
==================

**Driver for the TTI QL355P power supply**

*Charles Baynham 2023*

This package defines the `TTIPowerSupply` and `TTIPowerSupplyTCP` objects, for
USB and LAN control. Use them e.g. like this::

    d_USB = TTIPowerSupply(id="COM45")
    d_LAN = TTIPowerSupplyTCP(id="10.0.0.0")

    print(d_LAN.get_identity())
mutation 0.4.8
Mutation testing made easy
Requires Python: >=3.10

# 🐛 mutation 🐛

**early draft** requires more testing, please report any findings in
[my public inbox](https://lists.sr.ht/~amirouche/public-inbox).

The goal of `mutation` is to give an idea on how robust, and help
improve test suites.

## Getting started

```sh
pip install mutation
mutation play tests.py --include="foobar/ex.py,foobar/__init__.py" --exclude="tests.py"
```

Then call:

```sh
mutation replay
```

## Usage

```
mutation play [--verbose] [--exclude=<globs>] [--only-deadcode-detection] [--include=<globs>] [--sampling=
] [--randomly-seed=<n>] [--max-workers=<n>] [<file-or-directory> ...] [-- TEST-COMMAND ...]
mutation replay [--verbose] [--max-workers=<n>]
mutation list
mutation show MUTATION
mutation apply MUTATION
mutation (-h | --help)
mutation --version
```

Both `--include` and `--exclude` support glob patterns. They are
optional but highly recommended to avoid the production of useless
mutations. 

`mutation` will only mutate code that has test coverage, hence it
works better with a high coverage.

`mutation` will detect whether the tests can be run in parallel. It is
recommended to make the test suite work in parallel to speed up the
work of `mutation`.

Also, it is better to work with a random seed, otherwise add the
option `--randomly-seed=n` that works.

## TODO

- [ ] Avoid mutations that are syntax errors to improve efficiency,
      use python 3.9+ `ast.unparse`, possibly with `black`;
- [ ] `mutation play` can error even if the code and the test suite is
      valid e.g. removing a docstring will trigger an error: reduce,
      and hopefully eliminate that problem, requires python 3.9+ (see
      above);
- [ ] Add PyPy support;

## Links

- [forge](https://git.sr.ht/~amirouche/mutation)
openbb-provider 1.0.0b1
OpenBB package to execute queries to financial data providers
Requires Python: >=3.8,<4.0

# Table of contents

- [Table of contents](#table-of-contents)
  - [Provider](#provider)
  - [What is Data Standardization?](#what-is-data-standardization)
  - [Key Elements](#key-elements)
  - [Installation](#installation)

## Provider

The OpenBB Provider aims to give a coherent access to financial data providers by introducing standardization procedures.

## What is Data Standardization?

It's like teaching everyone to speak the same language with their data so we can understand and compare it easily.

**Think of it as a part of**:

Data normalization, a bigger way of organizing data.

**What We Do**:

- **Match Column Names and Formats**: Like making sure everyone calls a "closing price" the same thing.

- **For instance**: Some might say "Close", others might say "c". We make sure everyone uses one term.
**Unify Date and Time Styles**: Like having everyone use the same calendar format.

**Example**: Whether it's "YYYY-MM-DD" or "MM-DD-YYYY", we pick one style for everyone.

**What We Don’t Do**:

- **Cleaning Data**: We don't act like data detectives and remove mistakes from what providers give us.

- **Change & Combine Data**: Tweaking data or mixing data from different places.

## Key Elements

- **QueryParams** : The input model for a particular query. To load equity market data, we would have `EquityPriceQueryParams`, which would have fields like `symbol`, `start_date`, and `end_date`. You can find the standard query params inside the `standard_models` directory.
- **Data** : The output model of a particular query. Equity market data would be `EquityPriceData` and have fields such as `Open`, `High`, `Low`, `Close`, and `Volume`. You can find the standard data models inside the `standard_models` directory.
- **Fetcher** : Class containing a set of methods to receive query parameters, extract data and transform it. This class is responsible for implementing the standardization procedures.
- **Provider** : Entry point class for each provider extension. Contains information about the provider, it's required credentials and available fetchers.
- **RegistryLoader** : Loads the registry with the installed provider extensions.
- **Registry** : Maintains a registry of provider extensions installed.
- **RegistryMap** : Stores the complete characterization of each provider. It centralizes information like required credentials, standardized and extra query parameters/data by provider.
- **QueryExecutor** : Executes a given query, routing it to the respective provider and fetcher.

## Installation

To install the provider, run the following command in this folder:

```bash
pip install .
```