clizard 0.1.0__py3-none-any.whl

clizard/examples/examples_auto_cli_release_tool.py

@@ -0,0 +1,31 @@
+"""How to turn your existing argparse main() into a clizard interface."""
+import argparse
+from clizard import auto_cli
+
+
+def run(username, package, clean=None, install=None, twine=None, verbose=None):
+    """Your existing function, unchanged."""
+    print(f"Releasing {package} as {username} (clean={clean}, twine={twine}, verbose={verbose})")
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("-u", "--username", type=str, help="Username on Github/Gitlab..")
+    parser.add_argument("-p", "--package", type=str, help="Package name to be released.")
+    parser.add_argument("-c", "--clean", type=int, choices=[0, 1], help="Remove local builds: [dist], [build] and [x.egg-info].")
+    parser.add_argument("-i", "--install", type=int, choices=[0, 1], help="Install this versions on local machine.")
+    parser.add_argument("-t", "--twine", type=str, help="Path to twine in case you have a custom build.")
+    parser.add_argument("-v", "--verbosity", type=int, choices=[0, 1, 2, 3, 4, 5], help="Verbosity, higher number tends to more information.")
+    args = parser.parse_args()
+
+    # Instead of calling run(...) directly, build a CLI around it:
+    def run_callback(cli):
+        s = cli.config.settings
+        run(s["username"], s["package"], clean=s["clean"], install=s["install"], twine=s["twine"], verbose=s["verbosity"])
+
+    cli = auto_cli(parser, args=args, app_name="ReleaseTool", run_callback=run_callback)
+    cli.run()
+
+
+if __name__ == "__main__":
+    main()

clizard/examples/examples_llmlight_app.py

@@ -0,0 +1,42 @@
+"""Example: how another script/project reuses clizard for its own tool."""
+from clizard import GenericCLI, parse_args
+
+EXTRA_ARGS = [
+    {"flags": ["--temperature"], "kwargs": {"type": float, "default": None, "help": "Sampling temperature"}},
+]
+
+
+def my_handler(prompt, cli):
+    # plug in real LLM call here
+    model = cli.config.get("model")
+    return f"[{model}] you said: **{prompt}**"
+
+
+def main():
+    args = parse_args(app_name="LLMlight", extra_args=EXTRA_ARGS)
+
+    cli = GenericCLI(
+        app_name=args.name or "LLMlight",
+        ascii_art=r"""
+   /\_/\
+  ( o.o )
+   > ^ <
+""",
+        settings={"model": "google/gemma-26B-a4B", "path": "C:/LLMlight", "temperature": 0.7},
+        config_path=args.config,
+        handler=my_handler,
+        tips=["/init", "/help", "generate documentation"],
+        updates=["Agent system improvements", "Documentation generation", "Local model support"],
+    )
+    cli.config.update_from_args({"model": args.model, "path": args.path, "temperature": args.temperature})
+
+    # custom command specific to this project
+    @cli.command("/init", "Initialize a new project")
+    def cmd_init(prompt):
+        cli.assistant_message(f"Initialized project at `{cli.config.get('path')}`")
+
+    cli.run()
+
+
+if __name__ == "__main__":
+    main()

clizard/examples/examples_summarizer.py

@@ -0,0 +1,16 @@
+"""Example existing script: summarizes a text file."""
+
+
+def main(input_path: str, max_words: int = 50, uppercase: bool = False) -> str:
+    """Pretend this does real work (e.g. summarization)."""
+    try:
+        with open(input_path, "r") as f:
+            text = f.read()
+    except FileNotFoundError:
+        return f"File not found: {input_path}"
+
+    words = text.split()[:max_words]
+    result = " ".join(words)
+    if uppercase:
+        result = result.upper()
+    return result

clizard/examples/examples_wrap_summarizer.py

