strictcli 0.8.7__tar.gz → 0.9.0__tar.gz

strictcli-0.9.0/.rlsbl/changes/.validated

@@ -0,0 +1 @@
+aeaf4155c6c810b0aff48faa3574b04897413861

strictcli-0.9.0/.rlsbl/changes/0.9.0.jsonl

@@ -0,0 +1,5 @@
+{"commits":["e595eaf58390d6b941b0362dfcbc65b9016054a9"],"user_facing":false}
+{"commits":["36342216953c20b8f38c9517e4eebad0893d1718"],"user_facing":false}
+{"commits":["fad001e35420a4aa0bd019a68448ce4c970d3f1e"],"user_facing":false}
+{"commits":["bb95ff55342e50eeec9a20c417b96e76df99e9c0"],"user_facing":true,"description":"**New feature.** config_path and config_format options for TOML-based configuration file support.","type":"feature"}
+{"commits":["0f0524d47831254eb0579b55ea14aff204043546"],"user_facing":false}

strictcli-0.9.0/.rlsbl/changes/0.9.0.md

@@ -0,0 +1,5 @@
+## 0.9.0
+
+### Features
+
+- **New feature.** config_path and config_format options for TOML-based configuration file support.

strictcli-0.9.0/.rlsbl/releases/v0.9.0.toml

@@ -0,0 +1,3 @@
+bump = "minor"
+include = ["pypi", "npm"]
+exclude = []

{strictcli-0.8.7 → strictcli-0.9.0}/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 # Changelog
 
+## 0.9.0
+
+### Features
+
+- **New feature.** config_path and config_format options for TOML-based configuration file support.
+
 ## 0.8.7
 
 ### Features

{strictcli-0.8.7 → strictcli-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: strictcli
-Version: 0.8.7
+Version: 0.9.0
 Summary: A strict, zero-dependency CLI framework for Python
 Project-URL: Homepage, https://github.com/smm-h/strictcli
 Project-URL: Repository, https://github.com/smm-h/strictcli

{strictcli-0.8.7 → strictcli-0.9.0}/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "strictcli",
-  "version": "0.8.7",
+  "version": "0.9.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "strictcli",
-      "version": "0.8.7",
+      "version": "0.9.0",
       "hasInstallScript": true,
       "license": "MIT"
     }

{strictcli-0.8.7 → strictcli-0.9.0}/package.json

