update source

src/controlman/_util/jsonschema.py

@@ -55,7 +55,8 @@ def _make_registry():
                 if key in added_keys:
                     raise RuntimeError(f"Duplicate schema key '{key}'")
                 added_keys.append(key)
-                ref_resources.append((key, schema_dict))
+                schema_pared = _referencing.Resource.from_contents(schema_dict)
+                ref_resources.append((key, schema_pared))
             else:
                 for def_schema_key, def_schema in schema_dict.items():
                     if def_schema_key in added_keys:

src/controlman/center_man/file_comparer.py

@@ -1,5 +1,4 @@
-"""
-Writer
+"""Writer
 """
 
 from pathlib import Path
@@ -10,7 +9,7 @@
 from markitup import html, md
 
 from controlman.datatype import DynamicFile, DynamicFileType, DynamicFileChangeType, Diff
-
+from controlman.datatype import DynamicFile_, GeneratedFile
 
 class FileComparer:
     def __init__(self, path_root: str | Path):
@@ -61,6 +60,28 @@ def _compare_file(self, path: Path, content: str) -> Diff:
             )
         return Diff(status=status, before=before, after=content)
 
+    def compare(self, file: GeneratedFile):
+        if not file.content:
+            if not file.path_before:
+                return DynamicFileChangeType.DISABLED
+            filepath_before = self.path_root/file.path_before
+            if filepath_before.is_file():
+                return DynamicFileChangeType.REMOVED
+            return DynamicFileChangeType.DISABLED
+        if not file.path:
+            return DynamicFileChangeType.DISABLED
+        if not file.path_before:
+            return DynamicFileChangeType.CREATED
+        fullpath_before = self.path_root/file.path_before
+        if not fullpath_before.is_file():
+            return DynamicFileChangeType.CREATED
+        with open(self.path_root/file.path_before) as f:
+            content_before = f.read()
+        if file.content.strip() == content_before.strip():
+            return DynamicFileChangeType.UNCHANGED
+        return DynamicFileChangeType.MODIFIED
+
+
     def _compare_file_multiloc(self, path: Path, alt_paths: list[Path], content: str) -> Diff:
         alts = self._remove_alts(alt_paths)
         main = self._compare_file(path, content)
@@ -185,3 +206,5 @@ def _item_summary(info: DynamicFile, diff: Diff) -> html.DETAILS:
             details_.append(html.details(content=md.code_block(diff, "diff"), summary="Content"))
         details.append(html.ul(details_))
         return output
+
+

src/controlman/center_man/manager.py

@@ -24,7 +24,6 @@
 from controlman import _util
 from controlman import exception as _exception
 from controlman.center_man.cache import CacheManager
-from controlman._path_manager import PathManager as _PathManager
 from controlman.nested_dict import NestedDict as _NestedDict
 
 
@@ -55,24 +54,19 @@ def __init__(
         self._results: list[tuple[_DynamicFile, _Diff]] = []
         self._changes: dict[_DynamicFileType, dict[str, bool]] = {}
         self._summary: str = ""
-
-        self._path_manager = _PathManager(repo_path=self._path_root)
         return
 
-    @property
-    def path_manager(self) -> _PathManager:
-        return self._path_manager
-
     def load(self) -> _NestedDict:
         if self._contents_raw:
             return self._contents_raw
         if not self._path_cc:
             self._data_before = controlman.data_man.from_json_file(repo_path=self._path_root).dict
-            self._path_cc = self._data_before["dir.control"]
+            self._path_cc = self._path_root / self._data_before["dir.control"]
             cache_retention_hours = self._data_before["control.cache.retention_hours"]
         else:
             self._data_before = _NestedDict(data={})
-            cache_retention_hours = {"api": 0, "extensions": 0}
+            self._path_cc = self._path_root / self._path_cc
+            cache_retention_hours = {k: 0 for k in ("extension", "repo", "user", "orcid", "doi", "python")}
         self._hook_manager = _HookManager(
             dir_path=self._path_root / self._path_cc / const.DIRNAME_CC_HOOK
         )
@@ -126,6 +120,12 @@ def generate_data(self) -> _DataManager:
                 data=data,
                 website_dir_path=self._path_root / website_path,
             ).generate()
+        _data_gen.RepoDataGenerator(
+            data=data,
+            git_manager=self._git,
+            data_main=self._data_main,
+            future_versions=self._future_vers,
+        ).generate()
         if self._hook_manager.has_hook(const.FUNCNAME_CC_HOOK_POST_DATA):
             self._hook_manager.generate(
                 const.FUNCNAME_CC_HOOK_POST_DATA,
@@ -150,7 +150,6 @@ def generate_files(self) -> list[tuple[_DynamicFile, str]]:
 
     def generate(
         content_manager: _DataManager,
-        path_manager: _PathManager,
         custom_generator: _HookManager,
     ) -> list[tuple[_DynamicFile, str]]:
         return _generator.generate(content_manager=content_manager, path_manager=path_manager,

src/controlman/const.py

@@ -4,6 +4,7 @@
 """
 
 
