parq-cli 0.0.1__py3-none-any.whl

parq/__init__.py

@@ -0,0 +1,10 @@
+"""
+parq-cli: A powerful command-line tool for inspecting and analyzing Apache Parquet files.
+"""
+
+__version__ = "0.1.0"
+__author__ = "Jinfeng Sun"
+
+# {{CHENGQI:
+# Action: Created; Timestamp: 2025-10-14 16:12:00 +08:00; Reason: Package initialization file; Principle_Applied: KISS
+# }}

parq/__main__.py

@@ -0,0 +1,15 @@
+"""
+Entry point for running parq as a module.
+Allows execution via: python -m parq
+"""
+
+from parq.cli import app
+
+if __name__ == "__main__":
+    app()
+
+# {{CHENGQI:
+# Action: Modified; Timestamp: 2025-10-14 18:07:04 +08:00;
+# Reason: Entry point using app() with command-based design;
+# Principle_Applied: KISS, Typer best practices
+# }}

parq/cli.py

@@ -0,0 +1,130 @@
+"""
+CLI application module.
+Command-line interface for parq-cli tool.
+"""
+
+from pathlib import Path
+from typing import Optional
+
+import typer
+from typing_extensions import Annotated
+
+from parq.output import OutputFormatter
+from parq.reader import ParquetReader
+
+app = typer.Typer(
+    name="parq",
+    help="A powerful command-line tool for inspecting Apache Parquet files 🚀",
+    add_completion=False,
+    no_args_is_help=False,
+)
+
+formatter = OutputFormatter()
+
+
+@app.command()
+def main(
+    file: Annotated[
+        Optional[Path],
+        typer.Argument(
+            help="Path to Parquet file",
+        ),
+    ] = None,
+    schema: Annotated[
+        bool, typer.Option("--schema", "-s", help="Display schema information")
+    ] = False,
+    head: Annotated[Optional[int], typer.Option("--head", help="Display first N rows")] = None,
+    tail: Annotated[Optional[int], typer.Option("--tail", help="Display last N rows")] = None,
+    count: Annotated[bool, typer.Option("--count", "-c", help="Display total row count")] = False,
+    version: Annotated[
+        bool, typer.Option("--version", "-v", help="Show version information")
+    ] = False,
+) -> None:
+    """
+    A powerful command-line tool for inspecting Apache Parquet files 🚀
+
+    Examples:
+
+        # Show file metadata
+        parq data.parquet
+
+        # Show schema
+        parq data.parquet --schema
+
+        # Show first 10 rows
+        parq data.parquet --head 10
+
+        # Show last 5 rows
+        parq data.parquet --tail 5
+
+        # Show row count
+        parq data.parquet --count
+
+        # Show version
+        parq --version
+    """
+
+    # Handle version flag
+    if version:
+        from parq import __version__
+
+        typer.echo(f"parq-cli version {__version__}")
+        return
+
+    # File is required if not showing version
+    if file is None:
+        typer.echo("Error: Missing argument 'FILE'.")
+        typer.echo("Try 'parq --help' for help.")
+        raise typer.Exit(code=1)
+
+    try:
+        reader = ParquetReader(str(file))
+
+        # If no options specified, show metadata
+        if not any([schema, head is not None, tail is not None, count]):
+            metadata = reader.get_metadata_dict()
+            formatter.print_metadata(metadata)
+            return
+
+        # Show schema
+        if schema:
+            schema_info = reader.get_schema_info()
+            formatter.print_schema(schema_info)
+
+        # Show head
+        if head is not None:
+            table = reader.read_head(head)
+            formatter.print_table(table, f"First {head} Rows")
+
+        # Show tail
+        if tail is not None:
+            table = reader.read_tail(tail)
+            formatter.print_table(table, f"Last {tail} Rows")
+
+        # Show count
+        if count:
+            formatter.print_count(reader.num_rows)
+
+    except FileNotFoundError as e:
+        formatter.print_error(str(e))
+        raise typer.Exit(code=1)
+    except Exception as e:
+        formatter.print_error(f"Failed to read Parquet file: {e}")
+        raise typer.Exit(code=1)
+
+
+if __name__ == "__main__":
+    app()
+
+
+# {{CHENGQI:
+# Action: Modified; Timestamp: 2025-10-14 18:07:04 +08:00;
+# Reason: Fixed CLI options parsing by using @app.command() instead of @app.callback();
+# Principle_Applied: KISS, Typer best practices - single command app should use @app.command()
+# }}
+# {{START MODIFICATIONS}}
+# - Changed @app.callback(invoke_without_command=True) to @app.command()
+# - Removed ctx parameter and subcommand checking logic (lines 67-69)
+# - This fixes the issue where options like --schema were incorrectly parsed as subcommands
+# - Now 'parq file.parquet --schema' works correctly as expected
+# {{END MODIFICATIONS}}