@@ -1,6 +1,6 @@
 {
   "name": "strictcli",
-  "version": "0.8.7",
+  "version": "0.9.0",
   "description": "A strict, zero-dependency CLI framework for Python (npm wrapper)",
   "main": "index.js",
   "scripts": {

{strictcli-0.8.7 → strictcli-0.9.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "strictcli"
-version = "0.8.7"
+version = "0.9.0"
 description = "A strict, zero-dependency CLI framework for Python"
 readme = "README.md"
 license = "MIT"

{strictcli-0.8.7 → strictcli-0.9.0}/strictcli/__init__.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-__version__ = "0.8.7"
+__version__ = "0.9.0"
 
 __all__ = [
     "App", "Flag", "Arg", "Tag", "MutexGroup", "CoRequired", "Requires",
@@ -36,21 +36,40 @@ class _MissingSentinel:
 _MISSING = _MissingSentinel()
 
 
-def _config_path(app_name: str) -> str:
-    """Compute the config file path for an app."""
+def _config_path(app_name: str, *, override: str | None = None, config_format: str = "json") -> str:
+    """Compute the config file path for an app.
+
+    If override is provided, expand ~ and return it directly.
+    Otherwise compute from XDG_CONFIG_HOME + app_name.
+    """
+    if override is not None:
+        return os.path.expanduser(override)
     config_home = os.environ.get("XDG_CONFIG_HOME", os.path.expanduser("~/.config"))
-    return os.path.join(config_home, app_name, "config.json")
+    ext = "toml" if config_format == "toml" else "json"
+    return os.path.join(config_home, app_name, f"config.{ext}")
 
 
-def _load_config(app_name: str) -> dict:
-    """Load the JSON config file for an app.
+def _load_config(
+    app_name: str,
+    *,
+    config_path_override: str | None = None,
+    config_format: str = "json",
+) -> dict:
+    """Load the config file for an app.
 
-    Returns an empty dict if the file doesn't exist or contains invalid JSON.
-    Invalid JSON prints a warning to stderr.
+    Returns an empty dict if the file doesn't exist or contains invalid content.
+    Invalid content prints a warning to stderr.
     """
-    path = _config_path(app_name)
+    path = _config_path(app_name, override=config_path_override, config_format=config_format)
     if not os.path.isfile(path):
         return {}
+    if config_format == "toml":
+        try:
+            with open(path, "rb") as f:
+                return tomllib.load(f)
+        except (tomllib.TOMLDecodeError, UnicodeDecodeError):
+            print(f"warning: invalid TOML in config file '{path}', ignoring", file=sys.stderr)
+            return {}
     try:
         with open(path) as f:
             return json.loads(f.read())
@@ -59,6 +78,29 @@ def _load_config(app_name: str) -> dict:
         return {}
 
 
+def _write_toml_flat(data: dict, path: str) -> None:
+    """Write a flat dict as a TOML file.
+
+    Supports str, int, float, and bool values. This avoids requiring
+    a TOML writer dependency for the simple key=value configs that
+    'config set' produces.
+    """
+    lines: list[str] = []
+    for key, value in data.items():
+        if isinstance(value, bool):
+            lines.append(f"{key} = {str(value).lower()}")
+        elif isinstance(value, str):
+            escaped = value.replace("\\", "\\\\").replace('"', '\\"')
+            lines.append(f'{key} = "{escaped}"')
+        elif isinstance(value, (int, float)):
+            lines.append(f"{key} = {value}")
+        else:
+            escaped = str(value).replace("\\", "\\\\").replace('"', '\\"')
+            lines.append(f'{key} = "{escaped}"')
+    with open(path, "w") as f:
+        f.write("\n".join(lines) + "\n" if lines else "")
+
+
 def _coerce_config_value(value: object, flag: "Flag") -> object:
     """Coerce a JSON config value to the flag's type.
 
@@ -579,6 +621,8 @@ class App:
     version: str | None = None
     env_prefix: str | None = None
     config: bool = False
+    config_path: str | None = None
+    config_format: str = "json"
     flags: list[Flag] = field(default_factory=list)
     _commands: dict[str, Command] = field(default_factory=dict)
     _groups: dict[str, Group] = field(default_factory=dict)
@@ -600,10 +644,19 @@ class App:
             seen.add(f.name)
         self._global_flags: list[Flag] = list(self.flags)
         self._last_global_values: dict[str, object] = {}
+        # Validate config_format
+        if self.config_format not in ("json", "toml"):
+            raise ValueError(
+                f'App.config_format must be "json" or "toml", got {self.config_format!r}'
+            )
         # Load config and register config subcommands if enabled
         self._config_data: dict = {}
         if self.config:
-            self._config_data = _load_config(self.name)
+            self._config_data = _load_config(
+                self.name,
+                config_path_override=self.config_path,
+                config_format=self.config_format,
+            )
             self._register_config_group()
         # Discover checks TOML
         self._check_context_factory: Callable | None = None
@@ -843,12 +896,20 @@ class App:
         config_grp.commands["path"] = Command(
             name="path",
             help="Print the config file path",
-            handler=lambda **_kw: print(_config_path(app_ref.name)),
+            handler=lambda **_kw: print(_config_path(
+                app_ref.name,
+                override=app_ref.config_path,
+                config_format=app_ref.config_format,
+            )),
         )
 
         # config show
         def _config_show_handler(**_kw) -> None:
-            config_data = _load_config(app_ref.name)
+            config_data = _load_config(
+                app_ref.name,
+                config_path_override=app_ref.config_path,
+                config_format=app_ref.config_format,
+            )
             all_flags = app_ref._collect_all_flags()
             for f in all_flags:
                 param = _flag_param_name(f.name)
@@ -872,20 +933,34 @@ class App:
 
         # config set
         def _config_set_handler(key, value, **_kw) -> None:
-            path = _config_path(app_ref.name)
+            path = _config_path(
+                app_ref.name,
+                override=app_ref.config_path,
+                config_format=app_ref.config_format,
+            )
             dir_path = os.path.dirname(path)
             os.makedirs(dir_path, exist_ok=True)
             # Read existing config
             existing: dict = {}
             if os.path.isfile(path):
-                try:
-                    with open(path) as fh:
-                        existing = json.loads(fh.read())
-                except (json.JSONDecodeError, ValueError):
-                    existing = {}
+                if app_ref.config_format == "toml":
+                    try:
+                        with open(path, "rb") as fh:
+                            existing = tomllib.load(fh)
+                    except (tomllib.TOMLDecodeError, UnicodeDecodeError):
+                        existing = {}
+                else:
+                    try:
+                        with open(path) as fh:
+                            existing = json.loads(fh.read())
+                    except (json.JSONDecodeError, ValueError):
+                        existing = {}
             existing[key] = value
-            with open(path, "w") as fh:
-                fh.write(json.dumps(existing, indent=2) + "\n")
+            if app_ref.config_format == "toml":
+                _write_toml_flat(existing, path)
+            else:
+                with open(path, "w") as fh:
+                    fh.write(json.dumps(existing, indent=2) + "\n")
 
         config_grp.commands["set"] = Command(
             name="set",
@@ -899,12 +974,20 @@ class App:
 
         # config edit
         def _config_edit_handler(**_kw) -> None:
-            path = _config_path(app_ref.name)
+            path = _config_path(
+                app_ref.name,
+                override=app_ref.config_path,
+                config_format=app_ref.config_format,
+            )
             dir_path = os.path.dirname(path)
             os.makedirs(dir_path, exist_ok=True)
             if not os.path.isfile(path):
-                with open(path, "w") as fh:
-                    fh.write("{}\n")
+                if app_ref.config_format == "toml":
+                    with open(path, "w") as fh:
+                        fh.write("")
+                else:
+                    with open(path, "w") as fh:
+                        fh.write("{}\n")
             editor = os.environ.get("EDITOR", "vi")
             subprocess.run([editor, path])
 

{strictcli-0.8.7 → strictcli-0.9.0}/tests/test_config.py

@@ -376,3 +376,328 @@ def test_config_int_as_float(tmp_path, monkeypatch):
     r = app.test(["run"])
     assert r.exit_code == 0
     assert "ratio=2.0" in r.stdout
+
+
+# --- Custom config_path tests ---
+
+def test_custom_config_path(tmp_path, monkeypatch):
+    """Custom config_path is used instead of XDG-computed path."""
+    config_file = tmp_path / "my-custom-config.json"
+    config_file.write_text(json.dumps({"target": "custom-path-val"}) + "\n")
+
+    app = strictcli.App(
+        name="testapp",
+        version="1.0.0",
+        help="test app",
+        config=True,
+        config_path=str(config_file),
+    )
+
+    @app.command("run", help="run something")
+    @strictcli.flag("target", type=str, help="the target", default="default-val")
+    def run(target):
+        print(f"target={target}")
+
+    r = app.test(["run"])
+    assert r.exit_code == 0
+    assert "target=custom-path-val" in r.stdout
+
+
+def test_custom_config_path_tilde_expansion(tmp_path, monkeypatch):
+    """Custom config_path expands ~ correctly."""
+    monkeypatch.setenv("HOME", str(tmp_path))
+    config_dir = tmp_path / ".myapp"
+    config_dir.mkdir()
+    config_file = config_dir / "settings.json"
+    config_file.write_text(json.dumps({"target": "tilde-val"}) + "\n")
+
+    app = strictcli.App(
+        name="testapp",
+        version="1.0.0",
+        help="test app",
+        config=True,
+        config_path="~/.myapp/settings.json",
+    )
+
+    @app.command("run", help="run something")
+    @strictcli.flag("target", type=str, help="the target", default="default-val")
+    def run(target):
+        print(f"target={target}")
+
+    r = app.test(["run"])
+    assert r.exit_code == 0
+    assert "target=tilde-val" in r.stdout
+
+
+def test_custom_config_path_config_path_command(tmp_path):
+    """config path command prints the custom path."""
+    config_file = tmp_path / "custom.json"
+    config_file.write_text("{}")
+
+    app = strictcli.App(
+        name="testapp",
+        version="1.0.0",
+        help="test app",
+        config=True,
+        config_path=str(config_file),
+    )
+
+    @app.command("run", help="run something")
+    def run():
+        pass
+
+    r = app.test(["config", "path"])
+    assert r.exit_code == 0
+    assert str(config_file) in r.stdout
+
+
+def test_custom_config_path_config_set(tmp_path):
+    """config set writes to the custom path."""
+    config_file = tmp_path / "custom.json"
+
+    app = strictcli.App(
+        name="testapp",
+        version="1.0.0",
+        help="test app",
+        config=True,
+        config_path=str(config_file),
+    )
+
+    @app.command("run", help="run something")
+    @strictcli.flag("target", type=str, help="the target", default="default-val")
+    def run(target):
+        print(f"target={target}")
+
+    r = app.test(["config", "set", "target", "written"])
+    assert r.exit_code == 0
+    assert config_file.exists()
+    data = json.loads(config_file.read_text())
+    assert data["target"] == "written"
+
+
+# --- TOML config format tests ---
+
+def test_toml_format_reads_correctly(tmp_path):
+    """TOML format config reads values correctly."""
+    config_file = tmp_path / "config.toml"
+    config_file.write_text('target = "toml-value"\ncount = 42\nverbose = true\n')
+
+    app = strictcli.App(
+        name="testapp",
+        version="1.0.0",
+        help="test app",
+        config=True,
+        config_path=str(config_file),
+        config_format="toml",
+    )
+
+    @app.command("run", help="run something")
+    @strictcli.flag("target", type=str, help="the target", default="default-val")
+    @strictcli.flag("count", type=int, help="how many", default=1)
+    @strictcli.flag("verbose", type=bool, help="be verbose")
+    def run(target, count, verbose):
+        print(f"target={target} count={count} verbose={verbose}")
+
+    r = app.test(["run"])
+    assert r.exit_code == 0
+    assert "target=toml-value" in r.stdout
+    assert "count=42" in r.stdout
+    assert "verbose=True" in r.stdout
+
+
+def test_toml_format_set_writes_correctly(tmp_path):
+    """TOML format config set writes valid TOML."""
+    config_file = tmp_path / "config.toml"
+
+    app = strictcli.App(
+        name="testapp",
+        version="1.0.0",
+        help="test app",
+        config=True,
+        config_path=str(config_file),
+        config_format="toml",
+    )
+
+    @app.command("run", help="run something")
+    @strictcli.flag("target", type=str, help="the target", default="default-val")
+    def run(target):
+        print(f"target={target}")
+
+    r = app.test(["config", "set", "target", "toml-written"])
+    assert r.exit_code == 0
+    assert config_file.exists()
+
+    import tomllib
+    with open(config_file, "rb") as f:
+        data = tomllib.load(f)
+    assert data["target"] == "toml-written"
+
+
+def test_toml_format_set_preserves_existing(tmp_path):
+    """TOML format config set preserves existing keys."""
+    config_file = tmp_path / "config.toml"
+    config_file.write_text('existing = "keep-me"\n')
+
+    app = strictcli.App(
+        name="testapp",
+        version="1.0.0",
+        help="test app",
+        config=True,
+        config_path=str(config_file),
+        config_format="toml",
+    )
+
+    @app.command("run", help="run something")
+    @strictcli.flag("target", type=str, help="the target", default="default-val")
+    def run(target):
+        print(f"target={target}")
+
+    r = app.test(["config", "set", "target", "new-val"])
+    assert r.exit_code == 0
+
+    import tomllib
+    with open(config_file, "rb") as f:
+        data = tomllib.load(f)
+    assert data["target"] == "new-val"
+    assert data["existing"] == "keep-me"
+
+
+def test_toml_format_config_path_command(tmp_path):
+    """config path prints the custom path for TOML format."""
+    config_file = tmp_path / "my-config.toml"
+    config_file.write_text("")
+
+    app = strictcli.App(
+        name="testapp",
+        version="1.0.0",
+        help="test app",
+        config=True,
+        config_path=str(config_file),
+        config_format="toml",
+    )
+
+    @app.command("run", help="run something")
+    def run():
+        pass
+
+    r = app.test(["config", "path"])
+    assert r.exit_code == 0
+    assert str(config_file) in r.stdout
+
+
+def test_toml_format_xdg_default_path(tmp_path, monkeypatch):
+    """Without custom config_path, TOML format uses .toml extension in XDG path."""
+    monkeypatch.setenv("XDG_CONFIG_HOME", str(tmp_path))
+
+    app = strictcli.App(
+        name="testapp",
+        version="1.0.0",
+        help="test app",
+        config=True,
+        config_format="toml",
+    )
+
+    @app.command("run", help="run something")
+    def run():
+        pass
+
+    r = app.test(["config", "path"])
+    assert r.exit_code == 0
+    expected = os.path.join(str(tmp_path), "testapp", "config.toml")
+    assert expected in r.stdout
+
+
+def test_invalid_toml_warning(tmp_path):
+    """Invalid TOML file prints warning and falls back to defaults."""
+    config_file = tmp_path / "config.toml"
+    config_file.write_text("this is = not [ valid toml")
+
+    app = strictcli.App(
+        name="testapp",
+        version="1.0.0",
+        help="test app",
+        config=True,
+        config_path=str(config_file),
+        config_format="toml",
+    )
+
+    @app.command("run", help="run something")
+    @strictcli.flag("target", type=str, help="the target", default="default-val")
+    def run(target):
+        print(f"target={target}")
+
+    r = app.test(["run"])
+    assert r.exit_code == 0
+    assert "target=default-val" in r.stdout
+
+
+def test_invalid_config_format():
+    """Invalid config_format raises ValueError."""
+    with pytest.raises(ValueError, match='config_format must be'):
+        strictcli.App(
+            name="testapp",
+            version="1.0.0",
+            help="test app",
+            config=True,
+            config_format="yaml",
+        )
+
+
+def test_default_json_unchanged(tmp_path, monkeypatch):
+    """Default behavior (JSON, XDG path) is unchanged."""
+    config_home = _write_config(tmp_path, "testapp", {"target": "json-default"})
+    monkeypatch.setenv("XDG_CONFIG_HOME", config_home)
+    app = _make_config_app(config=True)
+    r = app.test(["run"])
+    assert r.exit_code == 0
+    assert "target=json-default" in r.stdout
+
+
+def test_toml_config_show(tmp_path):
+    """config show works with TOML format."""
+    config_file = tmp_path / "config.toml"
+    config_file.write_text('target = "toml-show-val"\n')
+
+    app = strictcli.App(
+        name="testapp",
+        version="1.0.0",
+        help="test app",
+        config=True,
+        config_path=str(config_file),
+        config_format="toml",
+    )
+
+    @app.command("run", help="run something")
+    @strictcli.flag("target", type=str, help="the target", default="default-val")
+    @strictcli.flag("count", type=int, help="how many", default=1)
+    def run(target, count):
+        pass
+
+    r = app.test(["config", "show"])
+    assert r.exit_code == 0
+    assert "target = toml-show-val  (source: config)" in r.stdout
+    assert "count = 1  (source: default)" in r.stdout
+
+
+def test_toml_float_value(tmp_path):
+    """TOML config with float values works correctly."""
+    config_file = tmp_path / "config.toml"
+    config_file.write_text('ratio = 0.75\n')
+
+    app = strictcli.App(
+        name="testapp",
+        version="1.0.0",
+        help="test app",
+        config=True,
+        config_path=str(config_file),
+        config_format="toml",
+    )
+
+    @app.command("run", help="run something")
+    @strictcli.flag("ratio", type=float, help="ratio value", default=1.0)
+    def run(ratio):
+        print(f"ratio={ratio}")
+
+    r = app.test(["run"])
+    assert r.exit_code == 0
+    assert "ratio=0.75" in r.stdout

{strictcli-0.8.7 → strictcli-0.9.0}/uv.lock

@@ -232,7 +232,7 @@ wheels = [
 
 [[package]]
 name = "strictcli"
-version = "0.8.7"
+version = "0.9.0"
 source = { editable = "." }
 
 [package.dev-dependencies]

strictcli-0.8.7/.rlsbl/changes/.validated

@@ -1 +0,0 @@
-cb4155e0427b58ad57b6684d038a8ec780101d5b