pyprojkit 0.4.2__tar.gz → 0.5.0__tar.gz

{pyprojkit-0.4.2 → pyprojkit-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyprojkit
-Version: 0.4.2
+Version: 0.5.0
 Summary: Development workflow toolkit for Python projects: pyproject.toml sync, doit tasks, nox sessions
 Author: mm21
 Author-email: mm21 <mm21.dev@gmail.com>
@@ -24,7 +24,7 @@ Requires-Dist: tomlkit>=0.13.3,<0.14
 Requires-Dist: pyprojkit[analysis,doc,format,test] ; extra == 'all'
 Requires-Dist: mypy[reports]>=1.5.1,<2 ; extra == 'analysis'
 Requires-Dist: pyright>=1.1.329,<2 ; extra == 'analysis'
-Requires-Dist: mkinit ; extra == 'doc'
+Requires-Dist: mkinit>=1.3.0,<2 ; extra == 'doc'
 Requires-Dist: autoflake>=2.3.1,<3 ; extra == 'format'
 Requires-Dist: black>=25.1.0,<26 ; extra == 'format'
 Requires-Dist: docfmt>=0.3.0,<0.4.0 ; extra == 'format'

{pyprojkit-0.4.2 → pyprojkit-0.5.0}/pyproject.toml

@@ -29,7 +29,7 @@ license-files = ["LICENSE"]
 name = "pyprojkit"
 readme = "README.md"
 requires-python = ">=3.12,<4.0"  # pyprojkit-managed
-version = "0.4.2"
+version = "0.5.0"
 
 [project.optional-dependencies]
 all = [
@@ -40,7 +40,7 @@ analysis = [
   "pyright>=1.1.329,<2"
 ]
 doc = [
-  "mkinit"
+  "mkinit>=1.3.0,<2"
 ]
 format = [
   "autoflake>=2.3.1,<3",
@@ -107,6 +107,7 @@ profile = "black"  # pyprojkit-managed
 quiet = true  # pyprojkit-managed
 
 [tool.mypy]
+check_untyped_defs = true  # pyprojkit-managed
 ignore_missing_imports = true  # pyprojkit-managed
 python_version = "3.12"  # pyprojkit-managed
 
@@ -114,6 +115,9 @@ python_version = "3.12"  # pyprojkit-managed
 default_venv_backend = "uv"  # pyprojkit-managed
 envdir = "__cache__/nox"  # pyprojkit-managed
 
+[tool.pyright]
+pythonVersion = "3.12"  # pyprojkit-managed
+
 [tool.pytest.ini_options]
 addopts = "--import-mode=importlib -s -v -rA"  # pyprojkit-managed
 cache_dir = "__cache__/pytest"  # pyprojkit-managed
@@ -127,6 +131,3 @@ sort_first = [
 ]  # pyprojkit-managed
 sort_table_keys = true  # pyprojkit-managed
 spaces_before_inline_comment = 2  # pyprojkit-managed
-
-[tool.uv.sources]
-mkinit = {git = "https://github.com/mm21/mkinit.git"}

{pyprojkit-0.4.2 → pyprojkit-0.5.0}/src/pyprojkit/__init__.py

@@ -19,6 +19,7 @@ __submodules__ = [
 # <AUTOGEN_INIT>
 from .config import (
     ConfigError,
+    BaseConfig,
     BaseToolConfig,
     BaseFormatterConfig,
     AutoflakeConfig,
@@ -32,6 +33,7 @@ from .config import (
     DoitConfig,
     NoxConfig,
     MypyConfig,
+    PyrightConfig,
     ProjectConfig,
     ToolsConfig,
     FormattingConfig,
@@ -71,6 +73,7 @@ from .sessions import (
 __all__ = [
     "sync",
     "ConfigError",
+    "BaseConfig",
     "BaseToolConfig",
     "BaseFormatterConfig",
     "AutoflakeConfig",
@@ -84,6 +87,7 @@ __all__ = [
     "DoitConfig",
     "NoxConfig",
     "MypyConfig",
+    "PyrightConfig",
     "ProjectConfig",
     "ToolsConfig",
     "FormattingConfig",

{pyprojkit-0.4.2 → pyprojkit-0.5.0}/src/pyprojkit/config/__init__.py

@@ -13,6 +13,7 @@ __submodules__ = [
 # <AUTOGEN_INIT>
 from .base import (
     ConfigError,
+    BaseConfig,
     BaseToolConfig,
     BaseFormatterConfig,
 )
@@ -28,6 +29,7 @@ from .tools import (
     DoitConfig,
     NoxConfig,
     MypyConfig,
+    PyrightConfig,
 )
 from .project import (
     ProjectConfig,
@@ -47,6 +49,7 @@ from .profiles import (
 
 __all__ = [
     "ConfigError",
+    "BaseConfig",
     "BaseToolConfig",
     "BaseFormatterConfig",
     "AutoflakeConfig",
@@ -60,6 +63,7 @@ __all__ = [
     "DoitConfig",
     "NoxConfig",
     "MypyConfig",
+    "PyrightConfig",
     "ProjectConfig",
     "ToolsConfig",
     "FormattingConfig",

{pyprojkit-0.4.2 → pyprojkit-0.5.0}/src/pyprojkit/config/base.py

@@ -6,13 +6,14 @@ from __future__ import annotations
 
 from abc import ABC, abstractmethod
 from dataclasses import dataclass, fields
-from typing import TYPE_CHECKING, Any, ClassVar
+from typing import TYPE_CHECKING, Any, ClassVar, Self
 
 if TYPE_CHECKING:
     from .project import ProjectConfig
 
 __all__ = [
     "ConfigError",
+    "BaseConfig",
     "BaseToolConfig",
     "BaseFormatterConfig",
 ]
@@ -24,16 +25,36 @@ class ConfigError(Exception):
     """
 
 
+class BaseConfig(ABC):
+    """
+    Base for all tool configurations: both tool categories (e.g. `TestConfig`) and
+    individual tools' `pyproject.toml` tables (e.g. `PytestConfig`).
+
+    A default-constructed config is empty: every setting is unset and every optional
+    sub-config is disabled. Opinionated settings are provided by
+    `create_kitchen_sink()`.
+    """
+
+    @classmethod
+    @abstractmethod
+    def create_kitchen_sink(cls) -> Self:
+        """
+        Get a new instance with opinionated settings, as used by
+        `create_kitchen_sink_tools()`.
+        """
+        ...
+
+
 @dataclass(kw_only=True)
-class BaseToolConfig(ABC):
+class BaseToolConfig(BaseConfig):
     """
     Configuration for a tool which reads its settings from a table in `pyproject.toml`,
     e.g. `[tool.black]`.
 
     Dataclass fields map to table entries; a field whose name differs from its TOML key
     declares the key via `field(metadata={"toml": "some-key"})`. Fields set to `None`
-    are omitted. Values derived from project-wide config (e.g. black's `target-version`)
-    are contributed by `extra_toml()`.
+    (the default for every field) are omitted. Values derived from project-wide config
+    (e.g. black's `target-version`) are contributed by `extra_toml()`.
     """
 
     table_path: ClassVar[str]

pyprojkit-0.5.0/src/pyprojkit/config/profiles.py

@@ -0,0 +1,51 @@
+"""
+Built-in tool configurations.
+
+Configurations are plain `ToolsConfig` values: define your own factory function or
+global in a module shared across projects, enabling just the tools you want:
+
+```python
+from pyprojkit import (
+    AnalysisConfig,
+    BlackConfig,
+    FormattingConfig,
+    IsortConfig,
+    PyrightConfig,
+    PytestConfig,
+    TestConfig,
+    ToolsConfig,
+)
+
+
+def create_mycompany_tools() -> ToolsConfig:
+    return ToolsConfig(
+        formatting=FormattingConfig(
+            formatters=(
+                IsortConfig(profile="black"),
+                BlackConfig(),
+            )
+        ),
+        test=TestConfig(pytest=PytestConfig(testpaths="tests")),
+        analysis=AnalysisConfig(pyright=PyrightConfig()),
+    )
+```
+
+Alternatively, start from `create_kitchen_sink_tools()` and override parts of it with
+`dataclasses.replace()`.
+"""
+
+from __future__ import annotations
+
+from .project import ToolsConfig
+
+__all__ = [
+    "create_kitchen_sink_tools",
+]
+
+
+def create_kitchen_sink_tools() -> ToolsConfig:
+    """
+    Get a new instance of the configuration which enables every tool; equivalent to
+    `ToolsConfig.create_kitchen_sink()`.
+    """
+    return ToolsConfig.create_kitchen_sink()

{pyprojkit-0.4.2 → pyprojkit-0.5.0}/src/pyprojkit/config/project.py

@@ -6,18 +6,24 @@ from __future__ import annotations
 
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import Literal, Sequence
+from typing import Literal, Self, Sequence
 
 from .. import _paths
 from ..versions import PythonVersions, PythonVersionSet, RequiresPython
-from .base import BaseFormatterConfig
+from .base import BaseConfig, BaseFormatterConfig
 from .tools import (
+    AutoflakeConfig,
+    BlackConfig,
     CoverageReportConfig,
     CoverageRunConfig,
+    DocfmtConfig,
     DoitConfig,
+    IsortConfig,
     MypyConfig,
     NoxConfig,
+    PyrightConfig,
     PytestConfig,
+    TomlSortConfig,
 )
 
 __all__ = [
@@ -35,19 +41,31 @@ __all__ = [
 
 
 @dataclass(kw_only=True)
-class FormattingConfig:
+class FormattingConfig(BaseConfig):
     """
     Formatting configuration: which formatters run (in order) and their settings.
     """
 
-    formatters: tuple[BaseFormatterConfig, ...]
+    formatters: tuple[BaseFormatterConfig, ...] = ()
     """
     Formatters in run order.
     """
 
+    @classmethod
+    def create_kitchen_sink(cls) -> Self:
+        return cls(
+            formatters=(
+                AutoflakeConfig.create_kitchen_sink(),
+                IsortConfig.create_kitchen_sink(),
+                DocfmtConfig.create_kitchen_sink(),
+                BlackConfig.create_kitchen_sink(),
+                TomlSortConfig.create_kitchen_sink(),
+            )
+        )
+
 
 @dataclass(kw_only=True)
-class TestConfig:
+class TestConfig(BaseConfig):
     """
     Testing configuration (pytest + coverage).
     """
@@ -56,27 +74,35 @@ class TestConfig:
     coverage_run: CoverageRunConfig = field(default_factory=CoverageRunConfig)
     coverage_report: CoverageReportConfig = field(default_factory=CoverageReportConfig)
 
+    @classmethod
+    def create_kitchen_sink(cls) -> Self:
+        return cls(
+            pytest=PytestConfig.create_kitchen_sink(),
+            coverage_run=CoverageRunConfig.create_kitchen_sink(),
+            coverage_report=CoverageReportConfig.create_kitchen_sink(),
+        )
+
 
 @dataclass(kw_only=True)
-class MkinitConfig:
+class MkinitConfig(BaseConfig):
     """
     Configuration for generating `__init__.py` files using mkinit.
     """
 
-    args: tuple[str, ...] = (
-        "--recursive",
-        "--nomods",
-        "--relative",
-        "-i",
-        "--source-order",
-    )
+    args: tuple[str, ...] = ()
     """
     Arguments passed to mkinit.
     """
 
+    @classmethod
+    def create_kitchen_sink(cls) -> Self:
+        return cls(
+            args=("--recursive", "--nomods", "--relative", "-i", "--source-order")
+        )
+
 
 @dataclass(kw_only=True)
-class SphinxConfig:
+class SphinxConfig(BaseConfig):
     """
     Configuration for building documentation using sphinx.
     """
@@ -92,49 +118,72 @@ class SphinxConfig:
     built documentation when the doc task is run with `--copy`.
     """
 
+    @classmethod
+    def create_kitchen_sink(cls) -> Self:
+        return cls()
+
 
 @dataclass(kw_only=True)
-class DocConfig:
+class DocConfig(BaseConfig):
     """
     Documentation tool configurations.
     """
 
-    mkinit: MkinitConfig | None = field(default_factory=MkinitConfig)
+    mkinit: MkinitConfig | None = None
     """
-    Enables the `init` task; enabled by default.
+    Enables the `init` task.
     """
 
     sphinx: SphinxConfig | None = None
     """
-    Enables the `doc` task; opt-in.
+    Enables the `doc` task.
     """
 
+    @classmethod
+    def create_kitchen_sink(cls) -> Self:
+        """
+        Enables mkinit; sphinx is left disabled since it needs project-specific
+        settings.
+        """
+        return cls(mkinit=MkinitConfig.create_kitchen_sink())
+
 
 @dataclass(kw_only=True)
-class AnalysisConfig:
+class AnalysisConfig(BaseConfig):
     """
     Static analysis configuration.
     """
 
-    mypy: MypyConfig | None = field(default_factory=MypyConfig)
-    pyright: bool = True
+    mypy: MypyConfig | None = None
+    pyright: PyrightConfig | None = None
+
+    @classmethod
+    def create_kitchen_sink(cls) -> Self:
+        return cls(
+            mypy=MypyConfig.create_kitchen_sink(),
+            pyright=PyrightConfig.create_kitchen_sink(),
+        )
 
 
 @dataclass(kw_only=True)
-class PublishConfig:
+class PublishConfig(BaseConfig):
     """
     Configuration for building and publishing via uv.
     """
 
-    out_dir: str = str(_paths.UV_PATH)
+    out_dir: str | None = None
     """
-    Directory for build artifacts; cleaned before each build so stale artifacts are
-    never published.
+    Directory for build artifacts, defaulting to uv's `dist`; cleaned before each build
+    so stale artifacts are never published.
     """
 
+    @classmethod
+    def create_kitchen_sink(cls) -> Self:
+        return cls(out_dir=str(_paths.UV_PATH))
+
 
 @dataclass(kw_only=True)
-class SkillConfig:
+class SkillConfig(BaseConfig):
     """
     Agent skill integration: a `pyprojkit-python` skill in the
     [Agent Skills](https://agentskills.io) format, generated from the project's
@@ -148,16 +197,20 @@ class SkillConfig:
     `<skills_dir>/pyprojkit-python/SKILL.md`.
     """
 
+    @classmethod
+    def create_kitchen_sink(cls) -> Self:
+        return cls()
+
 
 @dataclass(kw_only=True)
-class ToolsConfig:
+class ToolsConfig(BaseConfig):
     """
     Development tool configurations, grouped by broad tool category.
 
     Every category is opt-in: `None` (the default) means the tool is neither managed nor
-    given a task. For a pre-canned set of everything, see `create_kitchen_sink_tools()`;
-    to share a configuration across projects, define your own factory function or
-    global.
+    given a task. For a pre-canned set of everything, see `create_kitchen_sink()` (also
+    available as `create_kitchen_sink_tools()`); to share a configuration across
+    projects, define your own factory function or global.
     """
 
     workflow_tool: Literal["uv", "poetry"] | None = None
@@ -179,6 +232,26 @@ class ToolsConfig:
     sync.
     """
 
+    @classmethod
+    def create_kitchen_sink(cls) -> Self:
+        """
+        Enables every tool category, each with its opinionated settings: uv as the
+        workflow tool, formatting, testing, doit, nox, mkinit, static analysis,
+        publishing and the agent skill. Sphinx is left disabled since it needs
+        project-specific settings.
+        """
+        return cls(
+            workflow_tool="uv",
+            formatting=FormattingConfig.create_kitchen_sink(),
+            test=TestConfig.create_kitchen_sink(),
+            doit=DoitConfig.create_kitchen_sink(),
+            nox=NoxConfig.create_kitchen_sink(),
+            doc=DocConfig.create_kitchen_sink(),
+            analysis=AnalysisConfig.create_kitchen_sink(),
+            publish=PublishConfig.create_kitchen_sink(),
+            skill=SkillConfig.create_kitchen_sink(),
+        )
+
 
 @dataclass(kw_only=True)
 class ProjectConfig:

pyprojkit-0.5.0/src/pyprojkit/config/tools.py

@@ -0,0 +1,247 @@
+"""
+Configurations for all supported tools.
+
+Formatters are tools which additionally run as part of the `format` task. Every field
+defaults to `None` (unset); each tool's opinionated settings are provided by its
+`create_kitchen_sink()`.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any, ClassVar, Self
+
+from .. import _paths
+from .base import BaseFormatterConfig, BaseToolConfig
+
+if TYPE_CHECKING:
+    from .project import ProjectConfig
+
+__all__ = [
+    "AutoflakeConfig",
+    "IsortConfig",
+    "BlackConfig",
+    "DocfmtConfig",
+    "TomlSortConfig",
+    "PytestConfig",
+    "CoverageRunConfig",
+    "CoverageReportConfig",
+    "DoitConfig",
+    "NoxConfig",
+    "MypyConfig",
+    "PyrightConfig",
+]
+
+
+# --- formatters (run order defined by FormattingConfig) ---
+
+
+@dataclass(kw_only=True)
+class AutoflakeConfig(BaseFormatterConfig):
+    table_path: ClassVar[str] = "tool.autoflake"
+
+    in_place: bool | None = None
+    recursive: bool | None = None
+    remove_all_unused_imports: bool | None = field(
+        default=None, metadata={"toml": "remove-all-unused-imports"}
+    )
+    remove_unused_variables: bool | None = field(
+        default=None, metadata={"toml": "remove-unused-variables"}
+    )
+
+    @classmethod
+    def create_kitchen_sink(cls) -> Self:
+        return cls(
+            in_place=True,
+            recursive=True,
+            remove_all_unused_imports=True,
+            remove_unused_variables=True,
+        )
+
+    def command(self, py_paths: list[str], toml_paths: list[str]) -> list[str]:
+        return ["autoflake"] + py_paths
+
+
+@dataclass(kw_only=True)
+class IsortConfig(BaseFormatterConfig):
+    table_path: ClassVar[str] = "tool.isort"
+
+    profile: str | None = None
+    quiet: bool | None = None
+
+    @classmethod
+    def create_kitchen_sink(cls) -> Self:
+        return cls(profile="black", quiet=True)
+
+    def command(self, py_paths: list[str], toml_paths: list[str]) -> list[str]:
+        return ["isort"] + py_paths
+
+
+@dataclass(kw_only=True)
+class BlackConfig(BaseFormatterConfig):
+    table_path: ClassVar[str] = "tool.black"
+
+    quiet: bool | None = None
+
+    @classmethod
+    def create_kitchen_sink(cls) -> Self:
+        return cls(quiet=True)
+
+    def extra_toml(self, project: ProjectConfig) -> dict[str, Any]:
+        versions = project.pinned_versions
+        if versions is None:
+            return {}
+        return {"target-version": [f"py{maj}{min}" for maj, min in versions.versions]}
+
+    def command(self, py_paths: list[str], toml_paths: list[str]) -> list[str]:
+        return ["black"] + py_paths
+
+
+@dataclass(kw_only=True)
+class DocfmtConfig(BaseFormatterConfig):
+    table_path: ClassVar[str] = "tool.docfmt"
+
+    # docfmt returns 0 when it writes changes in-place; 1 means "would change"
+    # in check mode and 2 is an error, so only 0 is expected here
+    expect_rc: ClassVar[frozenset[int]] = frozenset({0})
+
+    # line length is left unset: docfmt picks it up from `[tool.black]`
+    in_place: bool | None = field(default=None, metadata={"toml": "in-place"})
+    recursive: bool | None = None
+    summary_on_own_line: bool | None = field(
+        default=None, metadata={"toml": "summary-on-own-line"}
+    )
+    force_reflow: bool | None = field(default=None, metadata={"toml": "force-reflow"})
+
+    @classmethod
+    def create_kitchen_sink(cls) -> Self:
+        return cls(
+            in_place=True, recursive=True, summary_on_own_line=True, force_reflow=True
+        )
+
+    def command(self, py_paths: list[str], toml_paths: list[str]) -> list[str]:
+        return ["docfmt"] + py_paths
+
+
+@dataclass(kw_only=True)
+class TomlSortConfig(BaseFormatterConfig):
+    table_path: ClassVar[str] = "tool.tomlsort"
+
+    sort_first: tuple[str, ...] | None = None
+    sort_table_keys: bool | None = None
+
+    # the toml-sort CLI and library defaults disagree; when unset, the sync engine's
+    # normalization falls back to the CLI default so it agrees with the format task
+    spaces_before_inline_comment: int | None = None
+
+    @classmethod
+    def create_kitchen_sink(cls) -> Self:
+        return cls(
+            sort_first=("project", "dependency-groups", "build-system"),
+            sort_table_keys=True,
+            spaces_before_inline_comment=2,
+        )
+
+    def command(self, py_paths: list[str], toml_paths: list[str]) -> list[str]:
+        return ["toml-sort", "-i"] + toml_paths
+
+
+# --- non-formatter tools ---
+
+
+@dataclass(kw_only=True)
+class PytestConfig(BaseToolConfig):
+    table_path: ClassVar[str] = "tool.pytest.ini_options"
+
+    addopts: str | None = None
+    cache_dir: str | None = None
+    testpaths: str | None = None
+
+    @classmethod
+    def create_kitchen_sink(cls) -> Self:
+        return cls(
+            addopts="--import-mode=importlib -s -v -rA",
+            cache_dir=str(_paths.PYTEST_CACHE_PATH),
+            testpaths="test",
+        )
+
+
+@dataclass(kw_only=True)
+class CoverageRunConfig(BaseToolConfig):
+    table_path: ClassVar[str] = "tool.coverage.run"
+
+    data_file: str | None = None
+
+    @classmethod
+    def create_kitchen_sink(cls) -> Self:
+        return cls(data_file=str(_paths.COVERAGE_DATA_PATH))
+
+
+@dataclass(kw_only=True)
+class CoverageReportConfig(BaseToolConfig):
+    table_path: ClassVar[str] = "tool.coverage.report"
+
+    exclude_lines: tuple[str, ...] | None = None
+
+    @classmethod
+    def create_kitchen_sink(cls) -> Self:
+        return cls(exclude_lines=("if TYPE_CHECKING:", "\\.\\.\\.$"))
+
+
+@dataclass(kw_only=True)
+class DoitConfig(BaseToolConfig):
+    table_path: ClassVar[str] = "tool.doit"
+
+    dep_file: str | None = None
+    verbosity: int | None = None
+
+    @classmethod
+    def create_kitchen_sink(cls) -> Self:
+        return cls(dep_file=str(_paths.DOIT_DB_PATH), verbosity=2)
+
+
+@dataclass(kw_only=True)
+class NoxConfig(BaseToolConfig):
+    table_path: ClassVar[str] = "tool.nox"
+
+    default_venv_backend: str | None = None
+    envdir: str | None = None
+
+    @classmethod
+    def create_kitchen_sink(cls) -> Self:
+        return cls(default_venv_backend="uv", envdir=str(_paths.NOX_ENVDIR_PATH))
+
+
+@dataclass(kw_only=True)
+class MypyConfig(BaseToolConfig):
+    table_path: ClassVar[str] = "tool.mypy"
+
+    ignore_missing_imports: bool | None = None
+    check_untyped_defs: bool | None = None
+
+    @classmethod
+    def create_kitchen_sink(cls) -> Self:
+        return cls(ignore_missing_imports=True, check_untyped_defs=True)
+
+    def extra_toml(self, project: ProjectConfig) -> dict[str, Any]:
+        versions = project.pinned_versions
+        if versions is None:
+            return {}
+        maj, min = versions.versions[0]
+        return {"python_version": f"{maj}.{min}"}
+
+
+@dataclass(kw_only=True)
+class PyrightConfig(BaseToolConfig):
+    table_path: ClassVar[str] = "tool.pyright"
+
+    @classmethod
+    def create_kitchen_sink(cls) -> Self:
+        return cls()
+
+    def extra_toml(self, project: ProjectConfig) -> dict[str, Any]:
+        versions = project.pinned_versions
+        if versions is None:
+            return {}
+        maj, min = versions.versions[0]
+        return {"pythonVersion": f"{maj}.{min}"}

{pyprojkit-0.4.2 → pyprojkit-0.5.0}/src/pyprojkit/sessions.py

@@ -45,7 +45,7 @@ class NoxFactory:
     ):
         self._config = config or load_config(root)
         self._registered = set()
-        if nox_config := self._config.tools.nox:
+        if (nox_config := self._config.tools.nox) and nox_config.envdir is not None:
             nox.options.envdir = nox_config.envdir
 
     def create_test_session(self, *, group: str = "dev") -> Callable[[Session], None]:

{pyprojkit-0.4.2 → pyprojkit-0.5.0}/src/pyprojkit/sync.py

@@ -45,7 +45,7 @@ from tomlkit import TOMLDocument
 from tomlkit.items import AoT, Null, Table
 
 from ._run import run
-from .config.base import ConfigError
+from .config.base import BaseToolConfig, ConfigError
 from .config.project import ProjectConfig, SkillConfig
 from .config.tools import TomlSortConfig
 from .skill import SKILL_NAME, render_skill
@@ -70,25 +70,21 @@ def compute_managed_fields(config: ProjectConfig) -> dict[str, dict[str, Any]]:
     """
     Compute all managed fields, keyed by dotted table path then key.
     """
-    tables: dict[str, dict[str, Any]] = {}
+    tool_configs: list[BaseToolConfig] = []
     tools = config.tools
 
     if tools.formatting:
-        for formatter in tools.formatting.formatters:
-            tables[formatter.table_path] = formatter.to_toml(config)
+        tool_configs += tools.formatting.formatters
 
     if test := tools.test:
-        for test_tool in (test.pytest, test.coverage_run, test.coverage_report):
-            tables[test_tool.table_path] = test_tool.to_toml(config)
+        tool_configs += [test.pytest, test.coverage_run, test.coverage_report]
 
-    for runner in (tools.doit, tools.nox):
-        if runner:
-            tables[runner.table_path] = runner.to_toml(config)
+    tool_configs += [t for t in (tools.doit, tools.nox) if t]
 
-    if (analysis := tools.analysis) and analysis.mypy:
-        tables[analysis.mypy.table_path] = analysis.mypy.to_toml(config)
+    if analysis := tools.analysis:
+        tool_configs += [t for t in (analysis.mypy, analysis.pyright) if t]
 
-    return tables
+    return {t.table_path: t.to_toml(config) for t in tool_configs}
 
 
 def render(config: ProjectConfig, text: str) -> str:

{pyprojkit-0.4.2 → pyprojkit-0.5.0}/src/pyprojkit/tasks.py

@@ -347,7 +347,7 @@ class TaskFactory:
         Create `publish` task which builds and publishes the package via uv.
         """
         publish = self._require(self._config.tools.publish, "tools.publish")
-        out_dir = Path(publish.out_dir)
+        out_dir = Path(publish.out_dir or "dist")
 
         def _publish():
             artifacts = [str(p) for p in sorted(out_dir.iterdir())]

pyprojkit-0.4.2/src/pyprojkit/config/profiles.py

@@ -1,69 +0,0 @@
-"""
-Built-in tool configurations.
-
-Configurations are plain `ToolsConfig` values: define your own factory function or
-global in a module shared across projects, optionally building on
-`create_kitchen_sink_tools()`:
-
-```python
-from dataclasses import replace
-
-from pyprojkit import AnalysisConfig, ToolsConfig, create_kitchen_sink_tools
-
-
-def create_mycompany_tools() -> ToolsConfig:
-    return replace(create_kitchen_sink_tools(), analysis=AnalysisConfig())
-```
-"""
-
-from __future__ import annotations
-
-from .project import (
-    AnalysisConfig,
-    DocConfig,
-    FormattingConfig,
-    PublishConfig,
-    SkillConfig,
-    TestConfig,
-    ToolsConfig,
-)
-from .tools import (
-    AutoflakeConfig,
-    BlackConfig,
-    DocfmtConfig,
-    DoitConfig,
-    IsortConfig,
-    NoxConfig,
-    TomlSortConfig,
-)
-
-__all__ = [
-    "create_kitchen_sink_tools",
-]
-
-
-def create_kitchen_sink_tools() -> ToolsConfig:
-    """
-    Get a new instance of the configuration which enables every tool: uv as the workflow
-    tool, formatting, testing, doit, nox, mkinit, static analysis, publishing and the
-    agent skill. Sphinx is left disabled since it needs project-specific settings.
-    """
-    return ToolsConfig(
-        workflow_tool="uv",
-        formatting=FormattingConfig(
-            formatters=(
-                AutoflakeConfig(),
-                IsortConfig(),
-                DocfmtConfig(),
-                BlackConfig(),
-                TomlSortConfig(),
-            )
-        ),
-        test=TestConfig(),
-        doit=DoitConfig(),
-        nox=NoxConfig(),
-        doc=DocConfig(),
-        analysis=AnalysisConfig(),
-        publish=PublishConfig(),
-        skill=SkillConfig(),
-    )

pyprojkit-0.4.2/src/pyprojkit/config/tools.py

@@ -1,175 +0,0 @@
-"""
-Configurations for all supported tools.
-
-Formatters are tools which additionally run as part of the `format` task.
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Any, ClassVar
-
-from .. import _paths
-from .base import BaseFormatterConfig, BaseToolConfig
-
-if TYPE_CHECKING:
-    from .project import ProjectConfig
-
-__all__ = [
-    "AutoflakeConfig",
-    "IsortConfig",
-    "BlackConfig",
-    "DocfmtConfig",
-    "TomlSortConfig",
-    "PytestConfig",
-    "CoverageRunConfig",
-    "CoverageReportConfig",
-    "DoitConfig",
-    "NoxConfig",
-    "MypyConfig",
-]
-
-
-# --- formatters (run order defined by FormattingConfig) ---
-
-
-@dataclass(kw_only=True)
-class AutoflakeConfig(BaseFormatterConfig):
-    table_path: ClassVar[str] = "tool.autoflake"
-
-    in_place: bool | None = True
-    recursive: bool | None = True
-    remove_all_unused_imports: bool | None = field(
-        default=True, metadata={"toml": "remove-all-unused-imports"}
-    )
-    remove_unused_variables: bool | None = field(
-        default=True, metadata={"toml": "remove-unused-variables"}
-    )
-
-    def command(self, py_paths: list[str], toml_paths: list[str]) -> list[str]:
-        return ["autoflake"] + py_paths
-
-
-@dataclass(kw_only=True)
-class IsortConfig(BaseFormatterConfig):
-    table_path: ClassVar[str] = "tool.isort"
-
-    profile: str | None = "black"
-    quiet: bool | None = True
-
-    def command(self, py_paths: list[str], toml_paths: list[str]) -> list[str]:
-        return ["isort"] + py_paths
-
-
-@dataclass(kw_only=True)
-class BlackConfig(BaseFormatterConfig):
-    table_path: ClassVar[str] = "tool.black"
-
-    quiet: bool | None = True
-
-    def extra_toml(self, project: ProjectConfig) -> dict[str, Any]:
-        versions = project.pinned_versions
-        if versions is None:
-            return {}
-        return {"target-version": [f"py{maj}{min}" for maj, min in versions.versions]}
-
-    def command(self, py_paths: list[str], toml_paths: list[str]) -> list[str]:
-        return ["black"] + py_paths
-
-
-@dataclass(kw_only=True)
-class DocfmtConfig(BaseFormatterConfig):
-    table_path: ClassVar[str] = "tool.docfmt"
-
-    # docfmt returns 0 when it writes changes in-place; 1 means "would change"
-    # in check mode and 2 is an error, so only 0 is expected here
-    expect_rc: ClassVar[frozenset[int]] = frozenset({0})
-
-    # line length is left unset: docfmt picks it up from `[tool.black]`
-    in_place: bool | None = field(default=True, metadata={"toml": "in-place"})
-    recursive: bool | None = True
-    summary_on_own_line: bool | None = field(
-        default=True, metadata={"toml": "summary-on-own-line"}
-    )
-    force_reflow: bool | None = field(default=True, metadata={"toml": "force-reflow"})
-
-    def command(self, py_paths: list[str], toml_paths: list[str]) -> list[str]:
-        return ["docfmt"] + py_paths
-
-
-@dataclass(kw_only=True)
-class TomlSortConfig(BaseFormatterConfig):
-    table_path: ClassVar[str] = "tool.tomlsort"
-
-    sort_first: tuple[str, ...] | None = (
-        "project",
-        "dependency-groups",
-        "build-system",
-    )
-    sort_table_keys: bool | None = True
-
-    # explicit since the toml-sort CLI and library defaults disagree; must be
-    # pinned so the sync engine's normalization and the format task agree
-    spaces_before_inline_comment: int | None = 2
-
-    def command(self, py_paths: list[str], toml_paths: list[str]) -> list[str]:
-        return ["toml-sort", "-i"] + toml_paths
-
-
-# --- non-formatter tools ---
-
-
-@dataclass(kw_only=True)
-class PytestConfig(BaseToolConfig):
-    table_path: ClassVar[str] = "tool.pytest.ini_options"
-
-    addopts: str | None = "--import-mode=importlib -s -v -rA"
-    cache_dir: str | None = str(_paths.PYTEST_CACHE_PATH)
-    testpaths: str | None = "test"
-
-
-@dataclass(kw_only=True)
-class CoverageRunConfig(BaseToolConfig):
-    table_path: ClassVar[str] = "tool.coverage.run"
-
-    data_file: str | None = str(_paths.COVERAGE_DATA_PATH)
-
-
-@dataclass(kw_only=True)
-class CoverageReportConfig(BaseToolConfig):
-    table_path: ClassVar[str] = "tool.coverage.report"
-
-    exclude_lines: tuple[str, ...] | None = (
-        "if TYPE_CHECKING:",
-        "\\.\\.\\.$",
-    )
-
-
-@dataclass(kw_only=True)
-class DoitConfig(BaseToolConfig):
-    table_path: ClassVar[str] = "tool.doit"
-
-    dep_file: str | None = str(_paths.DOIT_DB_PATH)
-    verbosity: int | None = 2
-
-
-@dataclass(kw_only=True)
-class NoxConfig(BaseToolConfig):
-    table_path: ClassVar[str] = "tool.nox"
-
-    default_venv_backend: str | None = "uv"
-    envdir: str | None = str(_paths.NOX_ENVDIR_PATH)
-
-
-@dataclass(kw_only=True)
-class MypyConfig(BaseToolConfig):
-    table_path: ClassVar[str] = "tool.mypy"
-
-    ignore_missing_imports: bool | None = True
-
-    def extra_toml(self, project: ProjectConfig) -> dict[str, Any]:
-        versions = project.pinned_versions
-        if versions is None:
-            return {}
-        maj, min = versions.versions[0]
-        return {"python_version": f"{maj}.{min}"}