pyOpenSourceProjects 0.5.1__tar.gz → 0.6.0__tar.gz

{pyopensourceprojects-0.5.1 → pyopensourceprojects-0.6.0}/AGENTS.md

@@ -162,7 +162,32 @@ except requests.RequestException as e:
 def process_items(items: list[dict], filter_key: str) -> Optional[list[str]]:
     """Process items and return filtered values."""
     values = [item.get(filter_key) for item in items if filter_key in item]
-    return values if values else None
+    result = values if values else None
+    return result
+```
+
+### Return Style
+
+- Never return expressions directly; always assign to a variable first
+- Avoid multiple return statements; use a single `return` at the end
+- Use a result variable and set it conditionally:
+```python
+# correct
+def get_value(flag: bool) -> Optional[str]:
+    result = None
+    if flag:
+        result = "yes"
+    return result
+
+# wrong - return expression
+def get_value(flag: bool) -> Optional[str]:
+    return "yes" if flag else None
+
+# wrong - multiple returns
+def get_value(flag: bool) -> Optional[str]:
+    if not flag:
+        return None
+    return "yes"
 ```
 
 ## Version Bumping
@@ -187,12 +212,12 @@ Then run formatters, tests, commit and push (or use `scripts/release`).
 
 ## Git Workflow
 
-1. Create a feature branch
+1. Read issue to work on
 2. Make changes following the code style guidelines
 3. Run formatters: `./scripts/blackisort`
 4. Run tests: `./scripts/test`
 5. Commit with a descriptive message
-6. Push and create a pull request
+6. Push
 
 ## Release
 

{pyopensourceprojects-0.5.1 → pyopensourceprojects-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyOpenSourceProjects
-Version: 0.5.1
+Version: 0.6.0
 Summary: Check python OpenSource Projects to follow standards for README, github workflow and pyprojec.toml - creates badges
 Project-URL: Home, https://github.com/WolfgangFahl/pyOpenSourceProjects
 Project-URL: Documentation, http://wiki.bitplan.com/index.php/pyOpenSourceProjects
@@ -20,6 +20,7 @@ Requires-Dist: beautifulsoup4>=4.14.2
 Requires-Dist: gitpython
 Requires-Dist: packaging>=24.1
 Requires-Dist: py-3rdparty-mediawiki>=0.18.1
+Requires-Dist: pybasemkit>=0.2.2
 Requires-Dist: pylodstorage>=0.17.0
 Requires-Dist: python-dateutil>=2.8.2
 Requires-Dist: ratelimit>=2.2.1

pyopensourceprojects-0.6.0/osprojects/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.6.0"

pyopensourceprojects-0.6.0/osprojects/git_api.py

@@ -0,0 +1,79 @@
+"""Created on 2026-03-16.
+
+@author: wf
+"""
+
+import re
+from dataclasses import dataclass
+from typing import Dict, List, Optional
+
+
+@dataclass
+class GenericRepo:
+    """Represents a generic git repository hosted on any forge.
+
+    Parses owner and project_id from any standard git remote URL
+    (SSH: git@host:owner/repo.git or HTTPS: https://host/owner/repo.git).
+
+    Attributes:
+        owner (str): The owner of the repository.
+        project_id (str): The name/id of the repository.
+        url (str): The original remote URL.
+    """
+
+    owner: str
+    project_id: str
+    url: str
+
+    @classmethod
+    def from_url(cls, url: str) -> Optional["GenericRepo"]:
+        """Parse owner and project_id from any standard git remote URL.
+
+        Args:
+            url: SSH or HTTPS git remote URL.
+
+        Returns:
+            GenericRepo instance or None if the URL cannot be parsed.
+        """
+        # Match HTTPS: https://host/owner/repo
+        https_pattern = r"https?://[^/]+/(?P<owner>[^/]+)/(?P<project_id>[^/.]+)"
+        match = re.match(https_pattern, url)
+
+        if not match:
+            # Match SSH: [user@]host:path - extract last two path components as owner/repo
+            ssh_pattern = r"(?:[^@]+@)?[^:]+:(?P<path>.+?)(?:\.git)?$"
+            ssh_match = re.match(ssh_pattern, url)
+            if ssh_match:
+                path = ssh_match.group("path")
+                # Split path and take last two components
+                parts = [p for p in path.split("/") if p]
+                if len(parts) >= 2:
+                    owner = parts[-2]
+                    project_id = parts[-1]
+                    repo = cls(owner=owner, project_id=project_id, url=url)
+                    return repo
+
+        repo = None
+        if match:
+            repo = cls(
+                owner=match.group("owner"),
+                project_id=match.group("project_id"),
+                url=url,
+            )
+        return repo
+
+    def projectUrl(self) -> str:
+        """Return a browsable HTTPS project URL derived from the remote URL."""
+        # Match SSH URLs: user@host:path or host:path
+        ssh = re.match(r"(?:[^@]+@)?(?P<host>[^:]+):(?P<path>.+?)(?:\.git)?$", self.url)
+        if ssh:
+            url = f"https://{ssh.group('host')}/{ssh.group('path')}"
+        else:
+            url = re.sub(r"\.git$", "", self.url)
+        return url
+
+    def getIssueRecords(self, limit: int = None, **params) -> List[Dict]:
+        """Not implemented for generic repos."""
+        raise NotImplementedError(
+            f"getIssueRecords is not supported for generic repo '{self.projectUrl()}'"
+        )

{pyopensourceprojects-0.5.1 → pyopensourceprojects-0.6.0}/osprojects/github_api.py

@@ -25,6 +25,8 @@ from backoff import expo, on_exception
 from basemkit.yamlable import lod_storable
 from ratelimit import RateLimitException, limits
 
+from osprojects.git_api import GenericRepo
+
 
 class GitHubApi:
     """
@@ -96,9 +98,8 @@ class GitHubApi:
 
         if response.status_code == 302 and not allow_redirects:
             # Return the redirect URL if we're not following redirects
-            return response.headers["Location"]
-
-        if response.status_code not in [200, 302]:
+            result = response.headers["Location"]
+        elif response.status_code not in [200, 302]:
             err_msg = (
                 f"Failed to {title} for {url}: {response.status_code} - {response.text}"
             )
@@ -106,8 +107,9 @@ class GitHubApi:
             if response.status_code in [403, 429]:
                 raise RateLimitException(err_msg, period_remaining=60)
             raise Exception(err_msg)
-
-        return response
+        else:
+            result = response
+        return result
 
     def repos_for_owner(self, owner: str, cache_expiry: int = 300) -> list[dict]:
         """Retrieve all repositories for the given owner, using cache if
@@ -130,14 +132,14 @@ class GitHubApi:
         if cache_content is not None and (
             cache_age is None or cache_age < cache_expiry
         ):
-            return cache_content
-
-        # If cache is not available or expired, retrieve from API
-        repos = self.repos_for_owner_via_api(owner)
+            repos = cache_content
+        else:
+            # If cache is not available or expired, retrieve from API
+            repos = self.repos_for_owner_via_api(owner)
 
-        # Cache the result
-        with open(cache_file, "w") as f:
-            json.dump(repos, f)
+            # Cache the result
+            with open(cache_file, "w") as f:
+                json.dump(repos, f)
 
         return repos
 
@@ -200,28 +202,28 @@ class GitHubApi:
 
 
 @dataclass
-class GitHubRepo:
+class GitHubRepo(GenericRepo):
     """Represents a GitHub Repository.
 
     Attributes:
         owner (str): The owner of the repository.
         project_id (str): The name/id of the repository.
+        url (str): The original remote URL.
     """
 
-    owner: str
-    project_id: str
-
     def __post_init__(self):
         self.github = GitHubApi.get_instance()
 
     @classmethod
-    def from_url(cls, url: str) -> (str, str):
-        """Resolve project url to owner and project name.
+    def from_url(cls, url: str) -> "GitHubRepo":
+        """Resolve GitHub project url to owner and project name.
+
+        Args:
+            url: SSH or HTTPS GitHub remote URL.
 
         Returns:
-            (owner, project)
+            GitHubRepo instance or None if the URL cannot be parsed.
         """
-        # https://www.rfc-editor.org/rfc/rfc3986#appendix-B
         pattern = r"((https?:\/\/github\.com\/)|(git@github\.com:))(?P<owner>[^/?#]+)\/(?P<project_id>[^\./?#]+)(\.git)?"
         match = re.match(pattern=pattern, string=url)
         repo = None
@@ -229,17 +231,13 @@ class GitHubRepo:
             owner = match.group("owner")
             project_id = match.group("project_id")
             if owner and project_id:
-                repo = cls(owner=owner, project_id=project_id)
-            else:
-                pass
-        else:
-            pass
+                repo = cls(owner=owner, project_id=project_id, url=url)
         return repo
 
     def ticketUrl(self):
         return f"{self.github.api_url}/repos/{self.owner}/{self.project_id}/issues"
 
-    def projectUrl(self):
+    def projectUrl(self) -> str:
         return f"https://github.com/{self.owner}/{self.project_id}"
 
     def getIssueRecords(self, limit: int = None, **params) -> List[Dict]:
@@ -306,7 +304,6 @@ class GitHubFileSet:
 
         # Deduplication check
         if sha and not sha in self._sha_set:
-
             # Extract fields
             repo_info = api_item.get("repository", {})
 
@@ -433,7 +430,10 @@ class GitHubAction:
             raise ValueError("Invalid GitHub Actions URL format")
 
         try:
-            repo = GitHubRepo(owner=path_parts[1], project_id=path_parts[2])
+            owner = path_parts[1]
+            project_id = path_parts[2]
+            repo_url = f"https://github.com/{owner}/{project_id}"
+            repo = GitHubRepo(owner=owner, project_id=project_id, url=repo_url)
             return cls(repo=repo, run_id=int(path_parts[5]), job_id=int(path_parts[7]))
         except (IndexError, ValueError) as e:
             raise ValueError(f"Failed to parse GitHub Actions URL: {e}")

pyopensourceprojects-0.6.0/osprojects/gitlab_api.py

@@ -0,0 +1,44 @@
+"""Created on 2026-03-16.
+
+@author: wf
+"""
+
+import re
+from dataclasses import dataclass
+from typing import Optional
+
+from osprojects.git_api import GenericRepo
+
+
+@dataclass
+class GitLabRepo(GenericRepo):
+    """Represents a GitLab repository.
+
+    Attributes:
+        owner (str): The owner/namespace of the repository.
+        project_id (str): The name/id of the repository.
+        url (str): The original remote URL.
+    """
+
+    @classmethod
+    def from_url(cls, url: str) -> Optional["GitLabRepo"]:
+        """Parse owner and project_id from a GitLab remote URL.
+
+        Args:
+            url: SSH or HTTPS GitLab remote URL.
+
+        Returns:
+            GitLabRepo instance or None if the URL cannot be parsed.
+        """
+        pattern = (
+            r"(?:https?://[^/]+/|git@[^:]+:)(?P<owner>[^/]+)/(?P<project_id>[^/.]+)"
+        )
+        match = re.match(pattern, url)
+        repo = None
+        if match:
+            repo = cls(
+                owner=match.group("owner"),
+                project_id=match.group("project_id"),
+                url=url,
+            )
+        return repo

{pyopensourceprojects-0.5.1 → pyopensourceprojects-0.6.0}/osprojects/osproject.py

@@ -13,10 +13,13 @@ import subprocess
 import sys
 from typing import Dict, Iterable, List, Optional, Set, Tuple
 
+from basemkit.base_cmd import BaseCmd
 from dateutil.parser import parse
 from tqdm import tqdm
 
+from osprojects.git_api import GenericRepo
 from osprojects.github_api import GitHubApi, GitHubRepo
+from osprojects.gitlab_api import GitLabRepo
 
 
 class Ticket(object):
@@ -327,16 +330,24 @@ class OsProject:
         self.repo_info = None  # might be fetched
         self.folder = None  # set for local projects
         if owner and project_id:
-            self.repo = GitHubRepo(owner=owner, project_id=project_id)
+            url = f"https://github.com/{owner}/{project_id}"
+            self.repo = GitHubRepo(owner=owner, project_id=project_id, url=url)
 
     @classmethod
     def fromUrl(cls, url: str) -> "OsProject":
-        """Init OsProject from given url."""
+        """Init OsProject from given url.
+
+        Selects the appropriate repo class based on the remote URL host:
+        GitHubRepo for github.com, GitLabRepo for gitlab hosts,
+        GenericRepo for everything else.
+        """
+        os_project = cls()
         if "github.com" in url:
-            os_project = cls()
             os_project.repo = GitHubRepo.from_url(url)
+        elif "gitlab" in url:
+            os_project.repo = GitLabRepo.from_url(url)
         else:
-            raise Exception(f"url '{url}' is not a github.com url ")
+            os_project.repo = GenericRepo.from_url(url)
         return os_project
 
     @classmethod
@@ -501,22 +512,18 @@ class OsProject:
             "--no-pager",
             "log",
             "--reverse",
-            r'--pretty=format:{"name":"%cn","date":"%cI","hash":"%h"}',
+            r'--pretty=format:{"name":"%cn","date":"%cI","hash":"%h","subject":"%s"}',
         ]
-        gitLogCommitSubject = ["git", "log", "--format=%s", "-n", "1"]
         rawCommitLogs = subprocess.check_output(gitlogCmd).decode()
         for rawLog in rawCommitLogs.split("\n"):
+            if not rawLog.strip():
+                continue
             log = json.loads(rawLog)
             if log.get("date", None) is not None:
                 log["date"] = datetime.datetime.fromisoformat(log["date"])
             log["project"] = self.project_id
             log["host"] = self.projectUrl()
             log["path"] = ""
-            log["subject"] = subprocess.check_output(
-                [*gitLogCommitSubject, log["hash"]]
-            )[
-                :-1
-            ].decode()  # seperate query to avoid json escaping issues
             commit = Commit()
             for k, v in log.items():
                 setattr(commit, k, v)
@@ -524,15 +531,73 @@ class OsProject:
         return commits
 
 
+class GitLog2WikiCmd(BaseCmd):
+    """Command line interface for gitlog2wiki."""
+
+    def add_arguments(self, parser):
+        """Add gitlog2wiki-specific arguments to the parser.
+
+        Args:
+            parser: The argument parser to extend.
+        """
+        super().add_arguments(parser)
+        parser.add_argument(
+            "--filter",
+            help="Filter commits by date prefix, e.g. 2026, 2026-03, 2026-03-28",
+            default=None,
+        )
+
+    def handle_args(self, args):
+        """Handle parsed arguments and run the command.
+
+        Args:
+            args: Parsed argument namespace.
+
+        Returns:
+            bool: True if handled.
+        """
+        handled = super().handle_args(args)
+        result = False
+        if handled:
+            result = True
+        else:
+            osProject = OsProject.fromRepo()
+            if osProject.repo is None:
+                try:
+                    url = subprocess.check_output(
+                        ["git", "config", "--get", "remote.origin.url"]
+                    )
+                    url = url.decode().strip("\n")
+                    print(
+                        f"Error: Could not parse git remote URL: {url}",
+                        file=sys.stderr,
+                    )
+                except subprocess.CalledProcessError:
+                    print(
+                        "Error: Not in a git repository or no remote.origin.url configured",
+                        file=sys.stderr,
+                    )
+                result = False
+            else:
+                commits = osProject.getCommits()
+                if args.filter:
+                    date_filter = args.filter
+                    commits = [
+                        c for c in commits if str(c.date.date()).startswith(date_filter)
+                    ]
+                print("\n".join([c.toWikiMarkup() for c in commits]))
+                result = True
+        return result
+
+
 def gitlog2wiki(_argv=None):
     """Cmdline interface to get gitlog entries in wiki markup."""
-    parser = argparse.ArgumentParser(description="gitlog2wiki")
-    if _argv:
-        _args = parser.parse_args(args=_argv)
+    from osprojects.version import Version
 
-    osProject = OsProject.fromRepo()
-    commits = osProject.getCommits()
-    print("\n".join([c.toWikiMarkup() for c in commits]))
+    argv = sys.argv[1:] if _argv is None else _argv
+    cmd = GitLog2WikiCmd(Version)
+    result = cmd.run(argv)
+    return result
 
 
 def main(_argv=None):

{pyopensourceprojects-0.5.1 → pyopensourceprojects-0.6.0}/osprojects/version.py

@@ -12,5 +12,6 @@ class Version(object):
     name = "pyOpenSourceProjects"
     version = osprojects.__version__
     date = "2024-07-31"
-    updated = "2026-03-14"  # keeping date; version now aligns to 0.5.1
+    updated = "2026-03-28"
     description = "Check python OpenSource Projects to follow standards for README, github workflow and pyproject.toml - creates badges"
+    doc_url = "http://wiki.bitplan.com/index.php/pyOpenSourceProjects"

{pyopensourceprojects-0.5.1 → pyopensourceprojects-0.6.0}/pyproject.toml

@@ -16,6 +16,8 @@ readme = "README.md"
 license = "Apache-2.0"
 
 dependencies = [
+  # https://pypi.org/project/pybasemkit/
+  "pybasemkit>=0.2.2",
   # https://pypi.org/project/beautifulsoup4/
   "beautifulsoup4>=4.14.2",
   # https://pypi.org/project/GitPython/

pyopensourceprojects-0.6.0/tests/test_gitlog2wiki.py

@@ -0,0 +1,122 @@
+"""Created on 2026-03-28.
+
+@author: wf
+"""
+
+import datetime
+import unittest
+
+from osprojects.osproject import Commit, GitLog2WikiCmd, gitlog2wiki
+from osprojects.version import Version
+from tests.basetest import BaseTest
+
+
+class TestGitLog2WikiFilter(BaseTest):
+    """Test the --filter option of gitlog2wiki."""
+
+    def _make_commit(self, date_iso: str) -> Commit:
+        """Create a Commit with the given ISO date string.
+
+        Args:
+            date_iso: ISO 8601 date string, e.g. '2026-03-28T10:00:00+00:00'.
+
+        Returns:
+            A Commit instance with date and hash set.
+        """
+        commit = Commit()
+        commit.date = datetime.datetime.fromisoformat(date_iso)
+        commit.hash = "abc1234"
+        commit.subject = "Test commit"
+        commit.name = "Tester"
+        commit.project = "testproject"
+        commit.host = "https://github.com/test/testproject"
+        commit.path = ""
+        return commit
+
+    def setUp(self, debug=False, profile=True):
+        """Set up sample commits spanning multiple years/months/days."""
+        super().setUp(debug=debug, profile=profile)
+        self.commits = [
+            self._make_commit("2024-12-01T08:00:00+00:00"),
+            self._make_commit("2025-06-15T12:00:00+00:00"),
+            self._make_commit("2026-03-01T09:00:00+00:00"),
+            self._make_commit("2026-03-28T14:30:00+00:00"),
+            self._make_commit("2026-11-05T17:00:00+00:00"),
+        ]
+
+    def _apply_filter(self, date_filter: str):
+        """Apply the same filter logic as GitLog2WikiCmd.handle_args.
+
+        Args:
+            date_filter: Date prefix string, e.g. '2026', '2026-03', '2026-03-28'.
+
+        Returns:
+            Filtered list of Commit objects.
+        """
+        result = [c for c in self.commits if str(c.date.date()).startswith(date_filter)]
+        return result
+
+    def test_filter_by_year(self):
+        """Filter by year should return all commits in that year."""
+        filtered = self._apply_filter("2026")
+        dates = [str(c.date.date()) for c in filtered]
+        self.assertEqual(3, len(filtered))
+        self.assertIn("2026-03-01", dates)
+        self.assertIn("2026-03-28", dates)
+        self.assertIn("2026-11-05", dates)
+
+    def test_filter_by_month(self):
+        """Filter by year-month should return only commits in that month."""
+        filtered = self._apply_filter("2026-03")
+        dates = [str(c.date.date()) for c in filtered]
+        self.assertEqual(2, len(filtered))
+        self.assertIn("2026-03-01", dates)
+        self.assertIn("2026-03-28", dates)
+
+    def test_filter_by_day(self):
+        """Filter by exact day should return only commits on that day."""
+        filtered = self._apply_filter("2026-03-28")
+        self.assertEqual(1, len(filtered))
+        self.assertEqual("2026-03-28", str(filtered[0].date.date()))
+
+    def test_filter_no_match(self):
+        """Filter with no matching commits should return an empty list."""
+        filtered = self._apply_filter("2023")
+        self.assertEqual(0, len(filtered))
+
+    def test_no_filter_returns_all(self):
+        """Without a filter all commits are returned."""
+        filtered = self.commits  # no filter applied
+        self.assertEqual(5, len(filtered))
+
+    def test_gitlog2wiki_filter_cmdline(self):
+        """Test gitlog2wiki CLI with --filter passes through and filters
+        output."""
+        if self.inPublicCI():
+            return
+        output = self.captureOutput(gitlog2wiki, ["--filter", "2022"])
+        lines = [line for line in output.strip().split("\n") if line]
+        # The very first commit (hash 106254f) is from 2022-01-24
+        self.assertTrue(len(lines) >= 1)
+        for line in lines:
+            self.assertIn("2022", line)
+
+    def test_gitlog2wiki_no_filter_cmdline(self):
+        """Test gitlog2wiki CLI without --filter returns all commits."""
+        if self.inPublicCI():
+            return
+        output_all = self.captureOutput(gitlog2wiki, [])
+        output_filtered = self.captureOutput(gitlog2wiki, ["--filter", "2022"])
+        lines_all = [l for l in output_all.strip().split("\n") if l]
+        lines_filtered = [l for l in output_filtered.strip().split("\n") if l]
+        self.assertGreater(len(lines_all), len(lines_filtered))
+
+    def test_gitlog2wiki_cmd_class(self):
+        """Test GitLog2WikiCmd can be instantiated with Version."""
+        cmd = GitLog2WikiCmd(Version)
+        self.assertIsNotNone(cmd)
+        self.assertIsInstance(cmd, GitLog2WikiCmd)
+
+
+if __name__ == "__main__":
+    unittest.main()

{pyopensourceprojects-0.5.1 → pyopensourceprojects-0.6.0}/tests/test_osproject.py

@@ -76,7 +76,7 @@ class TestOsProject(BaseTest):
             return
         commit = self.getSampleById(Commit, "hash", "106254f")
         expectedCommitMarkup = commit.toWikiMarkup()
-        output = self.captureOutput(gitlog2wiki)
+        output = self.captureOutput(gitlog2wiki, [])
         outputLines = output.split("\n")
         self.assertTrue(expectedCommitMarkup in outputLines)
 

pyopensourceprojects-0.5.1/osprojects/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.5.1"