blockchain-compare-py 1.0.0__tar.gz

blockchain_compare_py-1.0.0/PKG-INFO

@@ -0,0 +1,71 @@
+Metadata-Version: 2.4
+Name: blockchain-compare-py
+Version: 1.0.0
+Summary: PyPI Package - blockchain-compare-py v4
+License: MIT
+Project-URL: Homepage, https://github.com/worksOnMyFridge/blockchain-compare-py
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: matplotlib>=3.7
+Requires-Dist: pandas>=2.0
+Requires-Dist: aiohttp>=3.9
+Requires-Dist: requests>=2.31
+
+# blockchain-compare-py
+
+Compare blockchain networks (NEAR, Ethereum, Solana) with latency measurement and visualization tools.
+
+## Requirements
+
+- Python 3.9+
+
+## Installation
+
+pip install blockchain-compare-py
+
+## Optional Dependencies
+
+pip install pandas matplotlib
+
+## Quick Start
+
+from blockchain_compare_py import BlockchainComparePyClient
+
+client = BlockchainComparePyClient(timeout=10)
+
+## Methods
+
+| Method | Description |
+|---|---|
+| `get_block_height(chain)` | Get current block height for a chain |
+| `measure_latency(chain, samples)` | Measure RPC latency for a chain |
+| `compare_latency()` | Compare latency across all chains |
+| `get_metrics(chain)` | Get combined metrics for a chain |
+| `compare_all()` | Compare all metrics across all chains |
+| `to_dataframe()` | Export results as a pandas DataFrame |
+| `plot_latency()` | Plot latency comparison chart |
+| `plot_block_heights()` | Plot block height comparison chart |
+
+## Supported Chains
+
+- **NEAR** — `https://rpc.mainnet.near.org`
+- **Ethereum** — `https://cloudflare-eth.com`
+- **Solana** — `https://api.mainnet-beta.solana.com`
+
+## Example
+
+client = BlockchainComparePyClient()
+
+# Compare latency across chains
+results = client.compare_latency()
+
+# Export to DataFrame (requires pandas)
+df = client.to_dataframe()
+
+# Visualize (requires matplotlib)
+client.plot_latency()
+client.plot_block_heights()
+
+## License
+
+MIT

blockchain_compare_py-1.0.0/README.md

@@ -0,0 +1,58 @@
+# blockchain-compare-py
+
+Compare blockchain networks (NEAR, Ethereum, Solana) with latency measurement and visualization tools.
+
+## Requirements
+
+- Python 3.9+
+
+## Installation
+
+pip install blockchain-compare-py
+
+## Optional Dependencies
+
+pip install pandas matplotlib
+
+## Quick Start
+
+from blockchain_compare_py import BlockchainComparePyClient
+
+client = BlockchainComparePyClient(timeout=10)
+
+## Methods
+
+| Method | Description |
+|---|---|
+| `get_block_height(chain)` | Get current block height for a chain |
+| `measure_latency(chain, samples)` | Measure RPC latency for a chain |
+| `compare_latency()` | Compare latency across all chains |
+| `get_metrics(chain)` | Get combined metrics for a chain |
+| `compare_all()` | Compare all metrics across all chains |
+| `to_dataframe()` | Export results as a pandas DataFrame |
+| `plot_latency()` | Plot latency comparison chart |
+| `plot_block_heights()` | Plot block height comparison chart |
+
+## Supported Chains
+
+- **NEAR** — `https://rpc.mainnet.near.org`
+- **Ethereum** — `https://cloudflare-eth.com`
+- **Solana** — `https://api.mainnet-beta.solana.com`
+
+## Example
+
+client = BlockchainComparePyClient()
+
+# Compare latency across chains
+results = client.compare_latency()
+
+# Export to DataFrame (requires pandas)
+df = client.to_dataframe()
+
+# Visualize (requires matplotlib)
+client.plot_latency()
+client.plot_block_heights()
+
+## License
+
+MIT

blockchain_compare_py-1.0.0/pyproject.toml

@@ -0,0 +1,17 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "blockchain-compare-py"
+version = "1.0.0"
+description = "PyPI Package - blockchain-compare-py v4"
+readme = "README.md"
+requires-python = ">=3.9"
+license = {text = "MIT"}
+dependencies = [
+    "matplotlib>=3.7",
+    "pandas>=2.0","aiohttp>=3.9", "requests>=2.31"]
+
+[project.urls]
+Homepage = "https://github.com/worksOnMyFridge/blockchain-compare-py"

blockchain_compare_py-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

blockchain_compare_py-1.0.0/src/blockchain_compare_py/__init__.py

