smartclean-df 0.1.0__tar.gz

smartclean_df-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Pranay Mahendrakar
+
+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.

smartclean_df-0.1.0/PKG-INFO

@@ -0,0 +1,151 @@
+Metadata-Version: 2.5
+Name: smartclean-df
+Version: 0.1.0
+Summary: Automatically detects and fixes missing values, duplicates, outliers, inconsistent formats and dirty columns in tabular data
+Project-URL: Homepage, https://pypi.org/project/smartclean-df/
+Project-URL: Author, https://pypi.org/user/pranaymahendrakar/
+Author: Pranay Mahendrakar
+License-Expression: MIT
+License-File: LICENSE
+Keywords: data-cleaning,dataframe,duplicates,etl,missing-values,outliers,pandas,preprocessing
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Requires-Dist: numpy>=1.23
+Requires-Dist: pandas>=1.5
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == 'dev'
+Provides-Extra: parquet
+Requires-Dist: pyarrow>=12; extra == 'parquet'
+Description-Content-Type: text/markdown
+
+# smartclean-df
+
+Turns a messy table into a tidy one in one call: it finds and fixes missing
+values, duplicate rows, outliers, numbers/dates/booleans stored as text, and
+dirty column names, and tells you exactly what it changed.
+
+## Install
+
+```
+pip install smartclean-df
+```
+
+Parquet input needs the optional extra: `pip install "smartclean-df[parquet]"`.
+
+## Quickstart
+
+```python
+import pandas as pd
+from smartclean_df import clean
+df = pd.DataFrame({"Name ": ["Ann", " Bob", "Ann", None], "Age": ["34", "NA", "34", "41"], "Joined": ["2024-01-05", "2024-02-10", "2024-01-05", "-"]})
+result = clean(df)
+print(result.summary())
+print(result.df)
+```
+
+`result.df` is the cleaned copy (the input is never modified), `result.actions`
+lists every change in the order it was made, and `result.summary()` prints it
+as text. `df, actions = clean(df)` also works.
+
+## What it does
+
+Every step runs in this order and every change is logged as an `Action`:
+
+1. **Column names** are stripped, inner whitespace collapsed to `_`, and
+   lowercased (`"Order ID "` becomes `order_id`); clashes get a `_2` suffix.
+2. **String cells** are stripped of surrounding whitespace, and missing tokens
+   (`""`, `NA`, `N/A`, `null`, `None`, `-`, `?`, `nan`, any case) become `NaN`.
+3. **Numbers stored as text** are parsed when at least 90% of the non-missing
+   values parse: `"1,234"`, `"$12.50"`, `"(300)"`, `"45%"` (the `%` is
+   stripped, the value is kept as written: `45.0`), `"  7 "`. Whole-number
+   columns become `int64`. Codes with leading zeros (`"00123"`) are left alone.
+   Columns that mix numbers and text stay `object`.
+4. **Dates stored as text** are parsed when at least 90% parse. Day-first
+   versus month-first is inferred from the data, and no pandas warnings leak.
+5. **Booleans stored as text** (`yes/no`, `true/false`, `y/n`, `t/f`, `1/0`
+   strings) become `bool`. Numeric columns are never touched by this step.
+6. **Exact duplicate rows** are dropped, then rows and columns that are
+   entirely empty.
+7. **Missing values** are imputed: median for numeric columns, mode for
+   categorical/boolean columns, forward-fill for datetimes. Integer columns
+   stay integer when the median is a whole number. `missing="drop"` drops any
+   row with a missing value instead; `missing="none"` leaves them.
+8. **Outliers** in numeric columns are found with the IQR rule
+   (`Q1 - k*IQR`, `Q3 + k*IQR`, `k = iqr_factor`, default 3.0). `"clip"`
+   winsorizes them to the bounds, `"flag"` only reports them, `"drop"` removes
+   the rows, `"none"` skips the step. Columns with zero IQR (constants,
+   0/1 indicators) are never clipped.
+
+If the input has a default `RangeIndex` and rows were dropped, the result is
+re-indexed from 0; any other index is kept so rows stay traceable.
+
+## API
+
+```python
+clean(df_or_path, *, missing="auto", outliers="clip", iqr_factor=3.0, duplicates=True,
+      normalize_columns=True, parse_numbers=True, parse_dates=True, parse_booleans=True,
+      dry_run=False) -> CleanResult
+```
+
+`df_or_path` is a `pandas.DataFrame` or a path to a `.csv`, `.tsv` or
+`.parquet` file. `missing` is `"auto"`, `"drop"` or `"none"`; `outliers` is
+`"clip"`, `"flag"`, `"drop"` or `"none"`. With `dry_run=True` the actions are
+computed and reported but `result.df` is an unchanged copy of the input.
+
+`CleanResult`
+
+- `.df` - the cleaned `DataFrame` (unchanged copy when `dry_run=True`)
+- `.actions` - `list[Action]`, every change made, in order
+- `.input_shape`, `.output_shape` - `(rows, columns)` before and after
+- `.summary()` - human-readable text
+- `.to_dict()` - JSON-safe dict (`shapes`, `actions`, output `dtypes`)
+
+`Action(column, kind, detail, rows_affected)` - `column` is `None` for
+table-wide actions (dropping duplicate rows, dropping rows with missing
+values). `kind` is one of `rename_column`, `strip_whitespace`,
+`missing_tokens`, `parse_numeric`, `parse_datetime`, `parse_boolean`,
+`drop_duplicates`, `drop_empty_rows`, `drop_empty_column`, `impute`,
+`drop_missing_rows`, `clip_outliers`, `flag_outliers`, `drop_outliers`.
+
+```python
+Cleaner(**same options as clean, except dry_run)
+Cleaner.fit(df_or_path) -> Cleaner
+Cleaner.transform(df_or_path, *, dry_run=False) -> CleanResult
+Cleaner.fit_transform(df_or_path, *, dry_run=False) -> CleanResult
+```
+
+`fit` learns which columns to parse (and how), the imputation value of every
+column, the outlier bounds, and which all-empty columns to drop. `transform`
+applies exactly that to new data, so production batches get the same
+treatment as the data you fitted on: learned medians and modes fill new gaps,
+learned bounds clip new outliers, and a column that was parsed as a date is
+parsed as a date again even if the batch is too small to pass the 90% rule.
+Columns not seen during `fit` only get the stateless whitespace / missing
+token cleanup.
+
+The library never prints; it logs through `logging.getLogger("smartclean_df")`.
+
+## CLI
+
+```
+smartclean-df data.csv                    # print the summary of what would change
+smartclean-df data.csv --json             # print to_dict() as JSON
+smartclean-df data.csv --output clean.csv # also write the cleaned table (.csv, .tsv, .parquet)
+smartclean-df data.csv --missing drop --outliers flag --iqr-factor 1.5
+smartclean-df data.csv --dry-run          # report only, never write changed data
+smartclean-df --help
+```
+
+Flags mirror the Python options: `--missing`, `--outliers`, `--iqr-factor`,
+`--keep-duplicates`, `--keep-column-names`, `--no-parse-numbers`,
+`--no-parse-dates`, `--no-parse-booleans`, `--dry-run`.
+
+## License
+
+MIT

