Metadata-Version: 2.4
Name: bizx
Version: 0.1.1
Summary: An open-source Data & AI engineering ecosystem for building modern, production-oriented applications.
Author: Saman Siadati
License-Expression: MIT
Project-URL: Homepage, https://github.com/samansiadati/bizx
Project-URL: Repository, https://github.com/samansiadati/bizx
Project-URL: Issues, https://github.com/samansiadati/bizx/issues
Keywords: bizx,data-engineering,data,etl,data-processing,data-quality,data-profiling,pandas,spark,pyspark,sql,artificial-intelligence,ai,machine-learning,deep-learning,generative-ai,genai,llm,rag,ai-agents,mlops,observability,cloud,aws,azure,gcp
Classifier: Development Status :: 3 - Alpha
Classifier: Intended Audience :: Developers
Classifier: Intended Audience :: Science/Research
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.10
Classifier: Programming Language :: Python :: 3.11
Classifier: Programming Language :: Python :: 3.12
Classifier: Programming Language :: Python :: 3.13
Classifier: Operating System :: OS Independent
Classifier: Topic :: Software Development :: Libraries
Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
Classifier: Topic :: Scientific/Engineering :: Information Analysis
Requires-Python: >=3.10
Description-Content-Type: text/markdown
License-File: LICENSE
Provides-Extra: de
Requires-Dist: numpy>=1.26; extra == "de"
Requires-Dist: pandas>=2.0; extra == "de"
Provides-Extra: spark
Requires-Dist: pyspark>=3.5; extra == "spark"
Provides-Extra: ai
Requires-Dist: numpy>=1.26; extra == "ai"
Requires-Dist: scikit-learn>=1.4; extra == "ai"
Provides-Extra: genai
Requires-Dist: transformers>=4.40; extra == "genai"
Requires-Dist: huggingface-hub>=0.20; extra == "genai"
Provides-Extra: aws
Requires-Dist: boto3>=1.34; extra == "aws"
Provides-Extra: dev
Requires-Dist: pytest>=8.0; extra == "dev"
Requires-Dist: pytest-cov>=5.0; extra == "dev"
Requires-Dist: ruff>=0.5; extra == "dev"
Requires-Dist: mypy>=1.10; extra == "dev"
Requires-Dist: build>=1.2; extra == "dev"
Requires-Dist: twine>=5.0; extra == "dev"
Provides-Extra: all
Requires-Dist: numpy>=1.26; extra == "all"
Requires-Dist: pandas>=2.0; extra == "all"
Requires-Dist: pyspark>=3.5; extra == "all"
Requires-Dist: scikit-learn>=1.4; extra == "all"
Requires-Dist: transformers>=4.40; extra == "all"
Requires-Dist: huggingface-hub>=0.20; extra == "all"
Requires-Dist: boto3>=1.34; extra == "all"
Dynamic: license-file

# BizX

### The ecosystem for Data Engineering, Artificial Intelligence, Generative AI, MLOps, and Cloud-Native Engineering.

