fairspec-terminal 0.0.0.dev0__tar.gz

fairspec_terminal-0.0.0.dev0/.gitignore

@@ -0,0 +1,229 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#   Usually these files are written by a python script from a template
+#   before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+# Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+# uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+# poetry.lock
+# poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+# pdm.lock
+# pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+# pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# Redis
+*.rdb
+*.aof
+*.pid
+
+# RabbitMQ
+mnesia/
+rabbitmq/
+rabbitmq-data/
+
+# ActiveMQ
+activemq-data/
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#   JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#   be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#   and can be added to the global gitignore or merged into this file.  For a more nuclear
+#   option (not recommended) you can uncomment the following to ignore the entire idea folder.
+# .idea/
+
+# Abstra
+#   Abstra is an AI-powered process automation framework.
+#   Ignore directories containing user credentials, local state, and settings.
+#   Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#   Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore
+#   that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#   and can be added to the global gitignore or merged into this file. However, if you prefer,
+#   you could uncomment the following to ignore the entire vscode folder
+# .vscode/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/
+
+# Streamlit
+.streamlit/secrets.toml
+
+# Node
+node_modules/
+jspm_packages/
+.lock-wscript
+build/Release
+.node_repl_history
+*.tgz
+.npm
+*.so
+
+# User
+/.claude/settings.local.json

fairspec_terminal-0.0.0.dev0/PKG-INFO

