semvec/pypi-packages huggingface dataset:
vrox-lex 0.2.6
A fast, customizable lexer for tokenizing text using regex rules.
Requires Python: >=3.6


# 📜 VroxLexer

`VroxLexer` is a simple yet powerful Python-based lexer designed to tokenize input text based on user-defined regular expression rules. It efficiently processes large files by reading in chunks and writing tokens directly to an output file.

  

### ✨ Features

- **Customizable Tokenization** – Users can define `custom tokenization rules` using regular expressions.
- **Efficient File Processing** – Processes large files efficiently by `reading in chunks` instead of loading the entire file into memory.
-  **Regex-based Matching** – Uses precompiled `regular expressions` for fast token detection.
- **Automatic Output Writing** – Tokens are written directly to an output file in real time.
- **Callback Support** – Allows users to specify a callback function that runs after tokenization is complete.
-  **Extensible API** – Easily add `custom token rules` for any syntax.

### 📦 Installation

```bash
pip install vrox-lex
```


### 🔗 Optional Dependency
For higher-level regex abstraction, you can install VroxRegex:
```python
pip install vrox-regex
```
📝 `Note`: VroxLexer works without VroxRegex, but using it simplifies complex regex definitions.

## 🚀 Usage

### 1️⃣ **Create a Lexer Instance** 
To start using `VroxLexer`, create an instance of it:

```python
    from vrox_lexer import VroxLexer
    lexer = VroxLexer()
```

### 2️⃣ **Add Tokenization Rules**
Use the `add_rule(name, regex)` method to define token rules.

**Method 1:** One-by-One Rule Addition
```python
lexer.add_rule("KEYWORD", r"\b(if|else|while|for|return)\b")
lexer.add_rule("NUMBER", r"\b\d+(\.\d+)?\b")
lexer.add_rule("STRING", r"\".*?\"|'.*?'")
lexer.add_rule("IDENTIFIER", r"\b[a-zA-Z_][a-zA-Z0-9_]*\b")
lexer.add_rule("OPERATOR", r"[+\-*/=]")
lexer.add_rule("PUNCTUATION", r"[\(\)\{\},;]")
```

**Method 2:** Chainable API for Better Readability `(Recommended)`

```python
lexer = VroxLexer()\
        .add_rule("KEYWORD", r"\b(if|else|while|for|return)\b")\
        .add_rule("NUMBER", r"\b\d+(\.\d+)?\b")\
        .add_rule("STRING", r"\".*?\"|'.*?'")\
        .add_rule("IDENTIFIER", r"\b[a-zA-Z_][a-zA-Z0-9_]*\b")\
        .add_rule("OPERATOR", r"[+\-*/=]")\
        .add_rule("PUNCTUATION", r"[\(\)\{\},;]")
```

### 3️⃣ **Tokenize Text from a File**

```python
def on_tokenization_complete(output_path):
    print(f"✔ Tokenization complete! Tokens saved in {output_path}")

lexer.tokenize("input.txt", "output.txt", on_tokenization_complete)
```

### 📢 **Example Output (output.txt)**

```txt
KEYWORD: if
IDENTIFIER: count
OPERATOR: =
NUMBER: 10
PUNCTUATION: ;
```

### 🔗 **Final Notes**

- VroxLexer is lightweight, fast, and designed for extensibility.
- Using precompiled regex improves performance significantly.
- The chainable API makes rule definition more intuitive.
- The callback function enables post-processing after tokenization.
houseteli-administrator 0.1.21
Helpers for houseteli microservices which use django
Requires Python: >=3.6

# houseteli_administrator

## Usage

- Add as submodule

```bash
git submodule add git@github.com:houseteli/houseteli_administrator.git houseteli_administrator
```

- Add to installed apps