smartclean_df-0.1.0/README.md

@@ -0,0 +1,125 @@
+# smartclean-df
+
+Turns a messy table into a tidy one in one call: it finds and fixes missing
+values, duplicate rows, outliers, numbers/dates/booleans stored as text, and
+dirty column names, and tells you exactly what it changed.
+
+## Install
+
+```
+pip install smartclean-df
+```
+
+Parquet input needs the optional extra: `pip install "smartclean-df[parquet]"`.
+
+## Quickstart
+
+```python
+import pandas as pd
+from smartclean_df import clean
+df = pd.DataFrame({"Name ": ["Ann", " Bob", "Ann", None], "Age": ["34", "NA", "34", "41"], "Joined": ["2024-01-05", "2024-02-10", "2024-01-05", "-"]})
+result = clean(df)
+print(result.summary())
+print(result.df)
+```
+
+`result.df` is the cleaned copy (the input is never modified), `result.actions`
+lists every change in the order it was made, and `result.summary()` prints it
+as text. `df, actions = clean(df)` also works.
+
+## What it does
+
+Every step runs in this order and every change is logged as an `Action`:
+
+1. **Column names** are stripped, inner whitespace collapsed to `_`, and
+   lowercased (`"Order ID "` becomes `order_id`); clashes get a `_2` suffix.
+2. **String cells** are stripped of surrounding whitespace, and missing tokens
+   (`""`, `NA`, `N/A`, `null`, `None`, `-`, `?`, `nan`, any case) become `NaN`.
+3. **Numbers stored as text** are parsed when at least 90% of the non-missing
+   values parse: `"1,234"`, `"$12.50"`, `"(300)"`, `"45%"` (the `%` is
+   stripped, the value is kept as written: `45.0`), `"  7 "`. Whole-number
+   columns become `int64`. Codes with leading zeros (`"00123"`) are left alone.
+   Columns that mix numbers and text stay `object`.
+4. **Dates stored as text** are parsed when at least 90% parse. Day-first
+   versus month-first is inferred from the data, and no pandas warnings leak.
+5. **Booleans stored as text** (`yes/no`, `true/false`, `y/n`, `t/f`, `1/0`
+   strings) become `bool`. Numeric columns are never touched by this step.
+6. **Exact duplicate rows** are dropped, then rows and columns that are
+   entirely empty.
+7. **Missing values** are imputed: median for numeric columns, mode for
+   categorical/boolean columns, forward-fill for datetimes. Integer columns
+   stay integer when the median is a whole number. `missing="drop"` drops any
+   row with a missing value instead; `missing="none"` leaves them.
+8. **Outliers** in numeric columns are found with the IQR rule
+   (`Q1 - k*IQR`, `Q3 + k*IQR`, `k = iqr_factor`, default 3.0). `"clip"`
+   winsorizes them to the bounds, `"flag"` only reports them, `"drop"` removes
+   the rows, `"none"` skips the step. Columns with zero IQR (constants,
+   0/1 indicators) are never clipped.
+
+If the input has a default `RangeIndex` and rows were dropped, the result is
+re-indexed from 0; any other index is kept so rows stay traceable.
+
+## API
+
+```python
+clean(df_or_path, *, missing="auto", outliers="clip", iqr_factor=3.0, duplicates=True,
+      normalize_columns=True, parse_numbers=True, parse_dates=True, parse_booleans=True,
+      dry_run=False) -> CleanResult
+```
+
+`df_or_path` is a `pandas.DataFrame` or a path to a `.csv`, `.tsv` or
+`.parquet` file. `missing` is `"auto"`, `"drop"` or `"none"`; `outliers` is
+`"clip"`, `"flag"`, `"drop"` or `"none"`. With `dry_run=True` the actions are
+computed and reported but `result.df` is an unchanged copy of the input.
+
+`CleanResult`
+
+- `.df` - the cleaned `DataFrame` (unchanged copy when `dry_run=True`)
+- `.actions` - `list[Action]`, every change made, in order
+- `.input_shape`, `.output_shape` - `(rows, columns)` before and after
+- `.summary()` - human-readable text
+- `.to_dict()` - JSON-safe dict (`shapes`, `actions`, output `dtypes`)
+
+`Action(column, kind, detail, rows_affected)` - `column` is `None` for
+table-wide actions (dropping duplicate rows, dropping rows with missing
+values). `kind` is one of `rename_column`, `strip_whitespace`,
+`missing_tokens`, `parse_numeric`, `parse_datetime`, `parse_boolean`,
+`drop_duplicates`, `drop_empty_rows`, `drop_empty_column`, `impute`,
+`drop_missing_rows`, `clip_outliers`, `flag_outliers`, `drop_outliers`.
+
+```python
+Cleaner(**same options as clean, except dry_run)
+Cleaner.fit(df_or_path) -> Cleaner
+Cleaner.transform(df_or_path, *, dry_run=False) -> CleanResult
+Cleaner.fit_transform(df_or_path, *, dry_run=False) -> CleanResult
+```
+
+`fit` learns which columns to parse (and how), the imputation value of every
+column, the outlier bounds, and which all-empty columns to drop. `transform`
+applies exactly that to new data, so production batches get the same
+treatment as the data you fitted on: learned medians and modes fill new gaps,
+learned bounds clip new outliers, and a column that was parsed as a date is
+parsed as a date again even if the batch is too small to pass the 90% rule.
+Columns not seen during `fit` only get the stateless whitespace / missing
+token cleanup.
+
+The library never prints; it logs through `logging.getLogger("smartclean_df")`.
+
+## CLI
+
+```
+smartclean-df data.csv                    # print the summary of what would change
+smartclean-df data.csv --json             # print to_dict() as JSON
+smartclean-df data.csv --output clean.csv # also write the cleaned table (.csv, .tsv, .parquet)
+smartclean-df data.csv --missing drop --outliers flag --iqr-factor 1.5
+smartclean-df data.csv --dry-run          # report only, never write changed data
+smartclean-df --help
+```
+
+Flags mirror the Python options: `--missing`, `--outliers`, `--iqr-factor`,
+`--keep-duplicates`, `--keep-column-names`, `--no-parse-numbers`,
+`--no-parse-dates`, `--no-parse-booleans`, `--dry-run`.
+
+## License
+
+MIT