parq/output.py

@@ -0,0 +1,176 @@
+"""
+Output formatting module.
+Handles pretty-printing of Parquet data and metadata.
+"""
+
+from typing import Any, Dict, List
+
+import pyarrow as pa
+from rich import box
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+console = Console()
+
+
+class OutputFormatter:
+    """Formatter for displaying Parquet data and metadata."""
+
+    @staticmethod
+    def _format_file_size(size_bytes: int) -> str:
+        """
+        Format file size in human-readable format.
+        
+        Args:
+            size_bytes: Size in bytes
+            
+        Returns:
+            Formatted string like "1.23 MB"
+        """
+        if size_bytes < 1024:
+            return f"{size_bytes} B"
+        elif size_bytes < 1024 * 1024:
+            return f"{size_bytes / 1024:.2f} KB"
+        elif size_bytes < 1024 * 1024 * 1024:
+            return f"{size_bytes / (1024 * 1024):.2f} MB"
+        else:
+            return f"{size_bytes / (1024 * 1024 * 1024):.2f} GB"
+
+    @staticmethod
+    def print_metadata(metadata_dict: Dict[str, Any]) -> None:
+        """
+        Print file metadata in a formatted panel.
+
+        Args:
+            metadata_dict: Dictionary containing metadata
+        """
+        # Special handling for specific fields
+        content_lines = []
+        for key, value in metadata_dict.items():
+            if key == "num_columns":
+                content_lines.append(
+                    f"[cyan]{key}:[/cyan] [yellow]{value}[/yellow] [dim](logical)[/dim]"
+                )
+            elif key == "num_physical_columns":
+                content_lines.append(
+                    f"[cyan]{key}:[/cyan] [yellow]{value}[/yellow] [dim](storage)[/dim]"
+                )
+            elif key == "file_size":
+                # Format file size in human-readable format
+                formatted_size = OutputFormatter._format_file_size(value)
+                content_lines.append(f"[cyan]{key}:[/cyan] [yellow]{formatted_size}[/yellow]")
+            else:
+                content_lines.append(f"[cyan]{key}:[/cyan] [yellow]{value}[/yellow]")
+
+        content = "\n".join(content_lines)
+
+        panel = Panel(
+            content,
+            title="[bold green]📊 Parquet File Metadata[/bold green]",
+            border_style="green",
+            box=box.ROUNDED,
+        )
+        console.print(panel)
+
+    @staticmethod
+    def print_schema(schema_info: List[Dict[str, Any]]) -> None:
+        """
+        Print schema information as a table.
+
+        Args:
+            schema_info: List of column information dictionaries
+        """
+        table = Table(
+            title="[bold blue]📋 Schema Information[/bold blue]",
+            box=box.ROUNDED,
+            show_header=True,
+            header_style="bold magenta",
+        )
+
+        table.add_column("Column Name", style="cyan", no_wrap=True)
+        table.add_column("Data Type", style="green")
+        table.add_column("Nullable", style="yellow")
+
+        for col in schema_info:
+            table.add_row(col["name"], col["type"], "✓" if col["nullable"] else "✗")
+
+        console.print(table)
+
+    @staticmethod
+    def print_table(arrow_table: pa.Table, title: str = "Data Preview") -> None:
+        """
+        Print PyArrow table as a Rich table.
+
+        Args:
+            arrow_table: PyArrow table to display
+            title: Title for the table
+        """
+        # Convert to pandas for easier display
+        df = arrow_table.to_pandas()
+
+        table = Table(
+            title=f"[bold blue]📄 {title}[/bold blue]",
+            box=box.ROUNDED,
+            show_header=True,
+            header_style="bold magenta",
+        )
+
+        # Add columns
+        for col in df.columns:
+            table.add_column(str(col), style="cyan")
+
+        # Add rows
+        for _, row in df.iterrows():
+            table.add_row(*[str(val) for val in row])
+
+        console.print(table)
+
+    @staticmethod
+    def print_count(count: int) -> None:
+        """
+        Print row count.
+
+        Args:
+            count: Number of rows
+        """
+        panel = Panel(
+            f"[bold yellow]{count:,}[/bold yellow] rows",
+            title="[bold green]📊 Total Rows[/bold green]",
+            border_style="green",
+            box=box.ROUNDED,
+        )
+        console.print(panel)
+
+    @staticmethod
+    def print_error(message: str) -> None:
+        """
+        Print error message.
+
+        Args:
+            message: Error message to display
+        """
+        console.print(f"[bold red]❌ Error:[/bold red] {message}")
+
+    @staticmethod
+    def print_success(message: str) -> None:
+        """
+        Print success message.
+
+        Args:
+            message: Success message to display
+        """
+        console.print(f"[bold green]✓[/bold green] {message}")
+
+
+# {{CHENGQI:
+# Action: Modified; Timestamp: 2025-10-14 HH:MM:SS +08:00;
+# Reason: Enhanced metadata display to show both logical and physical column counts;
+# Principle_Applied: User-centric design - clear distinction between logical and physical columns
+# }}
+# {{START MODIFICATIONS}}
+# - Enhanced print_metadata to distinguish logical vs physical columns
+# - Added visual indicators: (logical) for num_columns, (storage) for num_physical_columns
+# - Added informative note when physical columns differ from logical columns
+# - Helps users understand nested structure impact on column count
+# {{END MODIFICATIONS}}

