semvec/pypi-packages huggingface dataset:
rapidchecker 0.1.5
Grammar and format checker for ABB RAPID code. 
Requires Python: >=3.10

# rapidchecker
Grammar and format checker for ABB Rapid code.

- 🔎 Checks ABB RAPID code (.sys modules)
- 🦾 Tested with RobotWare 5 code.
- 🐍 Powered by Python and [pyparsing](https://github.com/pyparsing/pyparsing).

## Features

`rapidchecker` checks for:

- Code that violates the ABB RAPID grammar.
- Bad indentation.
- Lowercase keywords (`if` instead of `IF`, `module` instead of `MODULE` etc)
- Trailing space.
- Too many empty lines.

## Getting started

Install with `pip install rapidchecker`

Then check a RAPID module (or a directory containing modules) by running

```bash
python -m rapidchecker <path-to-file-or-dir>
```

If any grammar or format errors are found, they are printed to stdout and the command exits with exitcode 1.

## Configuration

You can enable/disable different checks by adding a `rapidchecker.toml` file to the folder in which rapidchecker runs.

See [rapidchecker.template.toml](rapidchecker.template.toml) for reference.

## References

- ABB RAPID [docs](https://library.e.abb.com/public/f23f1c3e506a4383b635cff165cc6993/3HAC050946+TRM+RAPID+Kernel+RW+6-en.pdf?x-sign=oUq9VZeSx%2Fve4%2BCCAYZVeAQoLxtMdzw6S2BkJobVIFhUVtPrZ8dmV1VIHdk%2B6Yfg)
- [PyParsing](https://pyparsing-docs.readthedocs.io/en/latest/)
datek-web-crawler 0.1.0
Simple, powerful web crawler
Requires Python: >=3.13

[![codecov](https://codecov.io/gh/DAtek/web-crawler/branch/master/graph/badge.svg?token=rrht7DUefF)](https://codecov.io/gh/DAtek/web-crawler)

# Web Crawler

Performant, extensible and lean web crawler, utilizes all available CPUs by default. 

Uses event loop for I/O and processes for analyzing the pages.

## Batteries included
- Basic `httpx` page downloader
- `S3` page storage
- Local filesystem page storage

## Usage
- Have a look at `tests/integration/test_crawl.py`
- Implement your own `PageAnalyzer` and `PageDownloader` classes
- Optionally customize `structlog` logging, see [configuration](https://www.structlog.org/en/stable/configuration.html)
- Have fun!

## Customization
All classes in the modules folder can be replaced with your custom implementation.
emp_hooks 0.0.12.post2
emp hooks
Requires Python: >=3.12

# Emp Hooks

Emp Hooks is a collection of hooks designed to work in conjunction with empctl. This library provides various hooks to handle events, schedules, and Twitter interactions.

## Installation

To install Emp Hooks, use pip:

```bash
pip install emp-hooks
```

## Usage

### Onchain Hooks

Onchain hooks are used to listen for events on a specific blockchain.

```python
from emp_hooks import onchain

@onchain.on_event(
    event=V3SwapEvent,
    network=Base,
)
def log_eth_price(event_data: EventData[V3SwapEventType]):
    event = event_data.event
    amount0 = event.amount0 / 1e18
    amount1 = event.amount1 / 1e6

    price = abs(amount1 / amount0)
    log.debug("ETH Price: %s", price)
```

### Scheduler Hooks

Scheduler hooks are used to schedule functions to run at a specific interval or cron schedule.

```python
from emp_hooks import scheduler

@scheduler.on_schedule(
    execution_frequency="0 0 * * *",
)
def periodic_function():
    print("Do scheduled task")
```

### Twitter Hooks

Twitter hooks are used to listen for tweets matching a specific query.

```python
from emp_hooks import twitter

@twitter.on_tweet(
    query="simmi_io",
)
def on_simmi_tweet(tweet: Tweet):
    print(tweet)
```

### Running Hooks

Make sure to import the manager and call `run_forever` on it.
This will ensure that all hooks are running indefinitely, and will handle the SIGINT and SIGTERM signals to stop the hooks gracefully.

```python
from emp_hooks import manager

if __name__ == "__main__":
    manager.hooks.run_forever()
```

## Contributing


To contribute to Emp Hooks, please follow these steps:

1. Fork the repository.
2. Create a new branch for your changes.
3. Make your changes and commit them.
4. Push your changes to your fork.
5. Create a pull request.
ntrees-tuning 0.1.1
The package ntrees_tuning is an extension to sklearn. To Random Forests and Gradient Boosting it adds the ntrees parameter which gives control over how many trees are used for prediction. The main benefit is that it enables to tune the ntrees parameter w.r.t. the OOB-error without having to retrain a new model for each value of ntrees.

The package **ntrees_tuning** is an **extension to sklearn**. To Random Forests and Gradient Boosting it adds the `ntrees` parameter which gives control over how many trees are used for prediction. The main benefit is that it enables to tune the `ntrees` parameter w.r.t. the OOB-error without having to retrain a new model for each value of `ntrees`.

The package introduces subclasses to the `sklearn`-classes of Random Forest and Gradient Boosting (RandomForestClassifier, RandomForestRegressor, GradientBoostingClassifier, GradientBoostingRegressor). Each adds two new methods called `predict_ntree` and `tune_ntree` which enable predicting and tuning the `ntrees` parameter possible

## Example usage:


# 1. Create data:

```python
from sklearn.datasets import make_classification, make_regression
Xcls, ycls = make_classification(n_samples=200, n_features=20, n_classes=3, random_state=42, n_clusters_per_class=3, n_informative=5)
Xreg, yreg = make_regression(n_samples=200, n_features=20, random_state=42)
```

# 2. Create and Fit RandomForest and GradientBoosting models for Regression and Classification

For tuning the `ntrees` parameter new custom classes are introduced. They are direct descendants of `sklearn` classes (`RandomForestClassifier`, `RandomForestRegressor`, `GradientBoostingClassifier`, `GradientBoostingRegressor`).

```python
import ntree_tuning as ntt

rf_cls = ntt.Ntree_RandForest_Classifier(n_estimators=100)
rf_cls.fit(Xcls, ycls)

rf_reg = ntt.Ntree_RandForest_Regressor(n_estimators=100)
rf_reg.fit(Xreg, yreg)

gb_cls = ntt.Ntree_GradBoost_Classifier(n_estimators=100, subsample=0.8)
gb_cls.fit(Xcls, ycls)

gb_reg = ntt.Ntree_GradBoost_Regressor(n_estimators=100, subsample=0.8)
gb_reg.fit(Xreg, yreg)
```

# 3. Tune ntrees

You then can call the `tune_ntrees` method to get a dictionary of the pairs of the `ntrees` value and the oob-error.

```python
# Gradient Boosting
print(gb_reg.tune_ntrees())
print(gb_cls.tune_ntrees())


# Random Forests
min_trees = 20
max_trees = 80
delta_trees = 5

print(rf_reg.tune_ntrees(Xreg, yreg, min_trees, max_trees, delta_trees))
print(rf_cls.tune_ntrees(Xcls, ycls, min_trees, max_trees, delta_trees))
```

# 4. Predict with ntrees

```python
print(gb_reg.predict_ntrees(Xreg, ntrees=10))
```
pyfileloader 0.0.14
Load common JSON formats quickly, CSV too. Supports writing as well.
Requires Python: >=3.7
Keywords: json, jsonl, ndjson, gzip, fileloader

# fileloader

`fileloader` are functions for quickly loading files into lists. Supported types
are `txt`, `jsonl/ndjson`, and `csv`. JSON loading is there too, if needed(it returns a standard json.load(), so it's an object rather than a list of objects)

### Building

`pip3 install build && python3 -m build`

### Installing

`pip3 install pyfileloader`

### Usage

```
>>> from fileloader import load_jsonl
>>> items = load_jsonl('test-10.jsonl')
>>> len(items)
10
>>> comp_items = load_jsonl('compress-10.jsonl.gz')
>>> len(comp_items)
10
```
but-better 0.3.0
Your code but better
Requires Python: >=3.9

# Your Code But Better

[![PyPI version](https://badge.fury.io/py/but-better.svg)](https://badge.fury.io/py/but-better)
[![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)

Wrapper for your code to make it nothing but better. 

## Installation

```bash
pip install but-better
```

## Usage

Pass the time during a long running function by watching a YouTube video. 
Pass YouTube video id as the argument to `but_better` and use it as a decorator.

```python
from but_better import but_better

my_favorite_youtube_id: str = ...
youtube_video = but_better(my_favorite_youtube_id)

from their_module import their_function 

their_function_but_better = youtube_video(their_function)
```

If you are writing the function, use the decorator syntax:

```python
@youtube_video
def my_function():
    # Your code here
    pass
```

Struggling to find something to kill the time? Try out a pre-defined video:

```python
from but_better import (
    elevator,
    favorite_customer, 
    gasolina, 
    gotcha,
    phillies_hype_song, 
    ten_hour_fireplace, 
)
```
ironfe-shared-tools 0.0.8rc0
Shared tools for IronFE
Requires Python: >=3.10

# Shared tooling for ironFE Models

This repository aims to house all of the tools that are shared between the various ironFE models. This currently includes the following:

- CLI Commands
- BigQuery Read/Write functions
- Google cloud storage read/write functions
- Model registry functions
- Parallelism calculation helper functions
- Data compression functions
- Common data processing functions
local-server 0.1.1
A simple FastAPI HTTP server with directory listing
Requires Python: >=3.7

# local-server

A simple FastAPI-based HTTP server that serves static files and directory listings.

## 🌟 Features

- Serves files from the current directory.
- Automatically displays `index.html` if present.
- Lists files and directories if `index.html` is not available.
- Clickable links for navigating directories and viewing file content.

---

## 🛠 Installation

Make sure you have Python 3.7 or higher installed.

### Using pip

```bash
pip install local-server
```
vonage-sms 1.1.6
Vonage SMS package
Requires Python: >=3.9

# Vonage SMS Package

This package contains the code to use Vonage's SMS API in Python.

It includes a method for sending SMS messages and returns an `SmsResponse` class to handle the response.

## Usage

It is recommended to use this as part of the main `vonage` package. The examples below assume you've created an instance of the `vonage.Vonage` class called `vonage_client`.

### Send an SMS

Create an `SmsMessage` object, then pass into the `Sms.send` method.

```python
from vonage_sms import SmsMessage, SmsResponse

message = SmsMessage(to='1234567890', from_='Acme Inc.', text='Hello, World!')
response: SmsResponse = vonage_client.sms.send(message)

print(response.model_dump(exclude_unset=True))
```