smartclean_df-0.1.0/pyproject.toml

@@ -0,0 +1,59 @@
+[build-system]
+requires = ["hatchling>=1.27"]
+build-backend = "hatchling.build"
+
+[project]
+name = "smartclean-df"
+version = "0.1.0"
+description = "Automatically detects and fixes missing values, duplicates, outliers, inconsistent formats and dirty columns in tabular data"
+readme = "README.md"
+requires-python = ">=3.9"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Pranay Mahendrakar" }]
+keywords = [
+  "pandas",
+  "data-cleaning",
+  "missing-values",
+  "outliers",
+  "duplicates",
+  "dataframe",
+  "preprocessing",
+  "etl",
+]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: Developers",
+  "Intended Audience :: Science/Research",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "Operating System :: OS Independent",
+  "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+dependencies = [
+  "pandas>=1.5",
+  "numpy>=1.23",
+]
+
+[project.optional-dependencies]
+# heavy or niche deps go here, never in `dependencies`
+parquet = ["pyarrow>=12"]
+dev = ["pytest>=7"]
+
+[project.scripts]
+smartclean-df = "smartclean_df.cli:main"
+
+[project.urls]
+Homepage = "https://pypi.org/project/smartclean-df/"
+Author = "https://pypi.org/user/pranaymahendrakar/"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/smartclean_df"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+filterwarnings = [
+  "error::UserWarning",
+  "error::FutureWarning",
+  "error::RuntimeWarning",
+]

