semvec/pypi-packages huggingface dataset:
dq_calculator 0.1.0
A data quality calculator for row comparison
Requires Python: <3.11,>=3.10
Keywords: data quality, databricks, validation

# DQ Calculator

A Python package for calculating and monitoring data quality metrics in Databricks tables.

## Features

- Comprehensive data quality checks including:
  - Null value detection
  - Uniqueness validation
  - Data freshness monitoring
  - Phone number format validation
  - Email format validation
  - Country code validation
  - Company name validation
- AI-powered suggestions for data quality improvements
- Support for both Databricks and Snowflake data sources
- Historical tracking of data quality metrics
- Configurable validation rules via YAML

## Installation

```bash
pip install dq-calculator
```

## Quick Start

```python
from dq_calculator import DataQualityCalculator, parse_config

# Example configuration
config = """
data_quality:
  data:
    format: databricks
    table_name: your_database.your_schema.your_table
    filter: N/A
    dri: Your Team

  data_quality_checks:
    general_rules:
      null_check: [column1, column2, column3]
      uniqueness:
        key: id_column
      freshness:
        timestamp_column: updated_at
        interval: 24

    format_rules:
      phone_format:
        column: phone_number
        country_code: country
      email_format: email_address
      country_code_format: country

    domain_rules:
      non_robot_email: email_address
      valid_company_name: company_name

    ai_suggestions: true
"""

# Parse configuration
config_dict = parse_config(config)

# Initialize calculator
calculator = DataQualityCalculator(config_dict)

# Process all tables
calculator.process_all_tables()
```

## Configuration

The package uses YAML configuration files to define data quality rules. Here's an example structure:

```yaml
data_quality:
  data:
    format: databricks  # or snowflake
    table_name: your_table
    filter: optional_filter_condition
    dri: team_name

  data_quality_checks:
    general_rules:
      null_check: [list_of_columns]
      uniqueness:
        key: unique_key_column
      freshness:
        timestamp_column: date_column
        interval: hours

    format_rules:
      phone_format:
        column: phone_column
        country_code: country_column
      email_format: email_column
      country_code_format: country_column

    domain_rules:
      non_robot_email: email_column
      valid_company_name: company_column

    ai_suggestions: true/false
```

## Output

The package generates three types of output tables:

1. Current results table (`your_table_dq_result`)
2. Historical results table (`your_table_dq_result_archive`)
3. Summary archive table (`data_quality_archive_summary`)

Each table includes:
- Individual check results
- Overall quality score
- Data quality summary
- AI-powered suggestions (if enabled)
- Timestamp of the quality check

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

## License

This project is licensed under the terms of the MIT license.
congrad 0.0.5
Generic conjugate gradient solver that works with your favorite backend
Requires Python: >=3.8

# PyConGrad
A somewhat optimized generic batch conjugate gradient algorithm that works with PyTorch, NumPy, CuPy, and whatever other backend you like as long as you code it up.