+# ControlMan Constants
 DIRPATH_CC_DEFAULT = ".control"
 
 FILEPATH_METADATA = ".github/.control/.metadata.json"
@@ -20,19 +21,29 @@
 
 CC_EXTENSION_TAG = u"!ext"
 
+# GitHub Constants
+DIRPATH_ISSUES = ".github/ISSUE_TEMPLATE"
+FILEPATH_ISSUES_CONFIG = f"{DIRPATH_ISSUES}/config.yml"
+FILEPATH_FUNDING_CONFIG = ".github/FUNDING.yml"
+FILEPATH_CITATION_CONFIG = "CITATION.cff"
+DIRPATH_DISCUSSIONS = ".github/DISCUSSION_TEMPLATE"
+FILEPATH_PULL_TEMPLATE_MAIN = ".github/PULL_REQUEST_TEMPLATE.md"
+DIRPATH_PULL_TEMPLATES = ".github/PULL_REQUEST_TEMPLATE"
 
+# Git Constants
+FILEPATH_GITIGNORE = ".gitignore"
+FILEPATH_GIT_ATTRIBUTES = ".gitattributes"
 
+# Python Constants
+FILENAME_PACKAGE_TYPING_MARKER = "py.typed"
+FILEPATH_PACKAGE_ENV_CONDA = "environment.yaml"
+FILEPATH_PACKAGE_ENV_PIP = "requirements.txt"
+FILENAME_PACKAGE_MANIFEST = "MANIFEST.in"
+FILENAME_PKG_PYPROJECT = "pyproject.toml"
 
 
-FILE_ISSUE_TEMPLATE_CHOOSER_CONFIG = ".github/ISSUE_TEMPLATE/config.yml"
-FILE_PYTHON_PYPROJECT = "pyproject.toml"
 FILE_PYTHON_REQUIREMENTS = "requirements.txt"
-FILE_PYTHON_MANIFEST = "MANIFEST.in"
-FILE_GITIGNORE = ".gitignore"
-FILE_GITATTRIBUTES = ".gitattributes"
+
 DIR_GITHUB = ".github/"
 DIR_GITHUB_WORKFLOWS = ".github/workflows/"
 DIR_GITHUB_WORKFLOW_REQUIREMENTS = ".github/workflow_requirements/"
-DIR_GITHUB_ISSUE_TEMPLATE = ".github/ISSUE_TEMPLATE/"
-DIR_GITHUB_PULL_REQUEST_TEMPLATE = ".github/PULL_REQUEST_TEMPLATE/"
-DIR_GITHUB_DISCUSSION_TEMPLATE = ".github/DISCUSSION_TEMPLATE/"

src/controlman/data_gen/__init__.py

@@ -1,3 +1,4 @@
 from controlman.data_gen.main import MainDataGenerator
 from controlman.data_gen.python import PythonDataGenerator
 from controlman.data_gen.web import WebDataGenerator
+from controlman.data_gen.repo import RepoDataGenerator

src/controlman/data_gen/main.py

@@ -8,11 +8,9 @@
 from loggerman import logger as _logger
 
 from controlman import _util
-from controlman._path_manager import PathManager
 from controlman.nested_dict import NestedDict as _NestedDict
 from controlman.center_man.cache import CacheManager
 from controlman.protocol import Git as _Git
-from controlman.center_man.hook import HookManager
 from controlman import exception as _exception
 
 
@@ -103,19 +101,19 @@ def _name(self) -> None:
             _logger.info(f"Set from repository name: {name}")
         return
 
-    @_logger.sectioner("Keyword Slugs")
+    @_logger.sectioner("GitHub Topics")
     def _keywords(self) -> None:
-        if self._data["keywords.slug"]:
-            _logger.info("Already set manually.")
+        if not self._data["repo.topics"]:
+            _logger.info("No GitHub topics specified.")
             return
-        if not self._data["keywords.display"]:
-            _logger.info("No keywords specified.")
-            return
-        slugs = self._data.setdefault("keywords.slug", [])
-        keywords = self._data.fill("keywords.display")
+        keywords = self._data.fill("repo.topics")
+        slugs = []
         for keyword in keywords:
+            if len(slugs) >= 20:
+                break
             if len(keyword) <= 50:
                 slugs.append(_miu.txt.slug(keyword))
+        self._data["repo.topics"] = slugs
         _logger.info("Set from keywords.")
         _logger.debug("Keyword slugs:", code=str(slugs))
         return
@@ -285,7 +283,7 @@ def make_name():
             if "suffix" in data["name"]:
                 full_name += f', {data["name"]["suffix"]}'
             data["name"]["full"] = full_name