smartclean_df-0.1.0/src/smartclean_df/__init__.py

@@ -0,0 +1,6 @@
+"""smartclean-df: turn a messy table into a tidy one in one call, and say what changed."""
+from .core import FORWARD_FILL, Cleaner, clean
+from .result import Action, CleanResult
+
+__version__ = "0.1.0"
+__all__ = ["clean", "Cleaner", "CleanResult", "Action", "FORWARD_FILL", "__version__"]

smartclean_df-0.1.0/src/smartclean_df/_io.py

@@ -0,0 +1,90 @@
+"""Accept a DataFrame or a path to a tabular file."""
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Union
+
+import pandas as pd
+
+__all__ = ["load_frame", "write_frame", "FrameLike"]
+
+FrameLike = Union[pd.DataFrame, str, "os.PathLike[str]"]
+
+
+def _inference_is_lossless(text: pd.Series) -> bool:
+    """True when letting pandas type-infer this column of text changes nothing.
+
+    ``"123"`` becomes ``123`` and renders back as ``"123"``, so inferring it is
+    free. ``"00123"`` becomes ``123`` and renders back as ``"123"`` -- a
+    different identifier -- so that column must stay text and be handed to the
+    cleaning pipeline, which knows to leave zero-padded codes alone.
+    """
+    values = text.dropna()
+    if values.empty:
+        return True
+    try:
+        numbers = pd.to_numeric(values)
+    except (ValueError, TypeError, OverflowError):
+        # pandas will not turn this column into numbers either; nothing to lose
+        return True
+    try:
+        rendered = numbers.astype(str).to_numpy()
+    except (ValueError, TypeError):
+        return False
+    return bool((rendered == values.to_numpy()).all())
+
+
+def _read_text_table(path: Path, *, sep: str) -> pd.DataFrame:
+    """Read a delimited text file without letting pandas destroy any values.
+
+    Reading a file must never be a lossy, unlogged transformation. Columns
+    pandas can type-infer without changing a single value are inferred as
+    usual; every other column is read as text, so that the cleaning pipeline
+    decides what becomes a number, a date or a boolean -- and logs an Action
+    for it -- instead of pandas deciding silently at read time.
+    """
+    text = pd.read_csv(path, sep=sep, dtype=str, keep_default_na=True)
+    as_text = {col: str for col in text.columns if not _inference_is_lossless(text[col])}
+    if not as_text:
+        return pd.read_csv(path, sep=sep)
+    return pd.read_csv(path, sep=sep, dtype=as_text)
+
+
+def load_frame(df_or_path: FrameLike) -> pd.DataFrame:
+    """Return a deep copy of a DataFrame, or read a .csv/.tsv/.parquet file."""
+    if isinstance(df_or_path, pd.DataFrame):
+        return df_or_path.copy(deep=True)
+    if isinstance(df_or_path, (str, os.PathLike)):
+        path = Path(df_or_path)
+        suffix = path.suffix.lower()
+        if suffix in (".csv", ".txt"):
+            return _read_text_table(path, sep=",")
+        if suffix == ".tsv":
+            return _read_text_table(path, sep="\t")
+        if suffix in (".parquet", ".pq"):
+            return pd.read_parquet(path)
+        raise ValueError(
+            f"Unsupported file type {suffix!r} for {path}; expected .csv, .tsv or .parquet"
+        )
+    raise TypeError(
+        "expected a pandas DataFrame or a path to a .csv/.tsv/.parquet file, "
+        f"got {type(df_or_path).__name__}"
+    )
+
+
+def write_frame(df: pd.DataFrame, path: "Union[str, os.PathLike[str]]") -> Path:
+    """Write ``df`` to ``path`` by extension (.csv, .tsv or .parquet)."""
+    target = Path(path)
+    suffix = target.suffix.lower()
+    if suffix in (".csv", ".txt"):
+        df.to_csv(target, index=False)
+    elif suffix == ".tsv":
+        df.to_csv(target, index=False, sep="\t")
+    elif suffix in (".parquet", ".pq"):
+        df.to_parquet(target, index=False)
+    else:
+        raise ValueError(
+            f"Unsupported output type {suffix!r} for {target}; expected .csv, .tsv or .parquet"
+        )
+    return target

