semvec/pypi-packages huggingface dataset:
vhip_light 1.0.0
Variable-height inverted pendulum balancing in Python.
Requires Python: >=3.8
Keywords: inverse,kinematics,pinocchio

# VHIP balancing in Python

Python code for [Biped Stabilization by Linear Feedback of the Variable-Height Inverted Pendulum Model](https://arxiv.org/abs/1909.07732).

The main script unrolls VHIP trajectories with different balance controllers and reproduces plots as in the paper:

![image](https://github.com/stephane-caron/vhip_light/assets/1189580/8a12ac28-3402-4b7a-92ea-9e46e18849b3)

This repository is a lighter implementation of the original script [vhip\_stabilization.py](https://github.com/stephane-caron/pymanoid/blob/2cbce7441f377a18119837dfeee51662654c6ce7/examples/vhip_stabilization.py) that was released with the paper.

## Installation

The recommended way is to use Conda:

```console
conda create -f environment.yaml
conda activate vhip_light
```

Alternatively, you can install all dependencies from PyPI:

```console
pip install cvxpy ipython matplotlib qpsolvers scipy
```

## Usage

```console
python main.py
```

## See also

- [vhip\_stabilization.py](https://github.com/stephane-caron/pymanoid/blob/2cbce7441f377a18119837dfeee51662654c6ce7/examples/vhip_stabilization.py): original Python prototype as a single script, with dependencies on OpenRAVE and pymanoid (now deprectated).
- [VHIP walking controller](https://github.com/stephane-caron/vhip_walking_controller): C++ version of the VHIP QP balancer that was validated on the HRP-4 humanoid robot.
htmlwhat 1.0.2
Verify HTML code submissions and auto-generate meaningful feedback messages.
Keywords: htmlwhat,html,feedback,html validation,testing,html testing

[![PyPI version](https://badge.fury.io/py/htmlwhat.svg)](https://badge.fury.io/py/htmlwhat)

# htmlwhat

`htmlwhat` is a Python module that provides feedback on incorrect HTML code submissions. It's often used in educational platforms where students submit HTML code as part of their assignments or exercises.

## Installation

```
# latest stable version from PyPi
pip install htmlwhat

# latest development version from GitHub
pip install git+https://github.com/arlarse/htmlwhat
```

## Quick Start
```python
from htmlwhat.test_exercise import test_exercise

userhtml = """
<!DOCTYPE html>
<html>
    <head>
        <title>Title</title>
    </head>
    <body class="hello">
        <h1>My First Heading</h1>
    </body>
</html>
"""

solutionhtml = """
<!DOCTYPE html>
<html>
    <head>
        <title>Title</title>
    </head>
    <body class="example">
        <h1>My First Heading</h1>
    </body>
</html>
"""

test = "Ex().check_body().has_equal_attr()"

print(test_exercise(
    test,
    userhtml,
    solutionhtml,
))
```
Output:
```json
{'correct': False, 'message': 'Inspect the <code>&lt;body&gt;</code> tag. Expected attribute <code>class</code> to be <code>"example"</code>, but found <code>"hello"</code>.'}
```

## Problems after installation

htmlwhat built over ``protowhat`` which uses ``jinja2==2.11.3``, and jinja uses ``MarkupSafe==2.0.1``.
Hence you will face this error

```
ImportError: cannot import name 'soft_unicode' from 'markupsafe'
```

so install the latest version of jinja2 using the following command:

```
pip install --upgrade jinja2
```
sequence-stk 0.7.2
A virtual stack machine that executes Python code based on instructions provided in a JSON file.

# Overview

Sequence is a library that lets you build analysis tools that can be controlled by configuration files.
This is useful when you want to define the logic for generating some sort of output, like data or an image, in a configuration file.
This type of configuration file is called a *sequence* and it defines a sequence of operations that do something.


Under the hood, sequences are run by a virtual stack machine.
A sequence is a list of *operations*, where an operation is either another sequence or a *method*.
A method is a Python function that uses the `@sequence.method` decorator and methods provide basic functionality building blocks.
Methods and sequences pass data to each other on the virtual machine's stack, via pushing, popping, and swapping data.

A *sequence toolkit (STK)* is a Python package that provides a suite of methods.
The *standard toolkit* (built-in) is a suite of turing-complete methods that provide the backbone for scripting logic in sequences (e.g., if blocks, while loops, string formatting, data resources, etc.).
Additional functionality can be added by installing additional toolkits.

## About Stack Machines

If it isn't clear how operations pass data using the stack, a good way to get familiar with the concept is by playing around with an RPN calculator like [this](http://www.alcula.com/calculators/rpn/). Try calculating the hypotenuse of a triangle with side length of 3 and 4 using the Pythagorean Theorem (the answer is *3, Enter, X, Enter, 4, Enter, X, +, SQRT*). Every button-press is equivalent to an operation in sequence.

The design of sequence took inspiration from these old RPN-style calculators as well as the
[FORTH](https://en.wikipedia.org/wiki/Forth_(programming_language)) programming language.


## Installing sequence
Sequence can be install using `pip`. The basic install supports JSON.

```console
$ pip install sequence-stk
```

It's often useful to be able to write comments and use multi-line strings in sequences.
JSON5 and HSON are extensions of JSON that support these features. 
Additional configuration languages can be installed via the `json5`, and/ord `hson` extras.

```console
$ pip install "sequence[json5,hson]"
```

If you are developing an STK, the `dev` and `docs` extras install the requirements for running tests and building documentation.

```console
$ pip install "sequence[dev,docs]"
```
openbb-orats 1.0.1
Connecting OpenBB to ORATS Option Data Source
Requires Python: >=3.8.1,<3.12

# openbb-orats Package

## Introduction

The openbb-orats package is a specialized extension designed for the OpenBB Platform, focusing on integrating options data and analytics from ORATS (Options Research & Technology Services). This package serves as a bridge, allowing users to access and manipulate options data seamlessly within the OpenBB Platform environment.

Key features include:

* Retrieving options data including pricing, Greeks, and implied volatility
* Performing advanced options analytics
* Accessing historical options data and trends
* Customizable queries for specific data retrieval

## Getting Started

To effectively utilize the openbb-orats package, familiarize yourself with its core components and functionalities:

* `openbb_orats/router.py` - Defines the routes for data retrieval and analytics commands.
* `openbb_orats/provider.py` - Manages data fetching from ORATS API.
* `openbb_orats/models/` - Contains models for structuring the options data.
* `openbb_orats/__init__.py` - Initializes the package, making it ready for use within the OpenBB Platform.
caat 0.2.1
CAAT: Commands as Arrow Types, a FFI that works across languages.
Requires Python: >3.6

# CAAT for Python
Commands as Arrow Types for Python

CAAT provides a way for programs to call each other regardless of the language used as if they were functions.
This is the library for the Python language, it provides the required classes, functions, and variables for calling 
foreign code or for making your scripts callable from foreign code.


## How it works
When you call a foreign command, an environment variable called `CAAT_ARGS` is set with a JSON string that represents the arguments passed into the function. They are also passed in via the command line arguments but this is for legacy reasons. The JSON string gets parsed into a format that the language can understand.
At the same time, the caller opens up a socket at `/tmp/caat_pid` where pid is the pid of the caller process. This is set as the `CAAT_SOCKET` variable which is also passed into the callee. When the callee is done with what it is doing, it should call the function or macro that will write the return value back to the caller. This will also end the program.


## Examples
#### Script 1
```python
import caat

ff = caat.ForiegnFunction('python')

return_value = ff('other.py', 1, [1, 2, 3])

print(return_value)
```

#### Script 2
```python
import caat

caat.return_caat(caat.argv[2])
```

#### Output
```
python script.py
[1, 2, 3]
```
basel 1.1.2
Report Architecture Data
Requires Python: >=3.10,<4.0
Keywords: report

# Basel Library

![Basel Logo](https://github.com/iramluism/basel/raw/main/docs/images/logo.png)

Basel Library is a powerful tool designed for calculating, reporting, and analyzing the architecture of a project.

## Key Concepts

* **Abstraction**: Level of definition vs implementation inside a component.
* **Stability**: Level of incoming and outgoing dependencies that a component has.

## Installation

```bash
pip install basel
```

## Reports
Abstract/Instability and Component Relationship reports are the main data you can obtain from an architecture. To generate each one, you can use the report and rel options.

### Abstraction/Stability (AE) Report
```
basel report --path ./path/to/project
```
Output:
```
Component                                   I     A     E
----------------------------------------  ----  ----  ----
path/to/project/module1                  0.75   0.2   0.05
path/to/project/module2                     1   0.8   0.8
path/to/project/module3                   0.5     1   0.5
----------------------------------------  ----  ----  ----
Mean                                     0.75  0.67  0.45
```

### Component Relationship (CRel) Report
This report uses a binary matrix, where 1 represents a relation, and 0 does not. All components are assigned to an index. Check the legend below the report to identify each component.

```
basel rel --path ./path/to/project
```
Output:
```
  Components    1    2    3  
------------  ---  ---  ---
           1    0    1    0  
           2    0    0    1  
           3    0    0    0  

Labels:
1: path/to/project/module1
2: path/to/project/module2
3: path/to/project/module3
```

## Formatting
To define a format use the `--format` or the abbreviation `-fmt`.

| Format        | Reports  | Description               |
|:------------- |:--------:|--------------------------:|
| basic         | AE, CRel | Basic and default format  |
| html          | AE, CRel | HTML format               |
| mean_i        | AE       | Only Instability Mean     | 
| mean_a        | AE       | Only Abstraction Mean     |
| mean_e        | AE       | Only Error Mean           |
| mean          | AE       | Only Error Mean           |
| uml           | CRel     | UML code                  |


## Excluding 
You can exclude components in your project, which can be helpful to define boundaries. To exclude, you can use the `-e` or `--exclude` argument.


## Filtering 
Is posible that the report results are very long, to get your desired components you can use the `-f` or `--filter` arguments.


## Contributing

We welcome contributions! If you'd like to contribute to Basel, please follow these guidelines:

1. Fork the repository.
2. Create a new branch for your feature or bug fix.
3. Make your changes and commit them with clear messages.
4. Submit a pull request.

Thank you for your contribution!

## Contact

If you have any questions or suggestions, feel free to insert new issue.


## License

This project is licensed under the [MIT License](LICENSE).