@@ -0,0 +1,63 @@
+"""Example: expose summarizer.main(...) through a clizard interface.
+
+Run:
+    python wrap_summarizer.py --input-path notes.txt --max-words 20
+"""
+from clizard import GenericCLI, parse_args
+from summarizer import main as summarize
+
+# 1. Declare the script's own arguments as extra CLI flags.
+EXTRA_ARGS = [
+    {"flags": ["--input-path"], "kwargs": {"default": None, "help": "Path to input text file"}},
+    {"flags": ["--max-words"], "kwargs": {"type": int, "default": 50, "help": "Max words to keep"}},
+    {"flags": ["--uppercase"], "kwargs": {"action": "store_true", "help": "Uppercase the output"}},
+]
+
+
+def build_cli(args):
+    cli = GenericCLI(
+        app_name="Summarizer CLI",
+        settings={
+            "input_path": args.input_path,
+            "max_words": args.max_words,
+            "uppercase": args.uppercase,
+        },
+        tips=["/run", "/settings", "/docs", "/help"],
+    )
+
+    # 2. A command that calls main() using whatever is currently in settings.
+    @cli.command("/run", "Run the summarizer with current settings")
+    def cmd_run(prompt):
+        path = cli.config.get("input_path")
+        if not path:
+            cli.error("No input_path set. Use: /settings set input_path <file>")
+            return
+        cli.status(f"Summarizing {path}...")
+        result = summarize(
+            input_path=path,
+            max_words=cli.config.get("max_words"),
+            uppercase=cli.config.get("uppercase"),
+        )
+        cli.assistant_message(result)
+
+    # 3. Optional: also let free-text input trigger main() directly,
+    #    treating the typed text as the input_path.
+    def handler(prompt, cli):
+        return summarize(
+            input_path=prompt,
+            max_words=cli.config.get("max_words"),
+            uppercase=cli.config.get("uppercase"),
+        )
+
+    cli.handler = handler
+    return cli
+
+
+def main():
+    args = parse_args(app_name="Summarizer CLI", extra_args=EXTRA_ARGS)
+    cli = build_cli(args)
+    cli.run()
+
+
+if __name__ == "__main__":
+    main()

clizard/git_info.py

@@ -0,0 +1,64 @@
+"""Read repo identity straight out of .git/config."""
+import configparser
+import re
+from pathlib import Path
+
+
+def _parse_remote_url(url: str):
+    """Return (host, user, repo) from a git remote URL (ssh or https)."""
+    url = url.strip().rstrip("/")
+    if url.endswith(".git"):
+        url = url[:-4]
+
+    m = re.match(r"git@([^:]+):([^/]+)/(.+)$", url)  # git@github.com:user/repo
+    if not m:
+        m = re.match(r"https?://([^/]+)/([^/]+)/(.+)$", url)  # https://github.com/user/repo
+    if not m:
+        return None, None, None
+
+    host, user, repo = m.group(1), m.group(2), m.group(3)
+    return host, user, repo
+
+
+def get_git_info(repo_path="."):
+    """Inspect <repo_path>/.git/config and return repo metadata.
+
+    Returns dict with: host, github_user, github_repo, remote_url,
+    default_branch. Any field defaults to None/"" if not found.
+    """
+    info = {
+        "host": None,
+        "github_user": None,
+        "github_repo": None,
+        "remote_url": None,
+        "default_branch": "main",
+    }
+
+    git_config = Path(repo_path) / ".git" / "config"
+    if not git_config.exists():
+        return info
+
+    parser = configparser.ConfigParser(strict=False)
+    try:
+        parser.read(git_config)
+    except configparser.Error:
+        return info
+
+    for section in parser.sections():
+        if section.startswith('remote "'):
+            url = parser.get(section, "url", fallback=None)
+            if url:
+                info["remote_url"] = url
+                host, user, repo = _parse_remote_url(url)
+                info["host"] = host
+                info["github_user"] = user
+                info["github_repo"] = repo
+                break  # first remote (usually 'origin') wins
+
+    head_file = Path(repo_path) / ".git" / "HEAD"
+    if head_file.exists():
+        head = head_file.read_text().strip()
+        if head.startswith("ref: refs/heads/"):
+            info["default_branch"] = head.split("refs/heads/")[-1]
+
+    return info

clizard/project_info.py