smartclean_df-0.1.0/src/smartclean_df/cli.py

@@ -0,0 +1,99 @@
+"""Command line entry point: ``smartclean-df data.csv --output clean.csv``."""
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from typing import List, Optional
+
+from . import __version__
+from ._io import write_frame
+from .core import MISSING_MODES, OUTLIER_MODES, clean
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="smartclean-df",
+        description=(
+            "Detect and fix missing values, duplicate rows, outliers, dirty column names and "
+            "numbers/dates/booleans stored as text in a table, and report every change."
+        ),
+    )
+    parser.add_argument("path", help="input table (.csv, .tsv or .parquet)")
+    parser.add_argument(
+        "--missing",
+        choices=MISSING_MODES,
+        default="auto",
+        help="auto: fill with median / mode / forward-fill; drop: drop rows with missing values; "
+        "none: leave them (default auto)",
+    )
+    parser.add_argument(
+        "--outliers",
+        choices=OUTLIER_MODES,
+        default="clip",
+        help="clip: winsorize to the IQR bounds; flag: only report; drop: drop the rows; "
+        "none: skip (default clip)",
+    )
+    parser.add_argument(
+        "--iqr-factor",
+        type=float,
+        default=3.0,
+        metavar="K",
+        help="outlier bounds are Q1 - K*IQR and Q3 + K*IQR (default 3.0)",
+    )
+    parser.add_argument("--keep-duplicates", action="store_true", help="do not drop exact duplicate rows")
+    parser.add_argument("--keep-column-names", action="store_true", help="do not normalize column names")
+    parser.add_argument("--no-parse-numbers", action="store_true", help="leave numbers stored as text alone")
+    parser.add_argument("--no-parse-dates", action="store_true", help="leave dates stored as text alone")
+    parser.add_argument("--no-parse-booleans", action="store_true", help="leave booleans stored as text alone")
+    parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="report what would change without changing anything (cannot be combined with --output)",
+    )
+    parser.add_argument("--json", action="store_true", help="print the result as JSON instead of the text summary")
+    parser.add_argument("--output", metavar="FILE", help="write the cleaned table here (.csv, .tsv or .parquet)")
+    parser.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
+    return parser
+
+
+def main(argv: Optional[List[str]] = None) -> int:
+    """Run the command line; returns the process exit status."""
+    for stream in (sys.stdout, sys.stderr):
+        if hasattr(stream, "reconfigure"):
+            stream.reconfigure(encoding="utf-8", errors="replace")
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    if args.dry_run and args.output:
+        parser.error("--dry-run cannot be combined with --output")
+    try:
+        result = clean(
+            args.path,
+            missing=args.missing,
+            outliers=args.outliers,
+            iqr_factor=args.iqr_factor,
+            duplicates=not args.keep_duplicates,
+            normalize_columns=not args.keep_column_names,
+            parse_numbers=not args.no_parse_numbers,
+            parse_dates=not args.no_parse_dates,
+            parse_booleans=not args.no_parse_booleans,
+            dry_run=args.dry_run,
+        )
+        written = write_frame(result.df, args.output) if args.output else None
+    except (ValueError, TypeError, ImportError, OSError) as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        return 2
+    if args.json:
+        payload = result.to_dict()
+        if written is not None:
+            payload["output"] = str(written)
+        print(json.dumps(payload, indent=2, ensure_ascii=False))
+    else:
+        print(result.summary())
+        if written is not None:
+            print(f"cleaned table written to {written}")
+    return 0
+
+
+if __name__ == "__main__":  # pragma: no cover
+    sys.exit(main())