-        if "orcid" in data and data["orcid"]["get_pubs"]:
+        if "orcid" in data and data["orcid"].get("get_pubs"):
             data["orcid"]["pubs"] = self._get_orcid_publications(orcid_id=data["orcid"]["user"])
         return
 
@@ -296,7 +294,7 @@ def add_social(name, user, url):
             socials[name] = {"user": user, "url": url}
             return
 
-        user_info = self._cache.get(f"github_user__{username}")
+        user_info = self._cache.get("user", username)
         if user_info:
             _logger.section_end()
             return user_info
@@ -332,7 +330,7 @@ def add_social(name, user, url):
                     generics.append(account["url"])
                     _logger.info(title=f"Unknown account", msg=account['url'])
         _logger.section_end()
-        self._cache.set(f"github_user__{username}", user_info)
+        self._cache.set("user", username, user_info)
         return user_info
 
     @_logger.sectioner("Get Publications")

src/controlman/data_gen/repo.py

@@ -122,7 +122,7 @@ def _package_releases(self) -> None:
     @_logger.sectioner("Repository Labels")
     def _repo_labels(self) -> None:
         out = []
-        for label_type in ("primary", "secondary", "status"):
+        for label_type in ("type", "subtype", "status"):
             group = self._data.get(f"label.{label_type}", {})
             if not group:
                 continue

src/controlman/data_man/manager.py

@@ -29,7 +29,7 @@ def __init__(self, data: _NestedDict):
         return
 
     @property
-    def dict(self) -> _NestedDict:
+    def ndict(self) -> _NestedDict:
         return self._data
 
     @property

src/controlman/datatype.py

@@ -60,6 +60,41 @@ class DynamicFileType(_Enum):
     FORM = "Forms"
 
 
+class DynamicFile_(_Enum):
+    GITHUB_FUNDING = (DynamicFileType.CONFIG, "GitHub funding options configurations")
+    GITHUB_CITATION = (DynamicFileType.HEALTH, "GitHub citation configurations")
+    GITHUB_ISSUES_CONFIG = (DynamicFileType.CONFIG, "GitHub Issues template chooser configurations")
+    GITHUB_ISSUE_FORM = (DynamicFileType.FORM, "GitHub Issue forms")
+    GITHUB_DISCUSSION_FORM = (DynamicFileType.FORM, "GitHub Discussion forms")
+    GITHUB_PULL_TEMPLATE = (DynamicFileType.FORM, "GitHub Pull Request templates")
+    GIT_IGNORE = (DynamicFileType.CONFIG, "Git ignore file")
+    GIT_ATTRIBUTES = (DynamicFileType.CONFIG, "Git attributes file")
+    WEB_ENV_CONDA = (DynamicFileType.CONFIG, "Website build environment file (conda)")
+    WEB_ENV_PIP = (DynamicFileType.CONFIG, "Website build environment file (pip)")
+    TOOL_ENV_CONDA = (DynamicFileType.CONFIG, "Tool build environment file (conda)")
+    TOOL_ENV_PIP = (DynamicFileType.CONFIG, "Tool build environment file (pip)")
+    TOOL_CONFIG = (DynamicFileType.CONFIG, "Tool configuration file")
+    PKG_TYPING_MARKER = (DynamicFileType.PACKAGE, "Package typing marker file")
+    PKG_ENV_CONDA = (DynamicFileType.PACKAGE, "Package environment file (conda)")
+    PKG_ENV_PIP = (DynamicFileType.PACKAGE, "Package environment file (pip)")
+    PKG_MANIFEST = (DynamicFileType.PACKAGE, "Package manifest file")
+    PKG_PYPROJECT = (DynamicFileType.PACKAGE, "Package pyproject file")
+    PKG_SOURCE = (DynamicFileType.PACKAGE, "Package source file")
+    TEST_TYPING_MARKER = (DynamicFileType.PACKAGE, "Test suite typing marker file")
+    TEST_ENV_CONDA = (DynamicFileType.PACKAGE, "Test suite environment file (conda)")
+    TEST_ENV_PIP = (DynamicFileType.PACKAGE, "Test suite environment file (pip)")
+    TEST_MANIFEST = (DynamicFileType.PACKAGE, "Test suite manifest file")
+    TEST_PYPROJECT = (DynamicFileType.PACKAGE, "Test suite pyproject file")
+    TEST_SOURCE = (DynamicFileType.PACKAGE, "Test suite source file")
+
+
+class GeneratedFile(_NamedTuple):
+    type: DynamicFile_ | tuple[DynamicFile_, str]
+    content: str | None = None
+    path: str | None = None
+    path_before: str | None = None
+
+
 class DynamicFile(_NamedTuple):
     id: str
     category: DynamicFileType