@@ -0,0 +1,175 @@
+"""blockchain-compare-py: Compare blockchain networks with NEAR-inclusive analysis."""
+
+__version__ = "1.0.0"
+__all__ = ["BlockchainComparePyClient"]
+
+import time
+import statistics
+from typing import Optional
+
+try:
+    import requests
+    HAS_REQUESTS = True
+except ImportError:
+    HAS_REQUESTS = False
+
+try:
+    import pandas as pd
+    HAS_PANDAS = True
+except ImportError:
+    HAS_PANDAS = False
+
+try:
+    import matplotlib.pyplot as plt
+    HAS_MATPLOTLIB = True
+except ImportError:
+    HAS_MATPLOTLIB = False
+
+
+class BlockchainComparePyClient:
+    """Client for comparing blockchain networks including NEAR, Ethereum, and Solana."""
+
+    CHAINS = ["near", "ethereum", "solana"]
+
+    RPC_ENDPOINTS = {
+        "near": "https://rpc.mainnet.near.org",
+        "ethereum": "https://cloudflare-eth.com",
+        "solana": "https://api.mainnet-beta.solana.com",
+    }
+
+    def __init__(self, timeout: int = 10):
+        """Initialize with optional request timeout."""
+        self.timeout = timeout
+        self._session = requests.Session() if HAS_REQUESTS else None
+
+    # ── Internal RPC helpers ──────────────────────────────────────────────────
+
+    def _post(self, url: str, payload: dict) -> Optional[dict]:
+        """Send JSON-RPC POST, return parsed response or None."""
+        if not HAS_REQUESTS:
+            return None
+        try:
+            r = self._session.post(url, json=payload, timeout=self.timeout)
+            r.raise_for_status()
+            return r.json()
+        except Exception:
+            return None
+
+    def _near_latest_block(self) -> Optional[dict]:
+        """Fetch latest NEAR block via RPC."""
+        data = self._post(
+            self.RPC_ENDPOINTS["near"],
+            {"jsonrpc": "2.0", "id": "bc", "method": "block", "params": {"finality": "final"}},
+        )
+        return data.get("result") if data else None
+
+    def _eth_block_number(self) -> Optional[int]:
+        """Fetch latest Ethereum block number."""
+        data = self._post(
+            self.RPC_ENDPOINTS["ethereum"],
+            {"jsonrpc": "2.0", "id": 1, "method": "eth_blockNumber", "params": []},
+        )
+        if data and "result" in data:
+            return int(data["result"], 16)
+        return None
+
+    def _sol_slot(self) -> Optional[int]:
+        """Fetch latest Solana slot."""
+        data = self._post(
+            self.RPC_ENDPOINTS["solana"],
+            {"jsonrpc": "2.0", "id": 1, "method": "getSlot", "params": []},
+        )
+        return data.get("result") if data else None
+
+    # ── Public API ────────────────────────────────────────────────────────────
+
+    def get_block_height(self, chain: str) -> Optional[int]:
+        """Return current block height / slot for the given chain."""
+        chain = chain.lower()
+        if chain == "near":
+            block = self._near_latest_block()
+            return block["header"]["height"] if block else None
+        if chain == "ethereum":
+            return self._eth_block_number()
+        if chain == "solana":
+            return self._sol_slot()
+        raise ValueError(f"Unknown chain: {chain}. Choose from {self.CHAINS}")
+
+    def measure_latency(self, chain: str, samples: int = 3) -> dict:
+        """Measure average RPC round-trip latency (seconds) over N samples."""
+        chain = chain.lower()
+        if chain not in self.CHAINS:
+            raise ValueError(f"Unknown chain: {chain}")
+        timings: list[float] = []
+        for _ in range(samples):
+            t0 = time.perf_counter()
+            self.get_block_height(chain)
+            timings.append(time.perf_counter() - t0)
+        return {
+            "chain": chain,
+            "samples": samples,
+            "avg_latency_s": round(statistics.mean(timings), 4),
+            "min_latency_s": round(min(timings), 4),
+            "max_latency_s": round(max(timings), 4),
+        }
+
+    def compare_latency(self, chains: Optional[list] = None, samples: int = 3) -> list[dict]:
+        """Compare RPC latency across multiple chains."""
+        chains = chains or self.CHAINS
+        return [self.measure_latency(c, samples) for c in chains]
+
+    def get_metrics(self, chain: str) -> dict:
+        """Return live-fetched metrics dict for a chain."""
+        chain = chain.lower()
+        height = self.get_block_height(chain)
+        latency = self.measure_latency(chain, samples=2)
+        return {
+            "chain": chain,
+            "block_height": height,
+            "avg_latency_s": latency["avg_latency_s"],
+        }
+
+    def compare_all(self, chains: Optional[list] = None) -> list[dict]:
+        """Return metrics list for all (or specified) chains."""
+        chains = chains or self.CHAINS
+        return [self.get_metrics(c) for c in chains]
+
+    # ── Pandas integration ────────────────────────────────────────────────────
+
+    def to_dataframe(self, chains: Optional[list] = None):
+        """Return a pandas DataFrame with chain metrics."""
+        if not HAS_PANDAS:
+            raise ImportError("pandas is required: pip install pandas")
+        rows = self.compare_all(chains)
+        return pd.DataFrame(rows).set_index("chain")
+
+    # ── Visualization ─────────────────────────────────────────────────────────
+
+    def plot_latency(self, chains: Optional[list] = None, samples: int = 3):
+        """Bar chart of average RPC latency per chain."""
+        if not HAS_MATPLOTLIB:
+            raise ImportError("matplotlib is required: pip install matplotlib")
+        results = self.compare_latency(chains, samples)
+        labels = [r["chain"] for r in results]
+        values = [r["avg_latency_s"] for r in results]
+        colors = ["#00C08B" if l == "near" else "#627EEA" if l == "ethereum" else "#9945FF" for l in labels]
+        fig, ax = plt.subplots()
+        ax.bar(labels, values, color=colors)
+        ax.set_ylabel("Avg latency (s)")
+        ax.set_title("Blockchain RPC Latency Comparison")
+        plt.tight_layout()
+        return fig
+
+    def plot_block_heights(self, chains: Optional[list] = None):
+        """Bar chart of current block heights per chain."""
+        if not HAS_MATPLOTLIB:
+            raise ImportError("matplotlib is required: pip install matplotlib")
+        chains = chains or self.CHAINS
+        heights = {c: (self.get_block_height(c) or 0) for c in chains}
+        colors = ["#00C08B" if c == "near" else "#627EEA" if c == "ethereum" else "#9945FF" for c in chains]
+        fig, ax = plt.subplots()
+        ax.bar(list(heights.keys()), list(heights.values()), color=colors)
+        ax.set_ylabel("Block height / slot")
+        ax.set_title("Blockchain Block Height Comparison")
+        plt.tight_layout()
+        return fig

