semvec/pypi-packages huggingface dataset:
etl-watcher-sdk 0.1.43
SDK for Watcher framework
Requires Python: >=3.12

# [Watcher](https://github.com/cmgoffena13/etl-watcher) SDK

[![PyPI version](https://badge.fury.io/py/etl-watcher-sdk.svg)](https://pypi.org/project/etl-watcher-sdk/)
[![Changelog](https://img.shields.io/badge/changelog-0.1.41-blue.svg)](CHANGELOG.md)

## QuickStart

### Installation

You can install the Watcher SDK, `etl-watcher-sdk`, using your preferred package manager.

### Store Pipeline and Address Lineage Configuration

Store your pipeline and address lineage configuration in a Python file.

```python
from watcher import Pipeline, PipelineConfig, AddressLineage, Address

MY_ETL_PIPELINE_CONFIG = PipelineConfig(
    pipeline=Pipeline(
        name="my-etl-pipeline",
        pipeline_type_name="extraction",
    ),
    default_watermark="2024-01-01",
    address_lineage=AddressLineage(
        source_addresses=[
            Address(
                name="source_db.source_schema.source_table",
                address_type_name="postgres",
                address_type_group_name="database",
            )
        ],
        target_addresses=[
            Address(
                name="target_db.target_schema.target_table",
                address_type_name="snowflake",
                address_type_group_name="warehouse",
            )
        ],
    ),
)
```

### Sync Pipeline and Address Lineage Configuration

Sync your pipeline and address lineage configuration to the Watcher framework. 
This ensures your code is the source of truth for the pipeline and address lineage configuration.

```python
from watcher import Watcher, PipelineConfig

watcher = Watcher("https://api.watcher.example.com")
synced_config = watcher.sync_pipeline_config(MY_ETL_PIPELINE_CONFIG)
print(f"Pipeline synced!")
```

### Track Pipeline Execution

```python
from watcher import Watcher, PipelineConfig, ETLResult

watcher = Watcher("https://api.watcher.example.com")

synced_config = watcher.sync_pipeline_config(MY_ETL_PIPELINE_CONFIG)

@watcher.track_pipeline_execution(
    pipeline_id=synced_config.pipeline.id, 
    active=synced_config.pipeline.active
)
def etl_pipeline():
    print("Starting ETL pipeline")
    
    # Your ETL work here
    # Set completed_successfully=True/False based on your logic
    
    return ETLResult(
        completed_successfully=True,
        inserts=100,
        total_rows=100,
        execution_metadata={"partition": "2025-01-01"},
    )

etl_pipeline()
```

## Contributing

I welcome contributions to the Watcher SDK! Please see the [Contributing Guidelines](CONTRIBUTING.md) for details on how to get started, the development process, and how to submit pull requests.

### Quick Start for Contributors
1. Fork the repository
2. Create a feature branch
3. Make your changes
4. Spin up the [Watcher framework](https://github.com/cmgoffena13/etl-watcher) for manual integration testing
5. Run tests in the repo with `make test`
6. Submit a pull request

For detailed information about the coding standards, testing requirements, and contribution process, please refer to the [Contributing Guidelines](CONTRIBUTING.md).
lukhed-basic-utils 1.6.10
A collection of basic utility functions
Requires Python: >=3.9

# lukhed_basic_utils

A collection of basic utility functions for Python projects.

## Installation and Usage

```bash
pip install lukhed-basic-utils
```

## osCommon

A set utility functions for interacting with the operating system's file and directory structures.  

### Example Usage

```python
from lukhed_basic_utils import osCommon as osC
```


#### Creating Operating System Agnostic FIle Path Strings
```python
example_path = osC.create_file_path_string(list_of_dir=['subdir', 'file.txt'])
print(example_path)
```

```python
#output
/home/user/current_working_dir/subdir/file.txt
```

#### Retrieving File Names in Directory

```python
return_files_in_dir_as_strings("/home/user/docs", return_file_names_only=True)
```

```python
# output
['file1.txt', 'file2.txt']
```

## fileCommon

A set utility functions for working with local files.  

```python
from lukhed_basic_utils import fileCommon as fC
```

## githubCommon

A class for working with the Github API, geared toward utilizing github repo's as storage or shared config.

```python
from lukhed_basic_utils.githubCommon import GithubHelper
```

### Retrieve JSON Content Stored In a Github Repo
```python
gC = GithubHelper(project='lukhed', repo_name='exampleRepo')
example_dict = gC.retrieve_file_content('someConfig.json')
```

## Other Utility Files
### classCommon
### listWorkCommon
### mathCommon
### stringCommon
### timeCommon

For more documentation, check pypi page:
https://pypi.org/project/lukhed-basic-utils/
velocity-py 0.2.4
A high-performance scaffolding tool for strictly typed Python projects.
Requires Python: >=3.9

# Velocity Py

A high-performance scaffolding tool for strictly typed, modern Python projects.

Designed as a streamlined solution for initializing Python applications, this tool establishes a robust toolchain using **uv**, **Ruff**, and **Ty** with zero manual configuration. It eliminates the need to manage `pyproject.toml` boilerplate, allowing developers to focus on implementation immediately.

## Features

* **Rapid Initialization:** Scaffolds complete project structures in milliseconds.
* **Modern Toolchain:** Comes pre-configured with high-performance tools from Astral (`uv`, `ruff`, `ty`).
* **Strict Type Safety:** Enforces type checking and code quality standards by default.
* **Integrated Development Environment:** Includes a development server with hot-reloading that automatically lints and type-checks code upon saving.
* **Interactive CLI:** Features a streamlined command-line interface for customized tool selection.

## Installation and Usage

This tool is designed to be executed directly via `uvx` (the command-line tool runner included with `uv`). This method ensures you always run the latest version without requiring a permanent global installation.

### Prerequisites

Ensure that `uv` is installed on your system.
For intallation guides refer to https://docs.astral.sh/uv/

## Creating a Project

To scaffold a new project, execute the following command in your terminal:

**macOS/Linux:**
```bash
uvx velocity-py
```

**Windows:**
```powershell
uvx velocity-py
```

This command will download and execute the tool in an isolated environment and guide you through the setup process interactively.
explainmath 0.1.1
A tiny library that catches invalid math operations and explains why they failed.
Requires Python: >=3.8

# ExplainMath

**ExplainMath** is a small Python library that catches invalid numeric operations (like division by zero, undefined results, or bad power operations) and explains **why it went wrong** in plain English — instead of silently giving `NaN` or `inf`.

This is useful in machine learning, simulations, finance, or any code where one wrong number can poison the whole pipeline without you noticing.

---

## 🔥 Why This Library Exists

In Python, many invalid numeric operations do **not** crash your program. Instead, they produce `NaN`, `inf`, or a complex number — and these values spread quietly through your code.

Example of a real problem:

\`\`\`python
result = model(data)
print(result)   # nan ... now what?
# Traditional debugging tells you where the error happened,
# but not why the math became invalid.

# ExplainMath catches the failure at the moment it happens and tells you the reason.
\`\`\`

## ✨ Features

*   Tracks invalid math operations
*   Supports addition, subtraction, multiplication, division, and power
*   Marks invalid values explicitly (no hidden NaNs or silent errors)
*   Preserves the reason for the failure
*   Propagates invalid state safely through further calculations
*   Optional `.require()` strict mode that raises an exception

## 🚀 Quick Start

## 📦 Examples

### Basic addition

\`\`\`python
from explainmath import Value

a = Value(10)
b = Value(5)
print(a.add(b).value)  # 15
\`\`\`

### Invalid Division

\`\`\`python
from explainmath import Value

a = Value(10)
b = Value(0)
c = a.div(b)
print(c.is_valid())        # False
print(c.explanation)       # "Division by zero while evaluating 10 / 0"
\`\`\`

## 🔒 Strict Mode Example (Fail Fast)

\`\`\`python
from explainmath import Value, SemanticError

try:
    Value(10).div(Value(0)).require()
except SemanticError as e:
    print("Error caught:", e)
\`\`\`

## 🧪 Running Tests

\`\`\`bash
python -m unittest discover -v
\`\`\`

## 📌 Project Status

This is version **v0.1**.
It is intentionally small and focused:

*   A single numeric type
*   Basic arithmetic
*   Error explanation
*   Safe propagation

Future versions will include:

*   Operation history
*   Provenance tracking
*   Better debugging reports
*   Optional integration with NumPy/PyTorch

## 🗂 Folder Structure

\`\`\`text
core/       → implementation
examples/   → usage demos
tests/      → unit tests
docs/       → (reserved for future)
\`\`\`

## License

This project is licensed under the **MIT License**.

---

*Made with curiosity, logic, and a desire to reduce silent math bugs.*
pixmatch 0.1.3
A modern VisiPics replacement.
Requires Python: >=3.9

# PixMatch

PixMatch is a modern, cross-platform duplicate-image finder inspired by VisiPics, built with PySide6. 

![Basic view of the application](https://github.com/rheard/markdown/blob/main/pixmatch/basic.jpg?raw=true)
    
PixMatch scans folders (and ZIP archives) for visually similar images, groups matches, 
    and lets you quickly keep, ignore, or delete files from a clean GUI. 
    Rotated, mirrored or recompressed imgaes are no match for PixMatch!
    PixMatch can even detect visually similar GIFs and animated WebP files.
    Files inside ZIPs are treated as read-only “sources of truth”
    —never deleted—so you can safely compare against archived libraries.


Supported extensions: `.jpg`, `.jpeg`, `.png`, `.webp`, `.tif`, `.tiff`, `.bmp`, `.gif`, `.zip`.


## Install

PixMatch is a standard Python app (GUI via PySide6).

```bash
python -m pip install pixmatch[gui]
```

## Running

```bash
python -m pixmatch
```

### Usage

Simply select some folders to parse and then click begin. 

Once duplicate groups begin to appear in the duplicates view,
    you can start to select actions for them and then execute those actions. 
Clicking on a tile will cycle through actions, with red being delete, yellow being ignore, and green being no action.

Images which are in zips and cannot be deleted will have a rar icon to denote such, 
    and they cannot be marked for deletion.

The status bar under each image shows the full path, the file size, the uncompressed file size, 
    the frames in the image if it is an animated image, the image dimensions and the last modified date.

Basic status bar example:

![Example of the status bar with a basic image loaded](https://github.com/rheard/markdown/blob/main/pixmatch/basic_status.jpg?raw=true)

Animated image status bar example:

![Example of the status bar with an animated image loaded](https://github.com/rheard/markdown/blob/main/pixmatch/gif_status.jpg?raw=true)

#### Notes
 * An exact match checkbox is provided. If strength is 10 and this checkbox is checked, 
    SHA-256 file hashes will be used instead of perceptual hashes.

#### Optional Args:
```markdown
positional arguments:
  folders     Folders to load into the selected file path display (to speed up testing).

options:
  --verbose   More detailed logging
```

## Acknowledgements

* Thanks to anyone who supported this effort, including the teams behind PySide6, Pillow, PyPI, and many other projects.
* Thanks to Johannes Buchner and the team behind imagehash, which serves as a large backbone in this application and saved me a lot of time.
* Thanks to Guillaume Fouet (aka Ozone) for VisiPics and the inspiration. Please don't be mad, I just wanted some new features like better gif and zip support.