semvec/pypi-packages huggingface dataset:
natrix 0.1.9
A Vyper linter for fine sneks.
Requires Python: >=3.10

# Natrix

Natrix is a vyper linter that checks for common mistakes in vyper contracts. It is designed to be your vyper copilot, helping you to write code that is more secure and efficient.

## Installation

You can install Natrix using pip:

```bash
pip install natrix
```

Currently natrix requires [`uv`](https://docs.astral.sh/uv/) to be installed to function correctly.

### Vyper Version Compatibility

Natrix supports Vyper compiler versions 0.4.0 and above.

## Usage

To check a contract:

```bash
natrix lint file_to_lint.vy
```

To check all vyper contract in the current directory:

```bash
natrix lint
# or simply
natrix
```

To generate explicit exports for a contract:

```bash
natrix codegen exports path/to/contract.vy
```

### Command Line Options

```bash
natrix --help                         # Show help message
natrix --version                      # Show version information
natrix lint --list-rules               # List all available rules
natrix lint --disable NTX1 NTX2       # Disable specific rules
natrix lint --rule-config RuleName.param=value  # Configure rule parameters
natrix lint -p /path/to/libs /another/path  # Add extra paths for imports
natrix codegen exports contract.vy    # Generate explicit exports
```

## Configuration

You can configure Natrix using a `pyproject.toml` file in your project root:

```toml
[tool.natrix]
# Files or directories to lint (relative to pyproject.toml)
files = ["contracts/", "tests/contracts/"]

# Additional paths to search for imports
path = ["lib", "vendor/contracts"]

# Rules to disable
disabled_rules = ["NTX1", "NTX2"]

# Rule-specific configurations
[tool.natrix.rule_configs.RuleName]
param = "value"
```

## Pre-commit hook

Natrix can also be used as a [pre-commit hook](https://pre-commit.com/). This allows to have your contracts checked automatically before you can commit.

To add natrix just add the following lines to your `pre-commit-config.yaml` config file:
```yaml
repos:
  - repo: https://github.com/albertocentonze/natrix
    rev: v0.1.9  # Use the latest version
    hooks:
      - id: natrix
```

and then install pre-commit in your repository by doing:
```bash
pre-commit install
```

## Disclaimer

Natrix is highly experimental software, I do not take any responsibility for changes to the codebase suggested by this linter that might lead to loss of funds or any other issue.
retryCommand 0.1.0
It is a Python library that allows you to retry executing a command multiple times until it succeeds or reaches the maximum number of retries. It provides options to customize the behavior of retries, such as setting a timeout for each execution and specifying the return codes that indicate success.
Requires Python: >=3.8
Keywords: cli, command line, retry, rich

# Retry Command

## Introduction

Retry Command is a Python library that allows you to retry executing a command multiple times until it succeeds or reaches the maximum number of retries. It provides options to customize the behavior of retries, such as setting a timeout for each execution and specifying the return codes that indicate success.

## Installation

To use Retry Command, you need to have Python installed on your system. You can install the library using pip:

```bash
pip install retryCommand
```

## Usage

Retry Command can only be used as a standalone script

### Standalone Script

To use Retry Command as a standalone script, you can run the following command:

```bash
do-retry [options] -c <command>
```

Replace `<command>` with the command you want to execute. You can also specify various options to customize the behavior of retries. Use the `-h` or `--help` option to see the available options and their descriptions.

## Options

Retry Command provides several options to customize the behavior of retries:

- `-s, --no-stop-after-success`: Do not stop retrying after the command succeeds.
- `-p, --no-ignore-process-error`: Do not stop retrying after encountering a process error.
- `-m, --max-num-of-retry`: Maximum number of retries. Set to -1 for unlimited retries.
- `-i, --interval`: Interval between retries in seconds.
- `-t, --time-out`: Timeout for each execution in seconds. Set to -1 for no timeout.
- `-d, --cwd`: Current working directory for the command.
- `-n, --success-return-code`: Return codes that indicate success. Multiple values can be specified.
- `-q --quite`: mute more output.
- `--mute`: mute all output.
- `-l, --no-need-to-log`: Does not output any records outside of stdou. It only works when mute is on.
- `-c, --command`: Command to execute.

## Examples

Here are some examples of how to use Retry Command:

- Retry executing a command until it succeeds, ignoring process errors:

```bash
do-retry -c <command>
```

- Retry executing a command with a maximum of 3 retries, an interval of 2 seconds, and a timeout of 5 seconds:

```bash
do-retry -m 3 -i 2 -t 5 -c <command>
```

## License

Retry Command is licensed under the MulanPSL-2.0 License. See the [LICENSE](LICENSE) file for more information.
bcn-rainfall-api-client 1.0.9
Client who serves routes from the Barcelona Rainfall API.
Requires Python: >=3.12

# bcn-rainfall-api-client

[![PyPI version](https://badge.fury.io/py/bcn-rainfall-api-client.svg)](https://badge.fury.io/py/bcn-rainfall-api-client)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
[![uv](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/uv/main/assets/badge/v0.json)](https://github.com/astral-sh/uv)
[![mypy](https://www.mypy-lang.org/static/mypy_badge.svg)](https://mypy-lang.org/)

Client who serves routes from the [Barcelona Rainfall API](https://github.com/paul-florentin-charles/bcn-rainfall-api); it is recommended to use it to retrieve rainfall data instead of directly calling the API code.

## Usage

```python
from bcn_rainfall_api_client import APIClient

# You can replace base_url with your own instance URL if you have one running
base_url = "https://bcn-rainfall-api.onrender.com/rest"

# Instantiate client
api_clt = APIClient(base_url=base_url)

# Have fun with client!
data = api_clt.get_rainfall_average(
    time_mode="yearly",
    begin_year=1991,
    end_year=2020
)
print(data)
...
```

### About time-related parameters

```python
time_mode = "monthly"
month = "may"
season = "winter"

assert time_mode in ["yearly", "seasonal", "monthly"]
assert month in ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"]
assert season in ["winter", "spring", "summer", "fall"]
```
ej2-streamlit-grids 30.1.37
Streamlit component implementation of Syncfusion® Grid
Requires Python: >=3.6

# Syncfusion® Streamlit Grid Component

Syncfusion® Streamlit Grid component is a powerful control that allows you to display data in a tabular format with rich features.

## Installation

You can install the Syncfusion® Streamlit Grid component using the following command:

```bash
pip install ej2-streamlit-grids
```

## Demo

To get started with the Syncfusion® Grid component in Streamlit, refer to the [GitHub](https://github.com/SyncfusionExamples/Getting-started-with-Syncfusion-Grid-component-in-Streamlit-app) repository. The provided example demonstrates the usage of the Grid component along with additional features.

![Streamlit Grid Component](https://raw.githubusercontent.com/SyncfusionExamples/Getting-started-with-Syncfusion-Grid-component-in-Streamlit-app/master/images/ej2_streamlit_grids_demos.gif)

## Support

Product support is available for through following mediums.

* Creating incident in Syncfusion® [Support system](https://support.syncfusion.com/) or [Community forum](https://www.syncfusion.com/forums/react-js2?utm_source=npm&utm_campaign=ej2-streamlit-ui-components).
* Ask your query in [Stack Overflow](https://stackoverflow.com/) with tag `syncfusion` and `ej2`.

## License

Please refer to the [license](https://github.com/syncfusion/ej2-streamlit-components/blob/master/license) for detailed information about the Syncfusion® Essential Studio® license and copyright.

© 2025 Syncfusion®, Inc. All Rights Reserved.
fontFeatures 1.9.0
Python library for manipulating OpenType font features

## `fontFeatures` library

*If you're looking for the FEE language, it has been renamed to FEZ and moved to its own library (fez).*

OpenType fonts are "programmed" using features, which are normally authored in Adobe's [feature file format](http://adobe-type-tools.github.io/afdko/OpenTypeFeatureFileSpecification.html). This like source code to a computer program: it's a user-friendly, but computer-unfriendly, way to represent the features.

Inside a font, the features are compiled in an efficient [internal format](https://simoncozens.github.io/fonts-and-layout/features.html#how-features-are-stored). This is like the binary of a computer program: computers can use it, but they can't do else anything with it, and people can't read it.

The purpose of this library is to provide a middle ground for representing features in a machine-manipulable format, kind of like the abstract syntax tree of a computer programmer. This is so that:

* features can be represented in a structured human-readable *and* machine-readable way, analogous to the XML files of the [Unified Font Object](http://unifiedfontobject.org/) format.
* features can be more directly authored by programs (such as font editors), rather than them having to output AFDKO feature file format.
* features can be easily manipulated by programs - for example, features from two files merged together, or lookups moved between languages.

> How is this different from fontTool's `feaLib`? I'm glad you asked. `feaLib` translates between the Adobe feature file format and a abstract syntax tree representing *elements of the feature file* - not representing the feature data. The AST is still "source equivalent". For example, when you code an `aalt` feature in feature file format, you might include code like `feature salt` to include lookups from another feature. But what's actually *meant* by that is a set of lookups. `fontFeatures` allows you to manipulate meaning, not description.

### Components

fontFeatures consists of the following components:

* `fontFeatures` itself, which is an abstract representation of the different layout operations inside a font.
* `fontFeatures.feaLib` (included as a mixin) which translates between Adobe feature syntax and fontFeatures representation.
* `fontFeatures.ttLib`, which translates between OpenType binary fonts and fontFeatures representation. (Currently only OTF -> `fontFeatures` is partially implemented; there is no `fontFeatures` -> OTF compiler yet.)
* `fontFeatures.fontDameLib` which translate FontDame text files into fontFeatures objects.

And the following utilities:

* `otf2fea`: translates an OTF file into Adobe features syntax.
* `txt2fea`: translates a FontDame txt file into Adobe features syntax.