parq/reader.py

@@ -0,0 +1,164 @@
+"""
+Parquet file reader module.
+Provides functionality to read and inspect Parquet files.
+"""
+
+from pathlib import Path
+from typing import List, Optional
+
+import pyarrow as pa
+import pyarrow.parquet as pq
+
+
+class ParquetReader:
+    """Parquet file reader with metadata inspection capabilities."""
+
+    def __init__(self, file_path: str):
+        """
+        Initialize ParquetReader with a file path.
+
+        Args:
+            file_path: Path to the Parquet file
+        """
+        self.file_path = Path(file_path)
+        if not self.file_path.exists():
+            raise FileNotFoundError(f"File not found: {file_path}")
+
+        self._parquet_file = pq.ParquetFile(self.file_path)
+
+    @property
+    def metadata(self) -> pq.FileMetaData:
+        """Get file metadata."""
+        return self._parquet_file.metadata
+
+    @property
+    def schema(self) -> pa.Schema:
+        """Get file schema."""
+        return self._parquet_file.schema_arrow
+
+    @property
+    def num_rows(self) -> int:
+        """Get total number of rows."""
+        return self.metadata.num_rows
+
+    @property
+    def num_columns(self) -> int:
+        """Get total number of columns (logical schema columns)."""
+        return len(self.schema)
+
+    @property
+    def num_physical_columns(self) -> int:
+        """Get total number of physical columns (from metadata)."""
+        return self.metadata.num_columns
+
+    @property
+    def num_row_groups(self) -> int:
+        """Get number of row groups."""
+        return self.metadata.num_row_groups
+
+    def get_metadata_dict(self) -> dict:
+        """
+        Get metadata as a dictionary.
+
+        Returns:
+            Dictionary containing file metadata
+        """
+        metadata_dict = {
+            "file_path": str(self.file_path),
+            "num_rows": self.num_rows,
+            "num_columns": self.num_columns,
+        }
+
+        # Add physical columns right after logical columns if different
+        if self.num_physical_columns != self.num_columns:
+            metadata_dict["num_physical_columns"] = self.num_physical_columns
+
+        # Add file size
+        file_size = self.file_path.stat().st_size
+        metadata_dict["file_size"] = file_size
+        
+        # Add compression type (from first row group, first column)
+        if self.num_row_groups > 0:
+            compression = self.metadata.row_group(0).column(0).compression
+            metadata_dict["compression_types"] = compression
+
+        # Add remaining metadata
+        metadata_dict.update(
+            {
+                "num_row_groups": self.num_row_groups,
+                "format_version": self.metadata.format_version,
+                "serialized_size": self.metadata.serialized_size,
+                "created_by": self.metadata.created_by,
+            }
+        )
+
+        return metadata_dict
+
+    def get_schema_info(self) -> List[dict]:
+        """
+        Get schema information as a list of column details.
+
+        Returns:
+            List of dictionaries with column information
+        """
+        schema_info = []
+        for field in self.schema:
+            schema_info.append(
+                {
+                    "name": field.name,
+                    "type": str(field.type),
+                    "nullable": field.nullable,
+                }
+            )
+        return schema_info
+
+    def read_head(self, n: int = 5) -> pa.Table:
+        """
+        Read first n rows.
+
+        Args:
+            n: Number of rows to read
+
+        Returns:
+            PyArrow table with first n rows
+        """
+        table = self._parquet_file.read()
+        return table.slice(0, min(n, self.num_rows))
+
+    def read_tail(self, n: int = 5) -> pa.Table:
+        """
+        Read last n rows.
+
+        Args:
+            n: Number of rows to read
+
+        Returns:
+            PyArrow table with last n rows
+        """
+        table = self._parquet_file.read()
+        start = max(0, self.num_rows - n)
+        return table.slice(start, n)
+
+    def read_columns(self, columns: Optional[List[str]] = None) -> pa.Table:
+        """
+        Read specific columns.
+
+        Args:
+            columns: List of column names to read. If None, read all columns.
+
+        Returns:
+            PyArrow table with selected columns
+        """
+        return self._parquet_file.read(columns=columns)
+
+
+# {{CHENGQI:
+# Action: Modified; Timestamp: 2025-10-14 HH:MM:SS +08:00;
+# Reason: Fixed num_columns to use schema length instead of metadata for accurate logical column count;
+# Principle_Applied: User-centric design - show logical columns that users actually see
+# }}
+# {{START MODIFICATIONS}}
+# - Changed num_columns from metadata.num_columns to len(self.schema)
+# - Reason: metadata.num_columns may include physical columns from nested structures
+# - Schema length represents logical columns that users expect to see
+# {{END MODIFICATIONS}}