@@ -0,0 +1,41 @@
+"""Read project metadata out of pyproject.toml."""
+from pathlib import Path
+
+try:
+    import tomllib  # py3.11+
+except ImportError:
+    import tomli as tomllib  # fallback
+
+
+def get_project_info(repo_path="."):
+    """Return dict with: name, version, docs_url, requirements (list)."""
+    info = {"name": None, "version": None, "docs_url": None, "requirements": []}
+
+    pyproject = Path(repo_path) / "pyproject.toml"
+    if pyproject.exists():
+        try:
+            with open(pyproject, "rb") as f:
+                data = tomllib.load(f)
+        except Exception:
+            data = {}
+
+        project = data.get("project", {})
+        info["name"] = project.get("name")
+        info["version"] = project.get("version")
+        info["requirements"] = project.get("dependencies", [])
+        info["description"] = project.get("description", "")
+
+        urls = project.get("urls", {})
+        for key in ("Documentation", "documentation", "Docs", "docs"):
+            if key in urls:
+                info["docs_url"] = urls[key]
+                break
+
+    req_file = Path(repo_path) / "requirements.txt"
+    if not info["requirements"] and req_file.exists():
+        info["requirements"] = [
+            line.strip() for line in req_file.read_text().splitlines()
+            if line.strip() and not line.strip().startswith("#")
+        ]
+
+    return info

clizard/scaffold.py