Heavily inspired by [sbarratt/torch_cg](https://github.com/sbarratt/torch_cg) and uses similar function signatures.

## Installation and Usage

```bash
$ pip install congrad # If you already have either NumPy, PyTorch, CuPy, or your backend of choice installed
$ pip install congrad[numpy] # To enforce NumPy dependency
$ pip install congrad[torch] # To enforce PyTorch dependency
$ pip install congrad[cupy] # To enforce CuPy dependency
```

```python
from congrad.numpy import cg_batch # Or congrad.torch or congrad.cupy

X = np.random.rand(100, 100)
A = X @ X.T + 0.001 * np.eye(100)
b = np.random.rand(100, 10) # PyConGrad expects matrix equations, so the rightmost dimension is for batching.

def A_batch(x):
    return np.matmul(A, x)

solution, solve_info = cg_batch(A_batch, b)
```

For more information, documentation, and detailed instructions, see the `examples` folder.  In particular, notebook 2 shows you how to use a different batch dimension if you want to batch over vectors instead of matrices.
powermap 0.1.0
Client for PowerMap geospatial API services
Requires Python: >=3.7
Keywords: powermap, grid

# PowerMap

A Python client for PowerMap geospatial API services.

## Installation

```bash
pip install powermap
```

## Usage

```python
from powermap import PowerMapClient

# Initialize client with your API token
client = PowerMapClient(token="your_api_token")

# Get grid of plus codes for a geographical zone
codes = client.grid(geozone="ercot_rto", resolution=0.02)
print(f"Found {len(codes)} locations in the zone")
```

## Authentication

To use this client, you need a valid API token. Contact PowerMap to obtain your token.

## Features

- Generate grids of plus codes for geographical zones
- Configurable resolution for grid generation
- Professional error handling
- Simple, intuitive API

## License

MIT
coreagent 0.1.1a0
The Simplest Agent framework. 
Keywords: CoreAgent, LLM, Agent, LLM Agent, AI Agent

<p align="center">
  <picture>
    <img alt="CoreAgent" src="https://raw.githubusercontent.com/CoreAgent-Project/CoreAgent/main/assets/coreagent.png" width=30%>
  </picture>
</p>

<h3 align="center">
Simplest Agent Framework
</h3>

<p align="center">
| <a href="https://github.com/CoreAgent-Project/CoreAgent/blob/main/docs/Documentation.md"><b>Documentation</b></a> | <a href="https://discord.gg/Hytrg9UXgU"><b>Discord</b></a> |
</p>

----

CoreAgent is a lightweight and intuitive framework designed to make building intelligent agents straightforward. Focusing on simplicity, CoreAgent allows you to quickly integrate language models with custom tools to create powerful and versatile applications. 

## Key Features

* **Universal:** Both coding, chatting, one `Agent` class handles them all! 
* **Simplicity First:** Ease of use and minimal boilerplate.
* **Sharable Tool States**: Share the same tool instances states across multiple agents. 
* **Built-in Tools**: Lots of built-in tools to get you started fast! 

## Installation

To install CoreAgent, simply use pip:

```bash
pip install coreagent
````

## Getting Started

Here's a basic example demonstrating how to use CoreAgent:

```python
from coreagent import Agent
import urllib.request
import json

class IPTool:
  def get_my_ip(self) -> str:
    j = json.loads(urllib.request.urlopen("https://api.ipify.org/?format=json").read().decode())
    return j['ip']

s = Agent()
s.register_tool(IPTool())

s.chat("What's my IP address? ")
```

## Registering Tools

CoreAgent makes it easy to integrate your own custom functionalities as tools. To register a tool, you simply need to:

1.  Define a Python class for your tool.
2.  Implement the methods you want to expose to the agent. Use docstrings to provide descriptions for your methods. These descriptions can be used by the agent to understand how to use the tool.
3.  Instantiate your tool class.
4.  Register the instance with the `ChatSession` using the `register_tool()` method.

Refer to the example above for a practical demonstration of tool registration.


## Roadmap
- [x] Basic universal agent framework. 
- [x] Remove `guided_grammar` restriction, allow general LLM usage (DeepSeek API, GPT3.5/4/4o API, Qwen API, etc. )
- [ ] More intuitive simplified examples, alowing hands-on try-outs. 
- [ ] RAG-based memory module. 

## Contributing

Contributions to CoreAgent are welcome! If you have ideas for improvements, bug fixes, or new features, please feel free to open an issue or submit a pull request.

## License
Brought to you by Shanghai Glacies Technologies Co,. LTD. <br />
GNU Lesser General Public License v3.0
https://www.gnu.org/licenses/lgpl-3.0.en.html

## Star History

[![Star History Chart](https://api.star-history.com/svg?repos=CoreAgent-Project/CoreAgent&type=Date)](https://www.star-history.com/#CoreAgent-Project/CoreAgent&Date)