semvec/pypi-packages huggingface dataset:
full-match 0.0.3
One function that makes the string matchable
Requires Python: >=3.8

# full_match

[![Downloads](https://static.pepy.tech/badge/full_match/month)](https://pepy.tech/project/full_match)
[![Downloads](https://static.pepy.tech/badge/full_match)](https://pepy.tech/project/full_match)
[![Coverage Status](https://coveralls.io/repos/github/pomponchik/full_match/badge.svg?branch=main)](https://coveralls.io/github/pomponchik/full_match?branch=main)
[![Lines of code](https://sloc.xyz/github/pomponchik/full_match/?category=code)](https://github.com/boyter/scc/)
[![Hits-of-Code](https://hitsofcode.com/github/pomponchik/full_match?branch=main)](https://hitsofcode.com/github/pomponchik/full_match/view?branch=main)
[![Test-Package](https://github.com/pomponchik/full_match/actions/workflows/tests_and_coverage.yml/badge.svg)](https://github.com/pomponchik/full_match/actions/workflows/tests_and_coverage.yml)
[![Python versions](https://img.shields.io/pypi/pyversions/full_match.svg)](https://pypi.python.org/pypi/full_match)
[![PyPI version](https://badge.fury.io/py/full_match.svg)](https://badge.fury.io/py/full_match)
[![Checked with mypy](http://www.mypy-lang.org/static/mypy_badge.svg)](http://mypy-lang.org/)
[![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)


When catching exceptions in [`Pytest`](https://docs.pytest.org/en/latest/), sometimes you need to check messages. Since the user sends a pattern for searching, and not a message for exact matching, sometimes similar, but not identical messages pass through the filter. This micro-library contains a function that makes `Pytest` check exception messages accurately.

It may also be useful to you if you use mutation testing tools such as [mutmut](https://github.com/boxed/mutmut).

Install it:

```bash
pip install full_match
```

And use:

```python
import pytest
from full_match import match

def test_something():
  with pytest.raises(AssertionError, match='Regex pattern did not match.'):
    with pytest.raises(ValueError, match=match('Some message.')):
      raise ValueError('XXSome message.XX')
```

The message in the inner `with` block does not match the pattern exactly, so an `AssertionError` exception will occur in this example.
pyrandomart 1.1.2
Python library to generate randomart of a bytes string
Requires Python: >=3.9.0

# pyrandomart
Python library to produce randomart text from a bytes object

This module contains a function to turn a bytes object into a randomart
string.
see: [http://www.dirk-loss.de/sshvis/drunken_bishop.pdf](http://www.dirk-loss.de/sshvis/drunken_bishop.pdf)
for a description of randomart

## Installation
Try either:

```shell
pip install pyrandomart
```
or directly from github
```shell
pip install git+https://github.com/aaronm6/pyrandomart.git
```

## Usage
The only function in this package that is useful to import is the last one, '`randomart`'. So the recommended usage is:
```shell
>>> from pyrandomart import randomart
```
`randomart`'s call signature and explantion of inputs:
```shell
randomart(bStr, header='RSA 4096', footer='SHA256', dims=(9, 17), box='clean')
```
- `bStr`: Bytes object with the hash to be turned into randomart
- `header`: Str object to be displayed at the header of the randomart box
- `footer`: Str object to be displayed at the footer of the randomart box
- `dims`: List or tuple object with dimensions of the randomart box (rows, columns). Dims must be odd ints.
- `box`: Describes the characters that make up the border of the randomart box.  Input value can be 'clean' or 'simple', or a custom dict object can be provided.

For example, to turn a bytes object consisting of byte values 30 through 60 into randomart and print:
```shell
>>> bobj = bytes(range(30,60))
>>> print(randomart(bobj, header='30-60', footer='no hash'))
┏━━━━━[30-60]━━━━━┓
┃@===+o.          ┃
┃XO.*+...         ┃
┃= o o . .        ┃
┃Xo     . .       ┃
┃+Oo     S .      ┃
┃BE.    . o .     ┃
┃=o.     . .      ┃
┃o.               ┃
┃.o.              ┃
┗━━━━[no hash]━━━━┛
```

### Notes
- The randomart here corresponds to the bytes given in bytes-object bStr.  However, often a cryptographic hash is given in the base64 representation of the bytes (e.g. when generating an ssh key).  In this case, one can simply import the standard library 'base64' and decode the base64 hash to bytes using `base64.b64decode(..)` and then pass the result to this randomart function.
- The number of columns should be large enough to accommodate the header and footer provided.  However, this is not explicitly checked, because it's your life. The function will still work if not, but it may look funky.
opencue-rqd 1.13.8
RQD is a software client that runs on all hosts doing work for an OpenCue deployment.
Requires Python: >3.7

# RQD

RQD is a software client that runs on all hosts doing work for an OpenCue deployment.

RQD's responsibilities include:

- Registering the host with Cuebot.
- Receiving instructions about what work to do.
- Monitoring the worker processes it launches and reporting on results.

RQD uses [gRPC](https://grpc.io/) to communicate with Cuebot. It also runs its own gRPC server, which is called by the Cuebot client to send instructions to RQD.

## How to start rqd from source

### Setup python environment
```bash
# Create virtual environment
python3 -m venv OpenCue-venv
# Activate virtual environment
source OpenCue-venv/bin/activate
# Change directory to Opencue source
cd <OpenCueSourceDir>

# Install compiled proto files which is needed by RQD into the virtual environment
pip install ./proto

# Install RQD into the virtual environment
pip install ./rqd
```

### Create rqd.conf
Example `rqd.conf` file :

```ini
[Override]
# Variable that decided if RQD should switch to the user of the job running. Requires root
RQD_BECOME_JOB_USER = False

# Log levels for RQD
CONSOLE_LOG_LEVEL = INFO
FILE_LOG_LEVEL = ERROR

# Number of seconds to wait before checking if the user has become idle.
CHECK_INTERVAL_LOCKED = 60
# Seconds of idle time required before NIMBY (Not In My BackYard) unlocks.
MINIMUM_IDLE = 900

# Whether or not to prefix each line in the log with a timestamp
RQD_PREPEND_TIMESTAMP = 0

# Maximum size in bytes for job log files before automatic termination
# Default: 1 GiB (1073741824 bytes). Set to 0 to disable.
JOB_LOG_MAX_SIZE_IN_BYTES = 1073741824
```

### Run rqd
(using the above virtual environment)
```bash
rqd -c <path to rqd.conf>
```
opencue-pyoutline 1.13.8
PyOutline is a Python library for building and managing OpenCue job definitions. It provides an API to create outlines that describe jobs, layers, and tasks, making it easier to construct repeatable workflows for rendering pipelines.
Requires Python: >3.7

# OpenCue PyOutline

PyOutline is a Python library for building and managing OpenCue job definitions. It provides an API to create outlines that describe jobs, layers, and tasks, making it easier to construct repeatable workflows for rendering pipelines. 

This library serves as a Python layer over OpenCue's XML job descriptions, allowing the construction of complex jobs without having to edit XML directly. PyOutline is used by CueSubmit to construct job submissions.

## Example Usage
Here is a simple example of how to submit a job to cuebot using the API
```python
import outline.modules.shell

# Create a job for submission
job = outline.Outline("test-job", shot='test', show='testing', user='jimmy')

# Create a layer that can later be associated with a job. The command can use internal variables that are  
# replaced at runtime (eg. #IFRAME# which is the current frame rendering)
layer1 = outline.modules.shell.Shell("layer1", type="Render", command=["echo #IFRAME#"], range="1-100")

# Adds the layer to the job
job.add_layer(layer1)

# Create a new layer that will run after the first layer is done. The frame size is the same, but the chunk
# size is set to the full range, which means that it will only result in a single task instead of 1 per frame
layer2 = outline.modules.shell.Shell("layer2", type="Util", command=["echo Collecting frames"], range="1-100", chunk=100, tags="ffmpeg")

# Set the layer to depend on layer1
layer2.depend_on(layer1)

# Add the layer to the job
job.add_layer(layer2)

# Submit the job to cuebot. It will not use the cuerun wrapper and mail notification is disabled.
outline.cuerun.launch(job, use_pycuerun=False, os="Linux", nomail=True)
```
opencue-pycue 1.13.8
PyCue is the Python API client for OpenCue, providing programmatic access to core services. It enables developers to query, submit, and control jobs, layers, and frames directly from Python code.
Requires Python: >3.7

# OpenCue Python API

PyCue is the OpenCue Python API. OpenCue client-side Python tools, such as CueGUI and CueAdmin, all call PyCue for communication with your OpenCue deployment. It enables developers to query, submit, and control jobs, layers, and frames directly from Python code.
opencue-cuesubmit 1.13.8
CueSubmit is a submission tool for OpenCue that allows artists and developers to easily submit jobs to the render farm. It provides an interface to configure job parameters, layers, and dependencies before dispatching work.
Requires Python: >3.7

# CueSubmit

CueSubmit is a submission tool for OpenCue that allows artists and developers to easily submit jobs to the render farm. It provides an interface to configure job parameters, layers, and dependencies before dispatching work.

This is a Python-based QT app through which you can submit jobs to an OpenCue deployment. It can run as a standalone application, or as a plugin in applications that support PySide/qtpy integration, such as Autodesk's Maya or the Foundry's Nuke.
opencue-cuegui 1.13.8
CueGUI is the graphical user interface for OpenCue with two main workspace views. Cuetopia provides artist-focused tools for monitoring and managing render jobs through plugins like Monitor Jobs, Job Details, Frame logs, and Job Graph. CueCommander offers administrator-focused system monitoring and host management with advanced tools for allocations, hosts, services, and resources. Together, they enable artists and administrators to track job progress and manage render farm operations.
Requires Python: >3.7

# CueGUI

CueGUI is the graphical user interface for OpenCue, divided into two main workspace views. 

- **Cuetopia** is the artist-focused view for monitoring and managing render jobs, including plugins such as Monitor Jobs, Monitor Job Details, Frame logs, and Job Graph. 

- **CueCommander** is the administrator-focused view for system monitoring and host management, providing advanced tools for allocations, hosts, services, and system resources. Together, they empower artists, production staff, and administrators to track job progress, troubleshoot issues, and manage render farm operations.