semvec/pypi-packages huggingface dataset:
deppython 0.1.0
Deppy: A Python dependency executor that builds and executes DAGs efficiently, optimizing workflows with concurrency and flexibility. Perfect for managing complex dependent tasks effortlessly.
Requires Python: >=3.11

# Deppy
[![Coverage](https://img.shields.io/badge/Coverage-100%25-brightgreen)]() [![Code Quality](https://img.shields.io/badge/Code%20Quality-A%2B-blue)]()

🚀 **Deppy** is a cutting-edge **dependency executor for Python** that empowers developers to design, build, and execute **DAGs (Directed Acyclic Graphs)** efficiently, effectively, and effortlessly.

Deppy is a versatile tool for designing complex workflows, including:
 - 📊 ETL Pipelines: Seamlessly extract, transform, and load data across systems.

### 🌟 Features:
- 🛠️ **Graph Building**: Create complex workflows with minimal effort.
- ⚡ **Optimized Execution**: Executes dependencies in the optimal order, leveraging threads and concurrency for maximum performance.
- 🖼️ **Graph Visualization**: Gain insights into your workflows with intuitive visual representations of your DAGs.
- 🔄 **Flexible Workflow Design**: Seamlessly supports synchronous, asynchronous, and hybrid workflows.
- 🎯 **Advanced Utilities**: Packed with tools to streamline and supercharge your development experience.
- 🛡️ **Reliable**: Comprehensive test coverage ensures stability and reliability.

### 📦 Installation

Deppy has support for python 3.11 and above.

To install Deppy, simply run:

```bash
pip install deppython
```

### 🚀 Quick Start

A quick and easy example to get you started with Deppy:

```python
from deppy import Deppy

def get_list():
    return ["world!", "everyone!", "deppy!"]

def say_hello(to):
    return f"Hello {to}"

deppy = Deppy()

get_list_node = deppy.add_node(func=get_list)
say_hello_node = deppy.add_node(func=say_hello)
deppy.add_edge(get_list_node, say_hello_node, input_name="to", loop=True)

result = deppy.execute()
print(result.query(say_hello_node))  # ['Hello world!', 'Hello everyone!', 'Hello deppy!']
```

### 📖 Documentation
For detailed usage and advanced features, dive into our [comprehensive documentation](./docs).

---

⚡ Transform your workflow management with **Deppy** today!
sqlcompyre 2.0.0
Tool for comparing and inspecting data in SQL databases.
Requires Python: >=3.11

# SQLCompyre

[![CI](https://img.shields.io/github/actions/workflow/status/quantco/sqlcompyre/ci.yml?style=flat-square&branch=main)](https://github.com/quantco/sqlcompyre/actions/workflows/ci.yml)
[![conda-forge](https://img.shields.io/conda/vn/conda-forge/sqlcompyre?logoColor=white&logo=conda-forge&style=flat-square)](https://prefix.dev/channels/conda-forge/packages/sqlcompyre)
[![Documentation](https://img.shields.io/badge/docs-latest-success?branch=main&style=flat-square)](https://sqlcompyre.readthedocs.io/en/latest/)
[![pypi-version](https://img.shields.io/pypi/v/sqlcompyre.svg?logo=pypi&logoColor=white&style=flat-square)](https://pypi.org/project/sqlcompyre)
[![python-version](https://img.shields.io/pypi/pyversions/sqlcompyre?logoColor=white&logo=python&style=flat-square)](https://pypi.org/project/sqlcompyre)

SQLCompyre is a simple Python package that allows you to find and explore the differences between SQL tables, schemas, and entire databases. It provides both a Python interface and a CLI, allowing it to be used for both ad-hoc comparisons as well as in-depth analyses.

SQLCompyre is designed to be dialect-agnostic and should, thus, work with most database systems out-of-the-box.

## Usage example

Given a connection to a database, this snippet will print a report of the differences between two tables:

```python
import sqlalchemy as sa
import sqlcompyre as sc

engine = sa.create_engine("<your_connection_string>")
comparison = sc.compare_tables(engine, "<left table name>", "<right table name>")

report = comparison.summary_report()
print(report)
```

To find more examples and get started, please visit the [documentation](https://sqlcompyre.readthedocs.io/en/latest/).

## Installation

SQLCompyre can be installed via `pip` or `conda`:

```bash
pip install sqlcompyre
# or
micromamba install sqlcompyre
# or
conda install sqlcompyre
```

Details on its usage can be found in the [documentation](https://sqlcompyre.readthedocs.io/en/latest/).

## Development

This project is managed by [pixi](https://pixi.sh).
You can install the package in development mode using:

```bash
git clone https://github.com/quantco/sqlcompyre
cd sqlcompyre

pixi run pre-commit-install
pixi run postinstall
```

### Running Tests Locally

1. Make sure you have `msodbcsql18` installed, or install it [here](https://learn.microsoft.com/en-us/sql/connect/odbc/download-odbc-driver-for-sql-server)

2. Make sure you have `Docker` installed, or install it [here](https://docs.docker.com/get-docker/)

3. Create a local test database with the following command:

```bash
docker compose up
```

4. Set environment variable

```bash
export DB_CONNECTION_STRING="mssql+pyodbc://sa:Passw0rd@localhost:1435/master?driver=ODBC+Driver+18+for+SQL+Server&Encrypt=no"
```

5. Navigate to the main directory of this repository and run pytest.

```bash
pixi run test
```