semvec/pypi-packages huggingface dataset:
hexly 0.0.4
A hex viewer for Jupyter notebooks
Requires Python: <4.0,>=3.12

# Hexly

Hexly is a hex viewer for Jupyter notebooks.

## Usage

```python
import hexly as hl
hl.HexView(bytes(range(256)))
```

![usage](https://raw.githubusercontent.com/shadanan/hexly/main/usage.png)

For more usage, checkout the [usage notebook](https://github.com/shadanan/hexly/blob/main/usage.ipynb).
dnssplitter 1.1.1
A fast python implementation of breaking down DNS domains into parts.
Requires Python: >=3

# Overview

Parses DNS domain names into three parts: the prefix, the registered
domain and it's registration point.

# Usage

## From the CLI

```
dnssplit www.google.co.uk www.yahoo.com
www.google.co.uk:
  Prefix:    www
  Domain:    google.co.uk
  Reg Point: co.uk
www.yahoo.com:
  Prefix:    www
  Domain:    yahoo.com
  Reg Point: com
```

## Using the API

``` python
import dnssplitter
splitter = dnssplitter.DNSSplitter()

splitter.init_tree() # uses internal data
# or load your own:
# splitter.load_psl_file("/path/to/public_suffix_list.dat")
results = splitter.search_tree("www.foo.co.uk")

# Returns an array of [prefix, registered_domain, public_point]:
# results == ['www', 'foo.co.uk', 'co.uk']
```

# Reason for being

There are a number of PSL breakdown libraries.  But this one is faster
than the others based on some initial tests, and returns more information.
pytest-loguru 0.4.0
Pytest Loguru
Requires Python: >=3.8
Keywords: loguru, py.test, pytest

[![Build Status](https://github.com/mcarans/pytest-loguru/workflows/build/badge.svg)](https://github.com/mcarans/pytest-loguru/actions?query=workflow%3Abuild)
[![PyPI](https://img.shields.io/pypi/v/pytest-loguru.svg)](https://pypi.python.org/pypi/pytest-loguru)
[![Conda Version](https://img.shields.io/conda/vn/conda-forge/pytest-loguru.svg)](https://anaconda.org/conda-forge/pytest-loguru)
[![Coverage Status](https://codecov.io/gh/mcarans/pytest-loguru/branch/main/graph/badge.svg?token=JpWZc5js4y)](https://codecov.io/gh/mcarans/pytest-loguru)
[![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)

### pytest-loguru

A pytest plugin to add support for loguru to pytest's caplog fixture.

You can install it from pypi with:
```
pip install pytest-loguru
```
and from conda-forge with:
```
conda install -c conda-forge pytest-loguru
```

Note that coverage is 100% but the coverage tool is confused by the fixture decorator.
safe-callback 0.0.5
A declarative approach to exception handling in python
Requires Python: >=3.10

# Safe Callback

## About

`safe-callback` is a simple library that provides a way to safely call a function or method and handle anticipated errors in a customizable way. It is designed to be used in situations where a function or method may fail, but the failure is not fatal and should be handled gracefully. However, this situation seems to be common enough that error handling code can become repetitive and clutter the main logic of a program. `safe-callback` aims to simplify this by providing a way to handle errors in a predictable and customizable way.

## Installation

Install `safe-callback` using pip:

```bash
$ pip install safe-callback
```

## Usage

`safe-callback` uses a decorator to wrap a function or method to handle any anticipated errors that may occur in the wrapped function or method. The decorator can specify a mapping of which errors to handle and how to handle them. If an instance of the exception is raised, the corresponding handler will be called. If no handler is specified for a particular exception, the exception will be raised as normal.

### Basic Usage

Use the `@safecallback` decorator to wrap a function or method. Specify the anticipated exceptions and how to handle them as a dictionary.

```python
from safe_callback import safecallback

@safecallback({
  ZeroDivisionError: lambda e: print("Denominator cannot be zero")
})
def divide(numerator, denominator):
  return numerator / denominator
```

In this example, the `divide` function is protected from a `ZeroDivisionError`. If a `ZeroDivisionError` is raised, the provided lambda function is called and the exception is handled. If any other exception is raised, it will be raised as normal.

```python
>>> divide(4, 2) # Returns 2.0 as normal
2.0
>>> divide(4, 0) # Prints "Denominator cannot be zero" and returns None
Denominator cannot be zero
```

### Advanced Usage

The `@safecallback` decorator can also be used without any arguments. In this case, the wrapped function or method will not handle any exceptions, but will allow the exception handlers to be specified at a later time using the `error_handler` sub-decorator. This can be useful when the exception mapping grows too large or for specifying exception handlers at runtime.

```python
@safecallback() # Exception mapping is empty, so no exceptions will be handled
def divide(numerator, denominator):
  return numerator / denominator

# Elsewhere or maybe in some other module
@divide.error_handler(ZeroDivisionError)
def handle_zero_division_error(e):
  print("Denominator cannot be zero")

```
In this example, the `divide` function is initially unprotected. However, the `handle_zero_division_error` function is specified as the exception handler for `ZeroDivisionError` at a later time. This allows the exception handlers to be specified at runtime or in a different module.

```python
>>> divide(4, 2) # Returns 2.0 as normal
2.0
>>> divide(4, 0) # Prints "Denominator cannot be zero" and returns None
Denominator cannot be zero
```
marque 0.1.1
Minimal workflows
Requires Python: <4.0,>=3.10

# marque

marque (mark) is a minimal library for building workflows and pipelines in python. It has basic primitives for storing long-term data (`keep()/recall()`), passing runtime context (`put()/get()`), and dynamically extending the flow as it's executing (`push()`). 

- `Flow`: Defines the workflow and orchestrates it
- `Context`: Runtime object storage for flexible dependencies
- `Step`: Individual function in the workflow
- `Scope`: A storage object provided to each step for artifacts/tagging
    - `Tag`: A `str, float | None` pair you can use to label a scope
    - `Artifact`: Arbitrary data you want to keep and recall later

The output of a flow is essentially a set of `Scope` objects which represent all the important data generated during the workflow run. You can use the `search()` function to find prior scopes and use their data to prepare new steps.

Here is a basic example:

```python
from random import Random

from marque import Flow, repeat
from marque.storage import PolarsStorage


def add(flow: Flow):
    a, b = flow.get(int, ["a", "b"])            # pull values from the current context
    flow.tag(f"{a} + {b}")                      # add tags for faster analytics/filtering
    flow.keep("data", {"answer": a + b})        # persist data to recall later

def sub(flow: Flow):
    a, b = flow.get(int, ["a", "b"])
    flow.tag(f"{a} - {b}")
    flow.keep("data", {"answer": a - b})

def simple_math(flow: Flow):
    random = flow.get(Random)           # pull context values using only types

    a = random.randint(10, 100)
    b = random.randint(10, 100)

    flow.push(
        random.choice([add, sub]),      # extend the workflow with a new step
        a=a, b=b                        # pass required context values
    )

def inspect_add(flow: Flow):
    for scope in flow.search(                       # search prior scopes and filter
        "*",                                        # glob syntax is supported
        where=lambda tag: "+" in tag.content
    ):
        for tag in scope.tags:
            flow.log(tag.content)

def inspect_sub(flow: Flow):
    for scope in flow.search(sub):                  # or just pass the function
        flow.log(scope.recall("data")["answer"])    # and pull data from the scope

flow = (
    Flow("test", PolarsStorage("test.parquet"))     # persist data to a parquet file
    .fail_fast()                                    # don't ignore errors
    .put(random=Random(42))                         # prepare a seeded random generator
    .push(repeat(simple_math, 5))                   # add 5 steps for simple_math
    .push([inspect_add, inspect_sub])               # run after everything else
)

flow()                 # Execute our flow

print(flow.run)        # The run id (2-part slug)
print(flow.logs)       # list of any logs
print(flow.scopes)     # list of all scopes
print(flow.errors)     # any errors if we don't fail_fast

```
LaTeX-PyPI 0.1
This is the simplest module for working with tables and images in LaTeX
Requires Python: >=3.8

# LaTeX_img_tab #
Р”Р°РЅРЅС‹Р№ РјРѕРґСѓР»СЊ СЏРІР»СЏРµС‚СЃСЏ С‚СЂРµРЅРµСЂРѕРІРєРѕР№ Рё РІС‹РїРѕР»РЅРµРЅРёРµРј РґРѕРјР°С€РЅРµРіРѕ Р·Р°РґР°РЅРёСЏ РїРѕ Python + LaTeX (РіРµРЅРµСЂР°С†РёСЏ С‚Р°Р±Р»РёС† Рё РёР·РѕР±СЂР°Р¶РµРЅРёР№)
floatingtime 1.5.0
Floating time app.
Requires Python: >=3.8


This Python application showcases a floating window timer that appears every half-hour (`HH:30`) and hour (`HH:00`), remaining visible for 10 seconds.

![Overview](https://github.com/lbyxiafei/floating_time/blob/main/img/overview.png)

# Install on Windows

Requirements: `python >= 3.9`. Install application and dependencies:

```bash
pip install schedule floatingtime
```

Create a Powershell script, `floatingtime.ps1`:

```ps
python -m floatingtime.main
```

Open Task Scheduler:
- Press `Win + R` to open the "Run" dialog.
- Type `taskschd.msc` and press Enter to open Task Scheduler.
Create a new task:
- In Task Scheduler, click on "Create Task..." in the right-hand Actions pane.
- Click on the "Triggers" tab and then "New".
Actions Tab:
- Click on the "Actions" tab and then "New".
- For the action, select "Start a program".
- In the "Program/script" field, enter `powershell.exe`.
- In the "Add arguments (optional)" field, enter the following:

```ps
-ExecutionPolicy Bypass -WindowStyle Hidden -File "C:\path\to\your\script\myscript.ps1"
```

Replace `"C:\path\to\your\script\myscript.ps1"` with the actual path to your PowerShell script(`floatingtime.ps1`).

Save and restart the computer, all set.

# Install on Mac

> To be added...