[![PyPI](https://img.shields.io/pypi/v/bizx.svg)](https://pypi.org/project/bizx/)
[![Python](https://img.shields.io/pypi/pyversions/bizx.svg)](https://pypi.org/project/bizx/)
[![License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
[![GitHub Stars](https://img.shields.io/github/stars/samansiadati/bizx.svg)](https://github.com/samansiadati/bizx/stargazers)
[![GitHub Issues](https://img.shields.io/github/issues/samansiadati/bizx.svg)](https://github.com/samansiadati/bizx/issues)

---

## 🚀 What is BizX?

**BizX** is an open-source ecosystem designed to bring modern **Data Engineering and Artificial Intelligence** capabilities together under a unified architecture.

BizX provides a modular foundation for building, integrating, and operating modern data and AI systems.

The ecosystem covers areas such as:

* Data Engineering
* Data Processing
* Data Quality
* Machine Learning
* Deep Learning
* Generative AI
* Large Language Models
* RAG
* AI Agents
* AI Evaluation
* MLOps
* AI Observability
* Cloud AI
* Cloud Data Engineering

The current implementation is written in **Python**.

The longer-term vision is to evolve BizX beyond a single-language library into an ecosystem that can organize Data and AI capabilities across multiple programming languages and technology stacks.

> **Or, even better, at the ecosystem level:**
>
> **BizX — one ecosystem for Data and AI Engineering.**

---

# 🌐 The BizX Ecosystem

BizX is organized around two primary engineering domains:

```text
                              BIZX
                               │
                  Data & AI Engineering Ecosystem
                               │
                 ┌─────────────┴─────────────┐
                 │                           │
                 ▼                           ▼
        ┌─────────────────┐         ┌─────────────────┐
        │       DE        │         │       AI        │
        │ Data Engineering│         │ Artificial Intel│
        └────────┬────────┘         └────────┬────────┘
                 │                           │
       ┌─────────┼──────────┐       ┌────────┼──────────┐
       │         │          │       │        │          │
       ▼         ▼          ▼       ▼        ▼          ▼
    DataFrame   ETL       Spark     ML      GenAI      LLM
       │         │          │       │        │          │
       ▼         ▼          ▼       ▼        ▼          ▼
    Quality    SQL       Cloud     DL       RAG       Agents
       │                    │       │        │          │
       │                    ▼       ▼        ▼          ▼
       │                   AWS   Evaluation MLOps  Observability
       │
       └───────────────────────────────────────────────────
```

The architectural principle is simple:

```text
                        BizX
                         │
              ┌──────────┴──────────┐
              │                     │
             DE                     AI
              │                     │
       Data Engineering       Artificial Intelligence
              │                     │
      ┌───────┼───────┐     ┌───────┼──────────────┐
      │       │       │     │       │              │
    Data     ETL    Spark   ML     GenAI          LLM
    SQL     Quality Cloud   DL      RAG          Agents
                              │       │              │
                              └───────┼──────────────┘
                                      │
                              Evaluation / MLOps
                                      │
                               Observability
```

---

# 🏗️ Architecture

The Python implementation follows a domain-oriented architecture.

```text
src/bizx/
│
├── core/
│
├── de/
│   ├── cloud/
│   │   └── aws/
│   │       ├── glue/
│   │       └── s3/
│   │
│   ├── dataframe/
│   ├── etl/
│   ├── profiling/
│   ├── quality/
│   ├── spark/
│   └── sql/
│
└── ai/
    ├── agents/
    ├── cloud/
    │   └── aws/
    │       ├── bedrock/
    │       └── sagemaker/
    │
    ├── deep_learning/
    ├── embeddings/
    ├── evaluation/
    ├── genai/
    ├── llm/
    ├── ml/
    ├── mlops/
    ├── observability/
    └── rag/
```

### `bizx.core`

The foundational layer.

It is intended to contain functionality shared across the ecosystem, such as:

* Common abstractions
* Configuration
* Exceptions
* Types
* Interfaces
* Shared utilities

The core should remain lightweight and stable.

---

## 📊 `bizx.de` — Data Engineering

The Data Engineering domain contains functionality for building reliable and scalable data systems.

Planned areas include:

* DataFrames
* ETL / ELT
* Data transformation
* Data profiling
* Data quality
* Data validation
* SQL
* Apache Spark
* PySpark
* Distributed processing
* Cloud data services
* AWS Glue
* Amazon S3
* Future data platforms

Example:

```python
from bizx.de import DataProfiler

profiler = DataProfiler(df)

report = profiler.generate()

print(report)
```

---

## 🤖 `bizx.ai` — Artificial Intelligence

The AI domain contains capabilities for machine learning, generative AI, LLM applications, and production AI systems.

Planned areas include:

* Machine Learning
* Deep Learning
* Generative AI
* Large Language Models
* Embeddings
* RAG
* AI Agents
* Model Evaluation
* LLM Evaluation
* MLOps
* AI Observability
* AI Safety and Governance
* Cloud AI services

---

## 🧠 Generative AI & LLM

Generative AI capabilities are organized inside the AI domain.

```text
bizx.ai
│
├── genai/
├── llm/
├── embeddings/
├── rag/
├── agents/
├── evaluation/
└── observability/
```

This provides a clear separation between general AI functionality and specialized GenAI capabilities.

Planned functionality includes:

* LLM interfaces
* Prompt management
* Prompt templates
* Embeddings
* Vector search
* Retrieval-Augmented Generation
* AI agents
* Tool calling
* Context management
* LLM evaluation
* Hallucination detection
* AI safety
* AI governance

---

# ☁️ Cloud Integration

Cloud-specific capabilities belong inside the domain where they are primarily used.

For example:

```text
bizx.de.cloud.aws.glue
```

is a Data Engineering capability, while:

```text
bizx.ai.cloud.aws.bedrock
```

is an AI capability.

This keeps the architecture domain-oriented rather than creating a large independent collection of cloud-specific modules.

```text
                         BizX
                           │
                ┌──────────┴──────────┐
                │                     │
               DE                     AI
                │                     │
             Cloud                  Cloud
                │                     │
               AWS                   AWS
                │                     │
          ┌─────┴─────┐        ┌─────┴────────┐
          │           │        │              │
        Glue          S3     Bedrock       SageMaker
```

Future cloud providers can be added without changing the fundamental architecture.

Potential integrations include:

* AWS
* Azure
* Google Cloud
* Databricks
* Other cloud and data platforms

---

# 🌍 Ecosystem-Level Vision

BizX currently provides a **Python implementation**.

However, the long-term vision is broader.

Modern Data and AI engineering is not limited to one programming language.

The ecosystem may eventually contain implementations or integrations across:

```text
Python
Java
.NET
JavaScript / TypeScript
Go
Scala
Other ecosystems
```

Conceptually:

```text
                 Programming Languages
                         │
       ┌─────────────────┼─────────────────┐
       │                 │                 │
    Python             Java              .NET
       │                 │                 │
       └─────────────────┼─────────────────┘
                         │
                         ▼
                       BizX
                         │
              ┌──────────┴──────────┐
              │                     │
             DE                     AI
              │                     │
       Data Engineering       Artificial Intelligence
              │                     │
          Cloud / Data          Cloud / AI
          Platforms             Platforms
```

This does **not** mean BizX currently supports these languages.

The current project is focused on building a strong Python foundation first.

---

# 🎯 Design Principles

## 1. Domain-Oriented

Technology should be organized according to the engineering domain it serves.

For example:

```text
AWS Glue → DE
Amazon S3 → DE
Apache Spark → DE

Amazon Bedrock → AI
SageMaker → AI
LLMs → AI
RAG → AI
Agents → AI
```

This makes the ecosystem easier to understand and extend.

---

## 2. Modular

Users should be able to install only the capabilities they need.

```bash
pip install bizx
```

or install optional functionality:

```bash
pip install "bizx[data]"
```

```bash
pip install "bizx[ai]"
```

```bash
pip install "bizx[llm]"
```

```bash
pip install "bizx[aws]"
```

```bash
pip install "bizx[spark]"
```

or install the complete ecosystem:

```bash
pip install "bizx[all]"
```

---

## 3. Composable

BizX components should be designed to work independently and together.

A typical production workflow may look like:

```text
Data
  │
  ▼
Ingestion
  │
  ▼
Transformation
  │
  ▼
Validation
  │
  ▼
Feature / Data Preparation
  │
  ▼
ML / AI / GenAI
  │
  ▼
Evaluation
  │
  ▼
Deployment
  │
  ▼
Monitoring
  │
  ▼
Observability
```

---

## 4. Cloud-Aware, Not Cloud-Locked

The core architecture should remain independent of any specific cloud provider.

Cloud integrations belong in dedicated modules.

```text
bizx.core
    │
    ├── bizx.de.cloud.aws
    ├── bizx.ai.cloud.aws
    ├── future Azure integrations
    ├── future GCP integrations
    └── future platform integrations
```

---

## 5. Production-Oriented

BizX is intended to support real-world Data and AI systems.

Important concerns include:

* Testing
* Configuration
* Logging
* Error handling
* Observability
* Reproducibility
* Security
* Evaluation
* Monitoring
* Scalability

---

## 6. Interoperability

BizX is not intended to replace established technologies.

Instead, it should provide useful abstractions and integrations around technologies such as:

* Pandas
* NumPy
* Apache Spark
* PySpark
* scikit-learn
* Hugging Face
* AWS
* Databricks
* SQL systems
* Vector databases
* LLM providers
* Cloud AI platforms

---

# 📦 Installation

## Basic Installation

```bash
pip install bizx
```

## Data Engineering

```bash
pip install "bizx[data]"
```

## AI / Machine Learning

```bash
pip install "bizx[ai]"
```

## LLM

```bash
pip install "bizx[llm]"
```

## AWS

```bash
pip install "bizx[aws]"
```

## Apache Spark

```bash
pip install "bizx[spark]"
```

## Complete Ecosystem

```bash
pip install "bizx[all]"
```

## Development

```bash
pip install "bizx[dev]"
```

---

# ⚡ Quick Start

Check the installed version:

```python
import bizx

print(bizx.__version__)
```

## Data Profiling

```python
import pandas as pd

from bizx.de import DataProfiler

df = pd.DataFrame(
    {
        "name": ["Alice", "Bob", "Charlie"],
        "age": [25, 30, None],
    }
)

profiler = DataProfiler(df)

report = profiler.generate()

print(report)
```

Example result:

```python
{
    "rows": 3,
    "columns": 2,
    "missing_values": {
        "name": 0,
        "age": 1
    },
    "dtypes": {
        "name": "object",
        "age": "float64"
    }
}
```

> **Note:** BizX is currently in Alpha development. APIs may evolve before the `1.0.0` release.

---

# 📁 Project Structure

```text
bizx/
│
├── docs/
├── examples/
├── tests/
│
├── src/
│   └── bizx/
│       │
│       ├── __init__.py
│       │
│       ├── core/
│       │
│       ├── de/
│       │   ├── __init__.py
│       │   ├── cloud/
│       │   │   └── aws/
│       │   │       ├── glue/
│       │   │       └── s3/
│       │   ├── dataframe/
│       │   ├── etl/
│       │   ├── profiling/
│       │   ├── quality/
│       │   ├── spark/
│       │   └── sql/
│       │
│       └── ai/
│           ├── __init__.py
│           ├── agents/
│           ├── cloud/
│           │   └── aws/
│           │       ├── bedrock/
│           │       └── sagemaker/
│           ├── deep_learning/
│           ├── embeddings/
│           ├── evaluation/
│           ├── genai/
│           ├── llm/
│           ├── ml/
│           ├── mlops/
│           ├── observability/
│           └── rag/
│
├── .gitignore
├── LICENSE
├── README.md
└── pyproject.toml
```

---

# 🧪 Development

Clone the repository:

```bash
git clone https://github.com/samansiadati/bizx.git
cd bizx
```

Create a virtual environment:

```bash
python -m venv .venv
```

Activate it on Linux/macOS:

```bash
source .venv/bin/activate
```

Install BizX in editable mode with development dependencies:

```bash
pip install -e ".[dev]"
```

Run the test suite:

```bash
pytest
```

Build the distribution:

```bash
python -m build
```

Validate the package:

```bash
python -m twine check dist/*
```

---

# 🗺️ Roadmap

## Phase 1 — Foundation

* [x] Establish Python package
* [x] Establish DE domain
* [x] Establish AI domain
* [x] PyPI packaging
* [x] Basic Data Profiler
* [x] Domain-oriented package structure
* [ ] Common configuration
* [ ] Common exceptions
* [ ] Common types
* [ ] Logging framework
* [ ] CI/CD
* [ ] Documentation system

---

## Phase 2 — Data Engineering

* [ ] DataFrame utilities
* [ ] Data profiling
* [ ] Data validation
* [ ] Data quality
* [ ] ETL / ELT utilities
* [ ] SQL utilities
* [ ] Spark utilities
* [ ] AWS Glue utilities
* [ ] Amazon S3 utilities
* [ ] Additional data-platform integrations

---

## Phase 3 — AI / ML

* [ ] Machine learning utilities
* [ ] Model interfaces
* [ ] Training utilities
* [ ] Feature engineering
* [ ] Model evaluation
* [ ] Deep learning utilities
* [ ] AI pipelines

---

## Phase 4 — Generative AI

* [ ] LLM interfaces
* [ ] Prompt utilities
* [ ] Embeddings
* [ ] RAG
* [ ] Vector search
* [ ] AI agents
* [ ] Tool calling
* [ ] LLM evaluation
* [ ] Hallucination detection

---

## Phase 5 — MLOps & AI Operations

* [ ] Experiment tracking
* [ ] Model monitoring
* [ ] Data drift detection
* [ ] Model drift detection
* [ ] LLM monitoring
* [ ] AI observability
* [ ] Production evaluation
* [ ] AI governance

---

## Phase 6 — Cloud

* [ ] AWS
* [ ] Amazon Bedrock
* [ ] Amazon SageMaker
* [ ] Amazon S3
* [ ] AWS Glue
* [ ] Amazon OpenSearch
* [ ] AWS Lambda
* [ ] API Gateway
* [ ] Databricks
* [ ] Azure integrations
* [ ] Google Cloud integrations

---

## Phase 7 — Ecosystem Expansion

The longer-term objective is to expand the BizX ecosystem beyond a single programming language.

Potential ecosystems include:

```text
Python
Java
.NET
JavaScript / TypeScript
Go
Scala
...
```

The architecture will evolve carefully so that language-specific implementations can share common ecosystem concepts without forcing unrelated technologies into the same codebase.

---

# 📚 Documentation

Documentation will grow alongside the project.

Planned areas include:

* Getting Started
* Installation
* Core API
* Data Engineering
* AI / ML
* Generative AI
* LLMs
* RAG
* AI Agents
* MLOps
* Observability
* Cloud Integrations
* Examples
* Architecture
* Developer Guide

---

# 🤝 Contributing

Contributions, ideas, discussions, bug reports, and architectural proposals are welcome.

Before submitting significant functionality, consider opening an issue to discuss the proposed design and how it fits within the BizX ecosystem.

Typical contribution workflow:

```bash
git checkout -b feature/my-feature

# Make changes

pytest

git add .
git commit -m "Add my feature"

git push origin feature/my-feature
```

Then open a pull request on GitHub.

---

# 🔐 Security

Please do not report security vulnerabilities through public GitHub issues.

Security reporting procedures will be documented as the project matures.

---

# 📈 Project Status

**Current Status: Alpha**

BizX is under active development.

The package structure and public APIs may change before the `1.0.0` release.

The current priority is establishing a strong architectural foundation before expanding the number of production-ready components.

---

# 👨‍💻 Author

**Saman Siadati**

BizX is an open-source project focused on building practical, reusable infrastructure for modern Data and AI engineering.

---

# 📄 License

BizX is released under the **MIT License**.

See [LICENSE](LICENSE) for the complete license text.

---

# ⭐ Support the Project

If you find BizX useful:

* ⭐ Star the GitHub repository
* 🐛 Report bugs
* 💡 Suggest improvements
* 📖 Improve documentation
* 🔧 Submit pull requests
* 💬 Discuss architectural ideas
* 📢 Share the project

---

# 🔗 Links

* **GitHub:** https://github.com/samansiadati/bizx
* **PyPI:** https://pypi.org/project/bizx/
* **Issues:** https://github.com/samansiadati/bizx/issues

---

> **BizX — one ecosystem for Data and AI Engineering.**