@@ -0,0 +1,20 @@
+Metadata-Version: 2.4
+Name: fairspec-terminal
+Version: 0.0.0.dev0
+Summary: Fairspec Python is a fast data management framework built on top of the Fairspec standard and Polars DataFrames
+Project-URL: homepage, https://github.com/fairspec/fairspec-python
+Project-URL: repository, https://github.com/fairspec/fairspec-python
+Author: Evgeny Karev
+License-Expression: MIT
+Keywords: arrow,csv,data,dataframe,fair,fairspec,inline,json,jsonschema,ods,parquet,polars,quality,table,tableschema,typescript,validation,xlsx
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.12
+Requires-Dist: fairspec-library
+Requires-Dist: typer>=0.15
+Description-Content-Type: text/markdown
+
+# fairspec-terminal
+
+Fairspec Python is a fast data management framework built on top of the Fairspec standard and Polars DataFrames. It supports various formats like CSV, JSON, and Parquet and integrates with data platforms such as CKAN, Zenodo, and GitHub. For more information, please read the [project's documentation](https://python.fairspec.org).

fairspec_terminal-0.0.0.dev0/README.md

@@ -0,0 +1,3 @@
+# fairspec-terminal
+
+Fairspec Python is a fast data management framework built on top of the Fairspec standard and Polars DataFrames. It supports various formats like CSV, JSON, and Parquet and integrates with data platforms such as CKAN, Zenodo, and GitHub. For more information, please read the [project's documentation](https://python.fairspec.org).

fairspec_terminal-0.0.0.dev0/fairspec_terminal/actions/error/render.py

@@ -0,0 +1,191 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from fairspec_metadata import FairspecError
+
+
+def render_error(error: FairspecError) -> str:
+    match error.type:
+        case "cell/type":
+            return _render_cell_type_error(error)
+        case "cell/missing":
+            return _render_cell_missing_error(error)
+        case "cell/minimum":
+            return _render_cell_minimum_error(error)
+        case "cell/maximum":
+            return _render_cell_maximum_error(error)
+        case "cell/exclusiveMinimum":
+            return _render_cell_exclusive_minimum_error(error)
+        case "cell/exclusiveMaximum":
+            return _render_cell_exclusive_maximum_error(error)
+        case "cell/multipleOf":
+            return _render_cell_multiple_of_error(error)
+        case "cell/minLength":
+            return _render_cell_min_length_error(error)
+        case "cell/maxLength":
+            return _render_cell_max_length_error(error)
+        case "cell/pattern":
+            return _render_cell_pattern_error(error)
+        case "cell/unique":
+            return _render_cell_unique_error(error)
+        case "cell/const":
+            return _render_cell_const_error(error)
+        case "cell/enum":
+            return _render_cell_enum_error(error)
+        case "cell/json":
+            return _render_cell_json_error(error)
+        case "cell/minItems":
+            return _render_cell_min_items_error(error)
+        case "cell/maxItems":
+            return _render_cell_max_items_error(error)
+        case "column/missing":
+            return _render_column_missing_error(error)
+        case "column/type":
+            return _render_column_type_error(error)
+        case "data":
+            return _render_data_error(error)
+        case "file/textual":
+            return _render_textual_error(error)
+        case "file/integrity":
+            return _render_integrity_error(error)
+        case "foreignKey":
+            return _render_foreign_key_error(error)
+        case "metadata":
+            return _render_metadata_error(error)
+        case "row/primaryKey":
+            return _render_row_primary_key_error(error)
+        case "row/uniqueKey":
+            return _render_row_unique_key_error(error)
+        case "resource/missing":
+            return _render_resource_missing_error(error)
+        case "resource/type":
+            return _render_resource_type_error(error)
+        case _:
+            return str(error)
+
+
+def _b(value: object) -> str:
+    return f"[bold]{value}[/bold]"
+
+
+def _in_resource(resource_name: str | None) -> str:
+    return f" in resource {_b(resource_name)}" if resource_name else ""
+
+
+def _render_cell_type_error(error: object) -> str:
+    return f"Value of the cell {_b(error.cell)} in column {_b(error.columnName)} of row {_b(error.rowNumber)} is not {_b(error.columnType)}{_in_resource(error.resourceName)}"  # type: ignore[union-attr]
+
+
+def _render_cell_missing_error(error: object) -> str:
+    return f"A cell in column {_b(error.columnName)} of row {_b(error.rowNumber)} is missing{_in_resource(error.resourceName)}"  # type: ignore[union-attr]
+
+
+def _render_cell_minimum_error(error: object) -> str:
+    return f"Value of the cell {_b(error.cell)} in column {_b(error.columnName)} of row {_b(error.rowNumber)} is less than {_b(error.minimum)}{_in_resource(error.resourceName)}"  # type: ignore[union-attr]
+
+
+def _render_cell_maximum_error(error: object) -> str:
+    return f"Value of the cell {_b(error.cell)} in column {_b(error.columnName)} of row {_b(error.rowNumber)} is more than {_b(error.maximum)}{_in_resource(error.resourceName)}"  # type: ignore[union-attr]
+
+
+def _render_cell_exclusive_minimum_error(error: object) -> str:
+    return f"Value of the cell {_b(error.cell)} in column {_b(error.columnName)} of row {_b(error.rowNumber)} is less or equal to {_b(error.minimum)}{_in_resource(error.resourceName)}"  # type: ignore[union-attr]
+
+
+def _render_cell_exclusive_maximum_error(error: object) -> str:
+    return f"Value of the cell {_b(error.cell)} in column {_b(error.columnName)} of row {_b(error.rowNumber)} is greater or equal to {_b(error.maximum)}{_in_resource(error.resourceName)}"  # type: ignore[union-attr]
+
+
+def _render_cell_multiple_of_error(error: object) -> str:
+    return f"Value of the cell {_b(error.cell)} in column {_b(error.columnName)} of row {_b(error.rowNumber)} is not a multiple of {_b(error.multipleOf)}{_in_resource(error.resourceName)}"  # type: ignore[union-attr]
+
+
+def _render_cell_min_length_error(error: object) -> str:
+    return f"Length of the cell {_b(error.cell)} in column {_b(error.columnName)} of row {_b(error.rowNumber)} is less than {_b(error.minLength)}{_in_resource(error.resourceName)}"  # type: ignore[union-attr]
+
+
+def _render_cell_max_length_error(error: object) -> str:
+    return f"Length of the cell {_b(error.cell)} in column {_b(error.columnName)} of row {_b(error.rowNumber)} is more than {_b(error.maxLength)}{_in_resource(error.resourceName)}"  # type: ignore[union-attr]
+
+
+def _render_cell_pattern_error(error: object) -> str:
+    return f"Value of the cell {_b(error.cell)} in column {_b(error.columnName)} of row {_b(error.rowNumber)} does not match the {_b(error.pattern)}{_in_resource(error.resourceName)}"  # type: ignore[union-attr]
+
+
+def _render_cell_unique_error(error: object) -> str:
+    return f"Value of the cell {_b(error.cell)} in column {_b(error.columnName)} of row {_b(error.rowNumber)} is not unique{_in_resource(error.resourceName)}"  # type: ignore[union-attr]
+
+
+def _render_cell_const_error(error: object) -> str:
+    const_val = getattr(error, "const", None)
+    return f"Value of the cell {_b(error.cell)} in column {_b(error.columnName)} of row {_b(error.rowNumber)} is not allowed value {_b(const_val)}{_in_resource(error.resourceName)}"  # type: ignore[union-attr]
+
+
+def _render_cell_enum_error(error: object) -> str:
+    enum_values = ", ".join(_b(v) for v in error.enum)  # type: ignore[union-attr]
+    return f"Value of the cell {_b(error.cell)} in column {_b(error.columnName)} of row {_b(error.rowNumber)} is not in the allowed values {enum_values}{_in_resource(error.resourceName)}"  # type: ignore[union-attr]
+
+
+def _render_cell_json_error(error: object) -> str:
+    return f"Value of the cell {_b(error.cell)} in column {_b(error.columnName)} of row {_b(error.rowNumber)} violates JSON schema at {_b(error.jsonPointer)}: {error.message}{_in_resource(error.resourceName)}"  # type: ignore[union-attr]
+
+
+def _render_cell_min_items_error(error: object) -> str:
+    return f"Value of the cell {_b(error.cell)} in column {_b(error.columnName)} of row {_b(error.rowNumber)} has less than {_b(error.minItems)} items{_in_resource(error.resourceName)}"  # type: ignore[union-attr]
+
+
+def _render_cell_max_items_error(error: object) -> str:
+    return f"Value of the cell {_b(error.cell)} in column {_b(error.columnName)} of row {_b(error.rowNumber)} has more than {_b(error.maxItems)} items{_in_resource(error.resourceName)}"  # type: ignore[union-attr]
+
+
+def _render_column_missing_error(error: object) -> str:
+    return f"Required column {_b(error.columnName)} is missing{_in_resource(error.resourceName)}"  # type: ignore[union-attr]
+
+
+def _render_column_type_error(error: object) -> str:
+    return f"Column {_b(error.columnName)} is expected to be {_b(error.expectedColumnType)}, but it is {_b(error.actualColumnType)}{_in_resource(error.resourceName)}"  # type: ignore[union-attr]
+
+
+def _render_data_error(error: object) -> str:
+    return f"Data error at {_b(error.jsonPointer)}: {error.message}{_in_resource(error.resourceName)}"  # type: ignore[union-attr]
+
+
+def _render_textual_error(error: object) -> str:
+    actual_encoding = getattr(error, "actualEncoding", None)
+    encoding_text = _b(actual_encoding) if actual_encoding else "binary"
+    return f"File is expected to be textual with utf-8 encoding but it is {encoding_text}{_in_resource(error.resourceName)}"  # type: ignore[union-attr]
+
+
+def _render_integrity_error(error: object) -> str:
+    return f"File hash {_b(error.hashType)} is expected to be {_b(error.expectedHash)}, but it is {_b(error.actualHash)}){_in_resource(error.resourceName)}"  # type: ignore[union-attr]
+
+
+def _render_foreign_key_error(error: object) -> str:
+    cells = ", ".join(_b(c) for c in error.cells)  # type: ignore[union-attr]
+    return f"Foreign key constraint violated as cells {cells} do not reference existing values{_in_resource(error.resourceName)}"  # type: ignore[union-attr]
+
+
+def _render_metadata_error(error: object) -> str:
+    return f"{error.message} at {_b(error.jsonPointer)}{_in_resource(error.resourceName)}"  # type: ignore[union-attr]
+
+
+def _render_row_primary_key_error(error: object) -> str:
+    column_names = ", ".join(_b(c) for c in error.columnNames)  # type: ignore[union-attr]
+    return f"Row {_b(error.rowNumber)} violates primary key constraint on columns {column_names}{_in_resource(error.resourceName)}"  # type: ignore[union-attr]
+
+
+def _render_row_unique_key_error(error: object) -> str:
+    column_names = ", ".join(_b(c) for c in error.columnNames)  # type: ignore[union-attr]
+    return f"Row {_b(error.rowNumber)} violates unique key constraint on columns {column_names}{_in_resource(error.resourceName)}"  # type: ignore[union-attr]
+
+
+def _render_resource_missing_error(error: object) -> str:
+    in_ref = _in_resource(getattr(error, "referencingResourceName", None))
+    return f"Resource {_b(error.resourceName)} is missing, but expected{in_ref}"  # type: ignore[union-attr]
+
+
+def _render_resource_type_error(error: object) -> str:
+    in_ref = _in_resource(getattr(error, "referencingResourceName", None))
+    return f"Resource {_b(error.resourceName)} is expected to be {_b(error.expectedResourceType)}{in_ref}"  # type: ignore[union-attr]

fairspec_terminal-0.0.0.dev0/fairspec_terminal/commands/data/infer_schema.py

@@ -0,0 +1,27 @@
+from fairspec_library import infer_data_schema
+from fairspec_metadata import Resource
+
+from fairspec_terminal.params import Debug, Json, RequiredFilePath, Silent
+from fairspec_terminal.program import data_program
+from fairspec_terminal.session import Session
+
+
+@data_program.command(name="infer-schema")
+def infer_schema(
+    path: RequiredFilePath,
+    silent: Silent = False,
+    debug: Debug = False,
+    json: Json = False,
+) -> None:
+    """Infer a Data Schema."""
+    session = Session(silent=silent, debug=debug, json=json)
+
+    def _infer() -> object:
+        data_schema = infer_data_schema(Resource(data=path))
+        if not data_schema:
+            raise ValueError("Could not infer data schema")
+        return data_schema
+
+    data_schema = session.task("Inferring data schema", _infer)
+
+    session.render_data_result(data_schema)

fairspec_terminal-0.0.0.dev0/fairspec_terminal/commands/data/validate.py

@@ -0,0 +1,32 @@
+from fairspec_library import validate_data
+from fairspec_metadata import Report, load_data_schema
+
+from fairspec_terminal.params import DataSchemaPath, Debug, Json, RequiredFilePath, Silent
+from fairspec_terminal.program import data_program
+from fairspec_terminal.session import Session
+
+
+@data_program.command()
+def validate(
+    path: RequiredFilePath,
+    schema: DataSchemaPath,
+    silent: Silent = False,
+    debug: Debug = False,
+    json: Json = False,
+) -> None:
+    """Validate a JSON Data from a local or remote path."""
+    session = Session(silent=silent, debug=debug, json=json)
+
+    def _load_schema() -> object:
+        if not schema:
+            raise ValueError("No data schema provided")
+        return load_data_schema(schema)
+
+    data_schema = session.task("Loading data schema", _load_schema)
+
+    def _validate() -> Report:
+        return validate_data({"data": path, "dataSchema": data_schema})  # type: ignore[arg-type]
+
+    report = session.task("Validating data", _validate)
+
+    session.render_report_result(report)

fairspec_terminal-0.0.0.dev0/fairspec_terminal/commands/data/validate_schema.py

@@ -0,0 +1,24 @@
+from fairspec_metadata import validate_data_schema
+
+from fairspec_terminal.params import Debug, Json, RequiredFilePath, Silent
+from fairspec_terminal.program import data_program
+from fairspec_terminal.session import Session
+
+
+@data_program.command(name="validate-schema")
+def validate_schema(
+    path: RequiredFilePath,
+    silent: Silent = False,
+    debug: Debug = False,
+    json: Json = False,
+) -> None:
+    """Validate a Data Schema."""
+    session = Session(silent=silent, debug=debug, json=json)
+
+    def _validate() -> object:
+        result = validate_data_schema(path)
+        return result
+
+    report = session.task("Validating data schema", _validate)
+
+    session.render_report_result(report)  # type: ignore[arg-type]

fairspec_terminal-0.0.0.dev0/fairspec_terminal/commands/dataset/copy.py

@@ -0,0 +1,28 @@
+from fairspec_library import load_dataset, save_dataset
+
+from fairspec_terminal.params import Debug, Json, RequiredPath, Silent, ToPathRequired
+from fairspec_terminal.program import dataset_program
+from fairspec_terminal.session import Session
+
+
+@dataset_program.command()
+def copy(
+    path: RequiredPath,
+    to_path: ToPathRequired,
+    silent: Silent = False,
+    debug: Debug = False,
+    json: Json = False,
+) -> None:
+    """Copy a local or remote dataset to a local folder."""
+    session = Session(silent=silent, debug=debug, json=json)
+
+    def _copy() -> None:
+        dataset = load_dataset(path)
+        save_dataset(dataset, target=to_path)  # type: ignore[arg-type]
+
+    session.task("Copy dataset", _copy)
+
+    session.render_text_result(
+        f"Copied dataset from [bold]{path}[/bold] to [bold]{to_path}[/bold]",
+        status="success",
+    )

fairspec_terminal-0.0.0.dev0/fairspec_terminal/commands/dataset/infer.py

@@ -0,0 +1,62 @@
+from fairspec_library import infer_dataset
+from fairspec_metadata import Dataset
+
+from fairspec_terminal.params import (
+    ArrayType,
+    ColumnTypes,
+    CommaDecimal,
+    Confidence,
+    DateFormat,
+    DatetimeFormat,
+    Debug,
+    DecimalChar,
+    FalseValues,
+    GroupChar,
+    Json,
+    KeepStrings,
+    ListDelimiter,
+    ListItemType,
+    MissingValues,
+    MonthFirst,
+    SampleRows,
+    TimeFormat,
+    TrueValues,
+    VariadicPaths,
+)
+from fairspec_terminal.program import dataset_program
+from fairspec_terminal.session import Session
+
+
+@dataset_program.command()
+def infer(
+    paths: VariadicPaths,
+    json: Json = False,
+    debug: Debug = False,
+    sample_rows: SampleRows = None,
+    confidence: Confidence = None,
+    comma_decimal: CommaDecimal = False,
+    month_first: MonthFirst = False,
+    keep_strings: KeepStrings = False,
+    column_types: ColumnTypes = None,
+    missing_values: MissingValues = None,
+    decimal_char: DecimalChar = None,
+    group_char: GroupChar = None,
+    true_values: TrueValues = None,
+    false_values: FalseValues = None,
+    datetime_format: DatetimeFormat = None,
+    date_format: DateFormat = None,
+    time_format: TimeFormat = None,
+    array_type: ArrayType = None,
+    list_delimiter: ListDelimiter = None,
+    list_item_type: ListItemType = None,
+) -> None:
+    """Infer a dataset from local or remote file paths."""
+    session = Session(debug=debug, json=json)
+
+    def _infer() -> Dataset:
+        dataset = Dataset(resources=[{"data": data} for data in paths])  # type: ignore[list-item]
+        return infer_dataset(dataset)
+
+    dataset = session.task("Inferring dataset", _infer)
+
+    session.render_data_result(dataset.model_dump(exclude_none=True))

fairspec_terminal-0.0.0.dev0/fairspec_terminal/commands/dataset/list_.py

@@ -0,0 +1,31 @@
+from fairspec_library import load_dataset
+from fairspec_metadata import infer_resource_name
+
+from fairspec_terminal.params import Debug, Json, RequiredPath
+from fairspec_terminal.program import dataset_program
+from fairspec_terminal.session import Session
+
+
+@dataset_program.command(name="list")
+def list_(
+    path: RequiredPath,
+    json: Json = False,
+    debug: Debug = False,
+) -> None:
+    """List Dataset resources."""
+    session = Session(debug=debug, json=json)
+
+    def _load() -> object:
+        dataset = load_dataset(path)
+        if not dataset:
+            raise ValueError("Could not load dataset")
+        return dataset
+
+    dataset = session.task("Loading dataset", _load)
+
+    resource_names = [
+        resource.name or infer_resource_name(resource)
+        for resource in getattr(dataset, "resources", None) or []
+    ]
+
+    session.render_data_result(resource_names)