@@ -0,0 +1,187 @@
+"""Generate a standalone `clizard_main.py` that wraps a repo's existing
+main() with tclizard_main clizard interface, using .clizard for display settings.
+"""
+import inspect
+from pathlib import Path
+
+from .discover import find_main, settings_from_main
+from .clizard_file import ensure_clizard_file, save_clizard_file
+from .git_info import get_git_info
+
+TEMPLATE = '''"""Auto-generated by clizard. Wraps {entry_module}.main() with the
+clizard interactive interface. Re-run `clizard --scaffold` to regenerate.
+"""
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent / "{entry_dir}"))
+
+from {entry_module} import main as _original_main
+# Prefer the local `clizard` package if present; fall back to `genericli` for
+# standalone generated scripts that expect that external package.
+
+from clizard import GenericCLI
+from clizard.clizard_file import load_clizard_file
+
+REPO_PATH = str(Path(__file__).parent.resolve())
+
+# Fallback values baked in at generation time, used only if .clizard is
+# missing these keys (e.g. it predates this feature, or was hand-edited).
+_DEFAULT_SETTINGS = {settings!r}
+_DEFAULT_ARG_META = {arg_meta!r}
+_DEFAULT_CALL_STYLE = {call_style!r}
+
+
+def build_cli():
+    clz = load_clizard_file(REPO_PATH)
+
+    # Settings/arg_meta/call_style live in .clizard so that edits made via
+    # `/settings` while running `clizard` interactively (or by hand-editing
+    # .clizard) are picked up here too, without needing to re-scaffold.
+    settings = clz.get("settings") or _DEFAULT_SETTINGS
+    arg_meta = clz.get("arg_meta") or _DEFAULT_ARG_META
+    call_style = clz.get("call_style") or _DEFAULT_CALL_STYLE
+
+    cli = GenericCLI(
+        app_name=clz.get("app_name") or {app_name!r},
+        ascii_art=clz.get("ascii_art"),
+        accent_color=clz.get("accent_color", "#d97757"),
+        settings=settings,
+        tips=clz.get("tips"),
+        updates=clz.get("updates"),
+    )
+    cli.arg_meta = arg_meta
+
+    @cli.command("/run", "Run {entry_module}.main() with current settings")
+    def _cmd_run(prompt):
+        cli.status("Running...")
+        if call_style == "argv":
+            # main() takes no arguments and parses its own argparse
+            # parser internally -- rebuild sys.argv from settings instead.
+            argv = [sys.argv[0]]
+            for name, meta in cli.arg_meta.items():
+                flag = meta.get("flag")
+                if not flag:
+                    continue
+                val = cli.config.get(name)
+                if val is None:
+                    continue
+                if meta.get("is_flag"):
+                    if val:
+                        argv.append(flag)
+                else:
+                    argv.extend([flag, str(val)])
+            old_argv = sys.argv
+            sys.argv = argv
+            try:
+                result = _original_main()
+            finally:
+                sys.argv = old_argv
+        else:
+            call_kwargs = {{k: cli.config.get(k) for k in settings}}
+            result = _original_main(**call_kwargs)
+        if result is not None:
+            cli.assistant_message(str(result))
+
+    return cli
+
+
+def main():
+    build_cli().run()
+
+
+if __name__ == "__main__":
+    main()
+'''
+
+
+def generate_clizard_main(repo_path=".", output_name="clizard_main.py"):
+    """Write a clizard_main.py at the repo root. Returns the output Path,
+    or raises RuntimeError if no main() could be found.
+
+    The previous default filename `clizard.py` shadows the `clizard` package when
+    executed from the repo root (Python will import the local `clizard.py` file as
+    the `clizard` module, making `from clizard import ...` fail). Use
+    `clizard_main.py` to avoid that naming collision.
+    """
+    repo_path = Path(repo_path).resolve()
+    module, main_func, entry_file = find_main(str(repo_path))
+
+    if main_func is None:
+        raise RuntimeError(f"No main() found under {repo_path}; nothing to wrap.")
+
+    settings, arg_meta, call_style = settings_from_main(main_func)
+    safe_arg_meta = {
+        name: {
+            "choices": info["choices"],
+            # Only a plain string type name (e.g. "int") is safe to embed
+            # in the generated source; a real class's repr (e.g. "<class
+            # 'int'>") is not valid Python syntax inside a dict literal.
+            "type": info["type"] if isinstance(info.get("type"), str) else None,
+            "help": info["help"],
+            "flag": info.get("flag"),
+            "is_flag": info.get("is_flag", False),
+        }
+        for name, info in arg_meta.items()
+    }
+    run_body_call_style = call_style
+
+    entry_file = Path(entry_file)
+    entry_module = entry_file.stem  # "__main__" or "main"
+    entry_dir = entry_file.parent.relative_to(repo_path) if entry_file.parent != repo_path else "."
+
+    # Both clizard_main.py and .clizard always live at repo_path (the repo
+    # root), never inside the subdirectory/package containing main(). This
+    # matches the sys.path math below (Path(__file__).parent / entry_dir,
+    # with entry_dir relative to repo_path) and keeps a single, predictable
+    # location -- the same one `clizard` itself uses for .clizard.
+    out_path = repo_path / output_name
+
+    # Persist the discovered settings/arg_meta/call_style into .clizard so
+    # they're loaded at runtime by build_cli() above -- this also means
+    # edits made via `/settings` (or by hand-editing .clizard) carry over
+    # without needing to re-scaffold, and clizard_main.py can be regenerated
+    # later without losing customizations made elsewhere in .clizard.
+    clz = ensure_clizard_file(str(repo_path))
+    clz["settings"] = settings
+    clz["arg_meta"] = safe_arg_meta
+    clz["call_style"] = call_style
+    save_clizard_file(clz, str(repo_path))
+
+    # __main__.py can't be imported by stem name; use the package instead.
+    if entry_module == "__main__":
+        entry_module = entry_file.parent.name
+        entry_dir = entry_file.parent.parent.relative_to(repo_path) if entry_file.parent.parent != repo_path else "."
+
+    code = TEMPLATE.format(
+        entry_module=entry_module,
+        entry_dir=str(entry_dir),
+        app_name=clz.get("app_name") or repo_path.name,
+        settings=settings,
+        arg_meta=safe_arg_meta,
+        call_style=run_body_call_style,
+    )
+
+    # Write file
+    out_path.write_text(code)
+    return out_path
+
+
+def clizardmake_cli(path=None):
+    """Console entrypoint wrapper that uses the current working directory by default.
+
+    This function is intended for the `clizardmake` console_scripts entry point so
+    that running `clizardmake` will operate on the directory where it is executed.
+    """
+    import os
+    import sys
+
+    repo_path = Path(path or os.getcwd())
+
+    try:
+        out = generate_clizard_main(repo_path=str(repo_path))
+        # Print the output path so the user sees where the file was written
+        print(f'clizard main file written to: {out}')
+    except RuntimeError as e:
+        print(str(e), file=sys.stderr)
+        sys.exit(1)

clizard-0.1.0.dist-info/METADATA