parq_cli-0.0.1.dist-info/METADATA

@@ -0,0 +1,226 @@
+Metadata-Version: 2.4
+Name: parq-cli
+Version: 0.0.1
+Summary: A powerful command-line tool for inspecting and analyzing Apache Parquet files
+Project-URL: Homepage, https://github.com/Tendo33/parq-cli
+Project-URL: Repository, https://github.com/Tendo33/parq-cli
+Project-URL: Issues, https://github.com/Tendo33/parq-cli/issues
+Project-URL: Documentation, https://github.com/Tendo33/parq-cli#readme
+Author-email: SimonSun <sjf19981112@gmail.com>
+License: MIT
+License-File: LICENSE
+Keywords: analytics,apache-parquet,cli,data,data-tools,parquet
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.9
+Requires-Dist: pandas>=2.0.0
+Requires-Dist: pyarrow>=18.0.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: typer>=0.15.0
+Provides-Extra: dev
+Requires-Dist: black>=24.0.0; extra == 'dev'
+Requires-Dist: pytest-cov>=4.1.0; extra == 'dev'
+Requires-Dist: pytest>=8.0.0; extra == 'dev'
+Requires-Dist: ruff>=0.7.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# parq-cli
+
+[![Python Version](https://img.shields.io/badge/python-3.9%2B-blue.svg)](https://www.python.org/downloads/)
+[![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+
+一个强大的 Apache Parquet 文件命令行工具 🚀
+
+## ✨ 特性
+
+- 📊 **元数据查看**: 快速查看 Parquet 文件的元数据信息
+- 📋 **Schema 展示**: 美观地展示文件的列结构和数据类型
+- 👀 **数据预览**: 支持查看文件的前 N 行或后 N 行
+- 🔢 **行数统计**: 快速获取文件的总行数
+- 🎨 **美观输出**: 使用 Rich 库提供彩色、格式化的终端输出
+
+## 📦 安装
+
+### 从源码安装
+
+```bash
+git clone https://github.com/yourusername/parq-cli.git
+cd parq-cli
+pip install -e .
+```
+
+### 使用 pip 安装（即将支持）
+
+```bash
+pip install parq-cli
+```
+
+## 🚀 快速开始
+
+### 基本用法
+
+```bash
+# 查看文件元数据
+parq data.parquet
+
+# 显示 schema 信息
+parq data.parquet --schema
+
+# 显示前 10 行
+parq data.parquet --head 10
+
+# 显示后 5 行
+parq data.parquet --tail 5
+
+# 显示总行数
+parq data.parquet --count
+```
+
+### 组合使用
+
+```bash
+# 同时显示 schema 和行数
+parq data.parquet --schema --count
+
+# 显示前 5 行和 schema
+parq data.parquet --head 5 --schema
+```
+
+## 📖 命令参考
+
+### 主命令
+
+```
+parq [OPTIONS] FILE
+```
+
+**参数:**
+- `FILE`: Parquet 文件路径（必需）
+
+**选项:**
+- `--schema, -s`: 显示 schema 信息
+- `--head N`: 显示前 N 行
+- `--tail N`: 显示后 N 行
+- `--count, -c`: 显示总行数
+- `--help`: 显示帮助信息
+
+### 版本信息
+
+```bash
+parq version
+```
+
+## 🎨 输出示例
+
+### 元数据展示
+
+```
+╭─────────────────────── 📊 Parquet File Metadata ───────────────────────╮
+│ file_path: /path/to/data.parquet                                       │
+│ num_rows: 1000                                                         │
+│ num_columns: 5                                                         │
+│ num_row_groups: 1                                                      │
+│ format_version: 2.6                                                    │
+│ serialized_size: 2048                                                  │
+│ created_by: parquet-cpp-arrow version 18.0.0                          │
+╰────────────────────────────────────────────────────────────────────────╯
+```
+
+### Schema 展示
+
+```
+                    📋 Schema Information
+┏━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┳━━━━━━━━━━┓
+┃ Column Name ┃ Data Type     ┃ Nullable ┃
+┡━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━╇━━━━━━━━━━┩
+│ id          │ int64         │ ✗        │
+│ name        │ string        │ ✓        │
+│ age         │ int64         │ ✓        │
+│ city        │ string        │ ✓        │
+│ salary      │ double        │ ✓        │
+└─────────────┴───────────────┴──────────┘
+```
+
+## 🛠️ 技术栈
+
+- **[PyArrow](https://arrow.apache.org/docs/python/)**: 高性能的 Parquet 读取引擎
+- **[Typer](https://typer.tiangolo.com/)**: 现代化的 CLI 框架
+- **[Rich](https://rich.readthedocs.io/)**: 美观的终端输出
+
+## 🧪 开发
+
+### 安装开发依赖
+
+```bash
+pip install -e ".[dev]"
+```
+
+### 运行测试
+
+```bash
+pytest
+```
+
+### 运行测试（带覆盖率）
+
+```bash
+pytest --cov=parq --cov-report=html
+```
+
+### 代码格式化
+
+```bash
+# 使用 Black
+black parq tests
+
+# 使用 Ruff 检查
+ruff check parq tests
+```
+
+## 🗺️ 路线图
+
+- [x] 基础元数据查看
+- [x] Schema 展示
+- [x] 数据预览（head/tail）
+- [x] 行数统计
+- [ ] SQL 查询支持
+- [ ] 数据统计分析
+- [ ] 格式转换（CSV, JSON, Excel）
+- [ ] 文件对比
+- [ ] 云存储支持（S3, GCS, Azure）
+
+## 🤝 贡献
+
+欢迎提交 Issue 和 Pull Request！
+
+1. Fork 本仓库
+2. 创建特性分支 (`git checkout -b feature/AmazingFeature`)
+3. 提交更改 (`git commit -m 'Add some AmazingFeature'`)
+4. 推送到分支 (`git push origin feature/AmazingFeature`)
+5. 开启 Pull Request
+
+## 📄 许可证
+
+本项目采用 MIT 许可证 - 详见 [LICENSE](LICENSE) 文件
+
+## 🙏 致谢
+
+- 灵感来源于 [parquet-cli](https://github.com/chhantyal/parquet-cli)
+- 感谢 Apache Arrow 团队提供强大的 Parquet 支持
+- 感谢 Rich 库为终端输出增添色彩
+
+## 📮 联系方式
+
+- 作者: Jinfeng Sun
+- 项目地址: https://github.com/Tendo33/parq-cli
+
+---
+
+**⭐ 如果这个项目对你有帮助，请给个 Star！**

parq_cli-0.0.1.dist-info/RECORD

@@ -0,0 +1,10 @@
+parq/__init__.py,sha256=gwi-2yJ5Vi64or1d2PUmaNh5kqK3_Zk0NqNTR5Ehyos,286
+parq/__main__.py,sha256=WGh0rg8ZQI3jEKQDY07_v9B4ZHhvfyF0bLQi-oQnpxY,338
+parq/cli.py,sha256=cNeWoO1vuDGhIQxFjB6EyWtVZngZKa8uxKSXIUw-j5w,3694
+parq/output.py,sha256=irl0ckCBWy15hJqy4QxGBLrRAdIWT-6AxFxjAoJac24,5415
+parq/reader.py,sha256=7S0D4RVDz0ElB5XugbfI4AIAI--MFsg8JqEUb4zkJVI,4859
+parq_cli-0.0.1.dist-info/METADATA,sha256=wBWuZf6ft07TfOTlp5aFwJcMeWGYCbLpzKQtXzZ9qug,6315
+parq_cli-0.0.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+parq_cli-0.0.1.dist-info/entry_points.txt,sha256=reTENlFOrUkuoCs5VGNvxD1FWvnpyIL4CP2GucIY0Hw,38
+parq_cli-0.0.1.dist-info/licenses/LICENSE,sha256=RCmRAGCROPvNK8H6jyCxN2CH3ka_-lb2_m8LpwjJl3w,1068
+parq_cli-0.0.1.dist-info/RECORD,,

parq_cli-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

parq_cli-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+parq = parq.cli:app

parq_cli-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Jinfeng Sun
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.