```python
INSTALLED_APPS = [
    # ...
    'houseteli_administrator',
]

AUTHENTICATION_BACKENDS = [
    'houseteli_administrator.backends.SessionEnhancingAuthBackend',
    # ...
]

MIDDLEWARE = [
    # ...,
    "django.contrib.auth.middleware.AuthenticationMiddleware",
    "houseteli_administrator.middleware.SharedSessionMiddleware",
]


### for auth services, you will not need to have houseteli_administrator.middleware.SharedSessionMiddleware in the main auth service
HAS_ADMIN_LOGIN_PAGE = config('HAS_ADMIN_LOGIN_PAGE', default='False', cast=bool)
if not HAS_ADMIN_LOGIN_PAGE:
    MIDDLEWARE.insert(MIDDLEWARE.index('django.contrib.auth.middleware.AuthenticationMiddleware') + 1, 'houseteli_administrator.middleware.SharedSessionMiddleware')


```

- Add urls entry

```python
urlpatterns = [
    #...
    path('', include('houseteli_administrator.urls')),
]
```

- Whitelabeling admin


```python
from houseteli_administrator import utils as admin_utils
admin_utils.set_site_id()
```
graphchem 2.3.3
Graph-based machine learning for chemical property prediction
Requires Python: >=3.11

[![UML Energy & Combustion Research Laboratory](https://sites.uml.edu/hunter-mack/files/2021/11/ECRL_final.png)](http://faculty.uml.edu/Hunter_Mack/)

# GraphChem: Graph-based machine learning for chemical property prediction

[![GitHub version](https://badge.fury.io/gh/ecrl%2FGraphChem.svg)](https://badge.fury.io/gh/ecrl%2FGraphChem)
[![PyPI version](https://badge.fury.io/py/graphchem.svg)](https://badge.fury.io/py/graphchem)
[![GitHub license](https://img.shields.io/badge/license-MIT-blue.svg)](https://raw.githubusercontent.com/ecrl/GraphChem/master/LICENSE.txt)
[![Documentation Status](https://readthedocs.org/projects/graphchem/badge/?version=latest)](https://graphchem.readthedocs.io/en/latest/?badge=latest)

**GraphChem** is an open source Python package for constructing graph-based machine learning models with a focus on fuel property prediction.

# Installation:

### Prerequisites:
- Have Python 3.11+ installed

### Method 1: pip
```
$ pip install graphchem
```

### Method 2: From Source
```
$ git clone https://github.com/ecrl/graphchem
$ cd graphchem
$ python -m pip install .
```

If any errors occur when installing dependencies, namely with RDKit, PyTorch, or torch-geometric, visit their installation pages and follow the installation instructions: [RDKit](https://www.rdkit.org/docs/Install.html), [PyTorch](https://pytorch.org/get-started/locally/), [PyTorch Geometric](https://pytorch-geometric.readthedocs.io/en/latest/notes/installation.html)

# Usage:

For advanced usage, head over to our [API documentation page](https://graphchem.readthedocs.io/en/latest/).

# Examples

To view some examples of how GraphChem can be used, head over to our [examples](https://github.com/ecrl/graphchem/tree/master/examples) folder on GitHub.

# Contributing, Reporting Issues and Other Support:

To contribute to GraphChem, make a pull request. Contributions should include tests for new features added, as well as extensive documentation.

To report problems with the software or feature requests, file an issue. When reporting problems, include information such as error messages, your OS/environment and Python version.

For additional support/questions, contact Travis Kessler (Travis_Kessler@student.uml.edu).
world-persona-manager 0.1.0
Persona management CLI for whorl personas

# `persona-manager`

This utility allows administrators and system builders to interact with the creation and
limited control of OpenAI Assistant threads. This utility requires a connection to an API
server as described in `[whorl-server](https://github.com/hellowhorl/whorl-server)`.

## Commands

Invoke each of the following commands using the `pmgr` CLI command:
```pmgr <command> <flags>```

### `create`

`create` adds a `persona` assistant to the OpenAI platform and `whorl-server` Postgres DB.
This command features two required and one optional flag:

* `--name`: template name of the Assistant
* `--prompt`: path to a text file containing the text of a prompt for an assistant
* `--file`: path to a Python file to attach to the Assistant

### `cancel`

* `--thread_id`: ID of thread to cancel run

### `delete`

* --thread_id`: ID of thread to delete