@@ -0,0 +1,174 @@
+Metadata-Version: 2.4
+Name: clizard
+Version: 0.1.0
+Summary: clizard is a Python library for Reusable rich-based interactive CLI framework
+Author-email: Erdogan Taskesen <erdogant@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://erdogant.github.io/clizard
+Project-URL: Download, https://github.com/erdogant/clizard/archive/{version}.tar.gz
+Keywords: Python,clizard
+Classifier: Programming Language :: Python :: 3
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: Unix
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: rich>=13.0
+Dynamic: license-file
+
+[![Python](https://img.shields.io/pypi/pyversions/clizard)](https://img.shields.io/pypi/pyversions/clizard)
+[![Pypi](https://img.shields.io/pypi/v/clizard)](https://pypi.org/project/clizard/)
+[![Docs](https://img.shields.io/badge/Sphinx-Docs-Green)](https://erdogant.github.io/clizard/)
+[![LOC](https://sloc.xyz/github/erdogant/clizard/?category=code)](https://github.com/erdogant/clizard/)
+[![Downloads](https://static.pepy.tech/personalized-badge/clizard?period=month&units=international_system&left_color=grey&right_color=brightgreen&left_text=PyPI%20downloads/month)](https://pepy.tech/project/clizard)
+[![Downloads](https://static.pepy.tech/personalized-badge/clizard?period=total&units=international_system&left_color=grey&right_color=brightgreen&left_text=Downloads)](https://pepy.tech/project/clizard)
+[![License](https://img.shields.io/badge/license-MIT-green.svg)](https://github.com/erdogant/clizard/blob/master/LICENSE)
+[![Forks](https://img.shields.io/github/forks/erdogant/clizard.svg)](https://github.com/erdogant/clizard/network)
+[![Issues](https://img.shields.io/github/issues/erdogant/clizard.svg)](https://github.com/erdogant/clizard/issues)
+[![Project Status](http://www.repostatus.org/badges/latest/active.svg)](http://www.repostatus.org/#active)
+[![DOI](https://zenodo.org/badge/231843440.svg)](https://zenodo.org/badge/latestdoi/231843440)
+[![Medium](https://img.shields.io/badge/Medium-Blog-black)](https://erdogant.github.io/clizard/pages/html/Documentation.html#medium-blog)
+[![Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://erdogant.github.io/clizard/pages/html/Documentation.html#colab-notebook)
+[![Donate](https://img.shields.io/badge/Support%20this%20project-grey.svg?logo=github%20sponsors)](https://erdogant.github.io/clizard/pages/html/Documentation.html#)
+
+<div>
+<a href="https://erdogant.github.io/clizard/">
+  <img src="https://raw.githubusercontent.com/erdogant/clizard/master/docs/figs/logo.png"
+       width="250"
+       align="left" />
+</a>
+clizard is a Python package for probability density fitting of univariate distributions for random variables.
+The clizard library can determine the best fit for over 90 theoretical distributions. The goodness-of-fit test is used to score for the best fit and after finding the best-fitted theoretical distribution, the loc, scale, and arg parameters are returned.
+It can be used for parametric, non-parametric, and discrete distributions. ⭐️Star it if you like it⭐️
+</div>
+
+---
+
+### Key Features
+
+| Feature | Description |
+|--------|-------------|
+| [**Parametric Fitting**](https://erdogant.github.io/clizard/pages/html/Parametric.html) | Fit distributions on empirical data X. |
+| [**Non-Parametric Fitting**](https://erdogant.github.io/clizard/pages/html/Quantile.html) | Fit distributions on empirical data X using non-parametric approaches (quantile, percentiles). |
+| [**Discrete Fitting**](https://erdogant.github.io/clizard/pages/html/Discrete.html) | Fit distributions on empirical data X using binomial distribution. |
+| [**Predict**](https://erdogant.github.io/clizard/pages/html/Functions.html#module-clizard.clizard.clizard.predict) | Compute probabilities for response variables y. |
+| [**Synthetic Data**](https://erdogant.github.io/clizard/pages/html/Generate.html) |  Generate synthetic data. |
+| [**Plots**](https://erdogant.github.io/clizard/pages/html/Plots.html) | Varoius plotting functionalities. |
+
+---
+
+### Resources and Links
+- **Example Notebooks:** [Examples](https://erdogant.github.io/clizard/pages/html/Documentation.html)
+- **Blog Posts:** [Medium](https://erdogant.github.io/clizard/pages/html/Documentation.html#medium-blog)
+- **Documentation:** [Website](https://erdogant.github.io/clizard)
+- **Bug Reports and Feature Requests:** [GitHub Issues](https://github.com/erdogant/clizard/issues)
+
+---
+
+### Background
+
+* For the parametric approach, The clizard library can determine the best fit across 89 theoretical distributions.
+  To score the fit, one of the scoring statistics for the good-of-fitness test can be used used, such as RSS/SSE, Wasserstein,
+  Kolmogorov-Smirnov (KS), or Energy. After finding the best-fitted theoretical distribution, the loc, scale,
+  and arg parameters are returned, such as mean and standard deviation for normal distribution.
+
+* For the non-parametric approach, the clizard library contains two methods, the quantile and percentile method.
+  Both methods assume that the data does not follow a specific probability distribution. In the case of the quantile method,
+  the quantiles of the data are modeled whereas for the percentile method, the percentiles are modeled.
+
+---
+
+### Installation
+
+##### Install clizard from PyPI
+```bash
+pip install clizard
+```
+
+##### Install from Github source
+```bash
+pip install git+https://github.com/erdogant/clizard
+```
+
+##### Imort Library
+```python
+import clizard
+print(clizard.__version__)
+
+# Import library
+from clizard import clizard
+```
+
+<hr>
+
+### Examples
+
+##### [Example: Quick start to find best fit for your input data](https://erdogant.github.io/clizard/pages/html/Examples.html#)
+
+```python
+
+# [clizard] >INFO> fit
+# [clizard] >INFO> transform
+# [clizard] >INFO> [norm      ] [0.00 sec] [RSS: 0.00108326] [loc=-0.048 scale=1.997]
+# [clizard] >INFO> [expon     ] [0.00 sec] [RSS: 0.404237] [loc=-6.897 scale=6.849]
+# [clizard] >INFO> [pareto    ] [0.00 sec] [RSS: 0.404237] [loc=-536870918.897 scale=536870912.000]
+# [clizard] >INFO> [dweibull  ] [0.06 sec] [RSS: 0.0115552] [loc=-0.031 scale=1.722]
+# [clizard] >INFO> [t         ] [0.59 sec] [RSS: 0.00108349] [loc=-0.048 scale=1.997]
+# [clizard] >INFO> [genextreme] [0.17 sec] [RSS: 0.00300806] [loc=-0.806 scale=1.979]
+# [clizard] >INFO> [gamma     ] [0.05 sec] [RSS: 0.00108459] [loc=-1862.903 scale=0.002]
+# [clizard] >INFO> [lognorm   ] [0.32 sec] [RSS: 0.00121597] [loc=-110.597 scale=110.530]
+# [clizard] >INFO> [beta      ] [0.10 sec] [RSS: 0.00105629] [loc=-16.364 scale=32.869]
+# [clizard] >INFO> [uniform   ] [0.00 sec] [RSS: 0.287339] [loc=-6.897 scale=14.437]
+# [clizard] >INFO> [loggamma  ] [0.12 sec] [RSS: 0.00109042] [loc=-370.746 scale=55.722]
+# [clizard] >INFO> Compute confidence intervals [parametric]
+# [clizard] >INFO> Compute significance for 9 samples.
+# [clizard] >INFO> Multiple test correction method applied: [fdr_bh].
+# [clizard] >INFO> Create PDF plot for the parametric method.
+# [clizard] >INFO> Mark 5 significant regions
+# [clizard] >INFO> Estimated distribution: beta [loc:-16.364265, scale:32.868811]
+```
+
+<p align="left">
+  <a href="https://erdogant.github.io/clizard/pages/html/Examples.html#make-predictions">
+  <img src="https://github.com/erdogant/clizard/blob/master/docs/figs/example_figP4c.png" width="450" />
+  </a>
+</p>
+
+
+#
+
+##### [Example: Plot summary of the tested distributions](https://erdogant.github.io/clizard/pages/html/Examples.html#plot-rss)
+
+After we have a fitted model, we can make some predictions using the theoretical distributions.
+After making some predictions, we can plot again but now the predictions are automatically included.
+
+<p align="left">
+  <a href="https://erdogant.github.io/clizard/pages/html/Examples.html#plot-rss">
+  <img src="https://github.com/erdogant/clizard/blob/master/docs/figs/fig1_summary.png" width="450" />
+  </a>
+</p>
+
+#
+
+<hr>
+
+### Contributors
+Setting up and maintaining bnlearn has been possible thanks to users and contributors. Thanks to:
+
+<p align="left">
+  <a href="https://github.com/erdogant/clizard/graphs/contributors">
+  <img src="https://contrib.rocks/image?repo=erdogant/clizard" />
+  </a>
+</p>
+
+### Maintainer
+* Erdogan Taskesen, github: [erdogant](https://github.com/erdogant)
+* Contributions are welcome.
+* Yes! This library is entirely **free** but it runs on coffee! :) Feel free to support with a <a href="https://erdogant.github.io/donate/?currency=USD&amount=5">Coffee</a>.
+
+[![Buy me a coffee](https://img.buymeacoffee.com/button-api/?text=Buy+me+a+coffee&emoji=&slug=erdogant&button_colour=FFDD00&font_colour=000000&font_family=Cookie&outline_colour=000000&coffee_colour=ffffff)](https://www.buymeacoffee.com/erdogant)

clizard-0.1.0.dist-info/RECORD

@@ -0,0 +1,20 @@
+clizard/__init__.py,sha256=NZ5zGhfVra-ScQaOomjsY2HEzQlFzXfRutY92ndfgi0,213
+clizard/__main__.py,sha256=QzRKix5w2tsHKk7pqmJw57Yd1_YHG-tcxhsN9hSzhSY,5960
+clizard/cli_args.py,sha256=SVxp_wDz4Q9xa5LYFBcX5rrtgEYfY5GQxSfYPAmhrCI,3698
+clizard/clizard_file.py,sha256=MI5lQ_uaOV7Gn8PFUqgXj76iiihY6CeibCxujiWGQXk,1511
+clizard/config.py,sha256=8epmfws8YL7T2ayiLYJ7OuUTlAu5Osv4UdDIfYSfisg,1524
+clizard/core.py,sha256=TMWxg9Rz0axnO-nf8HRgd4lDiZ_kt9aVZMqLW8HbJBU,13241
+clizard/discover.py,sha256=7BSiiEZhEKWhwW19E8EsxhEAoM4-7EVhYRJj922C3gg,11444
+clizard/git_info.py,sha256=v2j8RCFSrKBF9NSVXU_n5AV7ihpmoMghQ170LJDt_P0,1978
+clizard/project_info.py,sha256=eQdDpl9pz2vH7_K7gBhhpnPKil4u8AN6GTJAVhJXAlg,1359
+clizard/scaffold.py,sha256=awR81fPdn8XXsydmwHs4zWOUuTgDxqSHFbMjzytAhnU,7015
+clizard/examples/examples_auto_cli_release_tool.py,sha256=By5hCfbCh3YjueJPbpLz8uYZRBItJe7cIQGeff3nnko,1498
+clizard/examples/examples_llmlight_app.py,sha256=dfzb_Hl4jjmHbdaR6tTLlnI2zaFmkjcLKYlv3MnghbM,1286
+clizard/examples/examples_summarizer.py,sha256=i3HY0Sb3WGZN8tiOzkm78OaKHVsnqufKQfdLMUvmoqw,487
+clizard/examples/examples_wrap_summarizer.py,sha256=Uf7p3pi5uaQPKuNy3gIRxCBwPiB4zTkvQ0hk5Ee7aBY,2021
+clizard-0.1.0.dist-info/licenses/LICENSE,sha256=v324pRx1CBd6jiK-y7mRwY4IK-eN7UGIkAcT_6zmYXg,1120
+clizard-0.1.0.dist-info/METADATA,sha256=jI2189I97qpTMMeHRp9RlZg6nQNIr3Wu1WMPbE9Yy5k,9144
+clizard-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+clizard-0.1.0.dist-info/entry_points.txt,sha256=UZS1--te8y-T5lLxWOp3c3EMjvJsHiyWY6rLW_mVoIU,97
+clizard-0.1.0.dist-info/top_level.txt,sha256=zSS6AZ85ZQqAsMrOTjwEgwuC7RfNudorD82hVVF7xuE,8
+clizard-0.1.0.dist-info/RECORD,,

clizard-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

clizard-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+clizard = clizard.__main__:main
+clizardmake = clizard.scaffold:clizardmake_cli