blockchain_compare_py-1.0.0/src/blockchain_compare_py.egg-info/PKG-INFO

@@ -0,0 +1,71 @@
+Metadata-Version: 2.4
+Name: blockchain-compare-py
+Version: 1.0.0
+Summary: PyPI Package - blockchain-compare-py v4
+License: MIT
+Project-URL: Homepage, https://github.com/worksOnMyFridge/blockchain-compare-py
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: matplotlib>=3.7
+Requires-Dist: pandas>=2.0
+Requires-Dist: aiohttp>=3.9
+Requires-Dist: requests>=2.31
+
+# blockchain-compare-py
+
+Compare blockchain networks (NEAR, Ethereum, Solana) with latency measurement and visualization tools.
+
+## Requirements
+
+- Python 3.9+
+
+## Installation
+
+pip install blockchain-compare-py
+
+## Optional Dependencies
+
+pip install pandas matplotlib
+
+## Quick Start
+
+from blockchain_compare_py import BlockchainComparePyClient
+
+client = BlockchainComparePyClient(timeout=10)
+
+## Methods
+
+| Method | Description |
+|---|---|
+| `get_block_height(chain)` | Get current block height for a chain |
+| `measure_latency(chain, samples)` | Measure RPC latency for a chain |
+| `compare_latency()` | Compare latency across all chains |
+| `get_metrics(chain)` | Get combined metrics for a chain |
+| `compare_all()` | Compare all metrics across all chains |
+| `to_dataframe()` | Export results as a pandas DataFrame |
+| `plot_latency()` | Plot latency comparison chart |
+| `plot_block_heights()` | Plot block height comparison chart |
+
+## Supported Chains
+
+- **NEAR** — `https://rpc.mainnet.near.org`
+- **Ethereum** — `https://cloudflare-eth.com`
+- **Solana** — `https://api.mainnet-beta.solana.com`
+
+## Example
+
+client = BlockchainComparePyClient()
+
+# Compare latency across chains
+results = client.compare_latency()
+
+# Export to DataFrame (requires pandas)
+df = client.to_dataframe()
+
+# Visualize (requires matplotlib)
+client.plot_latency()
+client.plot_block_heights()
+
+## License
+
+MIT

blockchain_compare_py-1.0.0/src/blockchain_compare_py.egg-info/SOURCES.txt

@@ -0,0 +1,8 @@
+README.md
+pyproject.toml
+src/blockchain_compare_py/__init__.py
+src/blockchain_compare_py.egg-info/PKG-INFO
+src/blockchain_compare_py.egg-info/SOURCES.txt
+src/blockchain_compare_py.egg-info/dependency_links.txt
+src/blockchain_compare_py.egg-info/requires.txt
+src/blockchain_compare_py.egg-info/top_level.txt

blockchain_compare_py-1.0.0/src/blockchain_compare_py.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

blockchain_compare_py-1.0.0/src/blockchain_compare_py.egg-info/requires.txt

@@ -0,0 +1,4 @@
+matplotlib>=3.7
+pandas>=2.0
+aiohttp>=3.9
+requests>=2.31

blockchain_compare_py-1.0.0/src/blockchain_compare_py.egg-info/top_level.txt

@@ -0,0 +1 @@
+blockchain_compare_py