pyOpenSourceProjects 0.2.0__tar.gz → 0.2.1__tar.gz

{pyopensourceprojects-0.2.0 → pyopensourceprojects-0.2.1}/.github/workflows/build.yml

@@ -20,7 +20,7 @@ jobs:
       matrix:
         os: [ubuntu-latest, macos-latest, windows-latest]
         #os: [ubuntu-latest]
-        python-version: [3.9, "3.10", "3.11", "3.12"]
+        python-version: [ 3.9, '3.10', '3.11', '3.12' ]
         #python-version: ["3.10"]
 
     steps:
@@ -32,10 +32,8 @@ jobs:
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip
-        pip install sphinx
-        pip install sphinx_rtd_theme
         scripts/install
         scripts/doc
     - name: Run tests
       run: |
-        scripts/installAndTest
+        scripts/test

{pyopensourceprojects-0.2.0 → pyopensourceprojects-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pyOpenSourceProjects
-Version: 0.2.0
+Version: 0.2.1
 Dynamic: Summary
 Project-URL: Home, https://github.com/WolfgangFahl/pyOpenSourceProjects
 Project-URL: Documentation, http://wiki.bitplan.com/index.php/pyOpenSourceProjects
@@ -15,6 +15,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Requires-Python: >=3.9
+Requires-Dist: packaging>=24.1
 Requires-Dist: py-3rdparty-mediawiki>=0.11.3
 Requires-Dist: pylodstorage>=0.11.6
 Requires-Dist: python-dateutil>=2.8.2

pyopensourceprojects-0.2.1/osprojects/__init__.py

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

pyopensourceprojects-0.2.1/osprojects/checkos.py

@@ -0,0 +1,320 @@
+#!/usr/bin/env python
+"""
+Created on 2024-07-30
+
+@author: wf
+"""
+import argparse
+import os
+from argparse import Namespace
+from dataclasses import dataclass
+from typing import List
+# original at ngwidgets - use redundant local copy ...
+from osprojects.editor import Editor
+from osprojects.osproject import GitHub, OsProject
+import tomllib
+import traceback
+from packaging import version
+
+@dataclass
+class Check:
+    ok: bool = False
+    path: str = None
+    msg: str = ""
+    content: str = None
+
+    @property
+    def marker(self) -> str:
+        return f"✅" if self.ok else f"❌"
+
+    @classmethod
+    def file_exists(cls, path) -> "Check":
+        ok = os.path.exists(path)
+        content = None
+        if ok and os.path.isfile(path):
+            with open(path, "r") as f:
+                content = f.read()
+        check = Check(ok, path, msg=path, content=content)
+        return check
+
+class CheckOS:
+    """
+    check the open source projects
+    """
+
+    def __init__(self, args: Namespace, project: OsProject):
+        self.args = args
+        self.verbose = args.verbose
+        self.workspace = args.workspace
+        self.project = project
+        self.project_path = os.path.join(self.workspace, project.id)
+        self.checks = []
+
+    @property
+    def total(self) -> int:
+        return len(self.checks)
+
+    @property
+    def ok_checks(self) -> List[Check]:
+        ok_checks = [check for check in self.checks if check.ok]
+        return ok_checks
+
+    @property
+    def failed_checks(self) -> List[Check]:
+        failed_checks = [check for check in self.checks if not check.ok]
+        return failed_checks
+
+    def add_check(self, ok, msg:str="",path: str=None,negative:bool=False) -> Check:
+        if not path:
+            raise ValueError("path parameter missing")
+        marker=""
+        if negative:
+            ok=not ok
+            marker="⚠ ️"
+        check = Check(ok=ok, path=path, msg=f"{marker}{msg}{path}")
+        self.checks.append(check)
+        return check
+
+    def add_content_check(self, content: str, needle: str, path: str, negative:bool=False) -> Check:
+        ok=needle in content
+        check=self.add_check(ok, msg=f"{needle} in ", path=path,negative=negative)
+        return check
+
+    def add_path_check(self, path) -> Check:
+        # Check if path exists
+        path_exists = Check.file_exists(path)
+        self.checks.append(path_exists)
+        return path_exists
+
+    def check_local(self) -> Check:
+        local = Check.file_exists(self.project_path)
+        return local
+
+    def check_github_workflows(self):
+        workflows_path = os.path.join(self.project_path, ".github", "workflows")
+        workflows_exist = self.add_path_check(workflows_path)
+
+        if workflows_exist.ok:
+            required_files = ["build.yml", "upload-to-pypi.yml"]
+            for file in required_files:
+                file_path = os.path.join(workflows_path, file)
+                file_exists = self.add_path_check(file_path)
+
+                if file_exists.ok:
+                    content = file_exists.content
+
+                    if file == "build.yml":
+                        min_version = int(self.requires_python.split('.')[-1])
+                        python_versions = f"""python-version: [ {', '.join([f"'3.{i}'" for i in range(min_version, 13)])} ]"""
+                        self.add_content_check(
+                            content,
+                            python_versions,
+                            file_path,
+                        )
+                        self.add_content_check(
+                            content,
+                            "os: [ubuntu-latest, macos-latest, windows-latest]",
+                            file_path,
+                        )
+                        self.add_content_check(content, "uses: actions/checkout@v4", file_path)
+                        self.add_content_check(
+                            content,
+                            "uses: actions/setup-python@v5",
+                            file_path,
+                        )
+
+                        self.add_content_check(
+                            content,
+                            "sphinx",
+                            file_path,
+                            negative=True
+                        )
+                        scripts_ok="scripts/install" in content and "scripts/test" in content or "scripts/installAndTest" in content
+                        self.add_check(scripts_ok,"install and test", file_path)
+
+                    elif file == "upload-to-pypi.yml":
+                        self.add_content_check(content, "id-token: write", file_path)
+                        self.add_content_check(content, "uses: actions/checkout@v4", file_path)
+                        self.add_content_check(
+                            content,
+                            "uses: actions/setup-python@v5",
+                            file_path,
+                        )
+                        self.add_content_check(
+                            content,
+                            "uses: pypa/gh-action-pypi-publish@release/v1",
+                            file_path,
+                        )
+
+    def check_scripts(self):
+        scripts_path = os.path.join(self.project_path, "scripts")
+        scripts_exist = self.add_path_check(scripts_path)
+        if scripts_exist.ok:
+            required_files = ["blackisort", "test", "install", "doc", "release"]
+            for file in required_files:
+                file_path = os.path.join(scripts_path, file)
+                file_exists = self.add_path_check(file_path)
+                if file_exists.ok:
+                    content = file_exists.content
+                    if file=="doc":
+                        self.add_content_check(content, "sphinx", file_path, negative=True)
+                        self.add_content_check(content,"WF 2024-07-30 - updated",file_path)
+                    if file=="release":
+                        self.add_content_check(content, "scripts/docs -d", file_path, negative=True)
+
+    def check_readme(self):
+        readme_path = os.path.join(self.project_path, "README.md")
+        readme_exists = self.add_path_check(readme_path)
+        if readme_exists.ok:
+            readme_content = readme_exists.content
+            badge_lines = [
+                "[![pypi](https://img.shields.io/pypi/pyversions/{self.project_name})](https://pypi.org/project/{self.project_name}/)",
+                "[![Github Actions Build](https://github.com/{self.project.fqid}/actions/workflows/build.yml/badge.svg)](https://github.com/{self.project.fqid}/actions/workflows/build.yml)",
+                "[![PyPI Status](https://img.shields.io/pypi/v/{self.project_name}.svg)](https://pypi.python.org/pypi/{self.project_name}/)",
+                "[![GitHub issues](https://img.shields.io/github/issues/{self.project.fqid}.svg)](https://github.com/{self.project.fqid}/issues)",
+                "[![GitHub closed issues](https://img.shields.io/github/issues-closed/{self.project.fqid}.svg)](https://github.com/{self.project.fqid}/issues/?q=is%3Aissue+is%3Aclosed)",
+                "[![API Docs](https://img.shields.io/badge/API-Documentation-blue)](https://{self.project.owner}.github.io/{self.project.id}/)",
+                "[![License](https://img.shields.io/github/license/{self.project.fqid}.svg)](https://www.apache.org/licenses/LICENSE-2.0)",
+            ]
+            for line in badge_lines:
+                formatted_line = line.format(self=self)
+                self.add_content_check(
+                    content=readme_content,
+                    needle=formatted_line,
+                    path=readme_path,
+                )
+            self.add_content_check(readme_content, "readthedocs", readme_path, negative=True)
+
+    def check_pyproject_toml(self):
+        toml_path = os.path.join(self.project_path, "pyproject.toml")
+        toml_exists = self.add_path_check(toml_path)
+        if toml_exists.ok:
+            content=toml_exists.content
+            toml_dict = tomllib.loads(content)
+            project_check=self.add_check("project" in toml_dict, "[project]", toml_path)
+            if project_check.ok:
+                self.project_name=toml_dict["project"]["name"]
+                requires_python_check=self.add_check("requires-python" in toml_dict["project"], "requires-python", toml_path)
+                if requires_python_check.ok:
+                    self.requires_python = toml_dict["project"]["requires-python"]
+                    self.min_python_version = version.parse(self.requires_python.replace(">=", ""))
+                    min_version_needed="3.9"
+                    version_ok=self.min_python_version >= version.parse(min_version_needed)
+                    self.add_check(version_ok, f"requires-python>={min_version_needed}", toml_path)
+            self.add_content_check(content, "hatchling", toml_path)
+            self.add_content_check(content,"[tool.hatch.build.targets.wheel.sources]",toml_path)
+
+    def check(self):
+        """
+        Check the given project and print results
+        """
+        self.check_local()
+        self.check_pyproject_toml()
+        self.check_readme()
+        self.check_scripts()
+        self.check_github_workflows()
+
+        # ok_count=len(ok_checks)
+        failed_count = len(self.failed_checks)
+        summary = f"❌ {failed_count}/{self.total}" if failed_count > 0 else f"✅ {self.total}/{self.total}"
+        print(f"{self.project} {summary}: {self.project.url}")
+        if failed_count > 0:
+            # Sort checks by path
+            sorted_checks = sorted(self.checks, key=lambda c: c.path or "")
+
+            # Group checks by path
+            checks_by_path = {}
+            for check in sorted_checks:
+                if check.path not in checks_by_path:
+                    checks_by_path[check.path] = []
+                checks_by_path[check.path].append(check)
+
+            # Display results
+            for path, path_checks in checks_by_path.items():
+                path_failed = sum(1 for c in path_checks if not c.ok)
+                if path_failed > 0 or self.args.debug:
+                    print(f"❌ {path}: {path_failed}")
+                    i=0
+                    for check in path_checks:
+                        show=not check.ok or self.args.debug
+                        if show:
+                            i+=1
+                            print(f"    {i:3}{check.marker}:{check.msg}")
+
+                    if self.args.editor and path_failed > 0:
+                        if os.path.isfile(path):
+                            # @TODO Make editor configurable
+                            Editor.open(path,default_editor_cmd="/usr/local/bin/atom")
+                        else:
+                            Editor.open_filepath(path)
+
+
+def main(_argv=None):
+    """
+    main command line entry point
+    """
+    parser = argparse.ArgumentParser(description="Check open source projects")
+    parser.add_argument(
+        "-d",
+        "--debug",
+        action="store_true",
+        help="add debug output",
+    )
+    parser.add_argument(
+        "-e",
+        "--editor",
+        action="store_true",
+        help="open default editor on failed files",
+    )
+    parser.add_argument(
+        "-o", "--owner", help="project owner or organization", required=True
+    )
+    parser.add_argument("-p", "--project", help="name of the project")
+    parser.add_argument("-l", "--language", help="filter projects by language")
+    parser.add_argument(
+        "--local", action="store_true", help="check only locally available projects"
+    )
+    parser.add_argument(
+        "-v", "--verbose", action="store_true", help="show verbose output"
+    )
+    parser.add_argument(
+        "-ws",
+        "--workspace",
+        help="(Eclipse) workspace directory",
+        default=os.path.expanduser("~/py-workspace"),
+    )
+
+    args = parser.parse_args(args=_argv)
+
+    try:
+        github = GitHub()
+        if args.project:
+            # Check specific project
+            projects = github.list_projects_as_os_projects(
+                args.owner, project_name=args.project
+            )
+        else:
+            # Check all projects
+            projects = github.list_projects_as_os_projects(args.owner)
+
+        if args.language:
+            projects = [p for p in projects if p.language == args.language]
+
+        if args.local:
+            local_projects = []
+            for project in projects:
+                checker = CheckOS(args=args, project=project)
+                if checker.check_local().ok:
+                    local_projects.append(project)
+            projects = local_projects
+
+        for project in projects:
+            checker = CheckOS(args=args, project=project)
+            checker.check()
+    except Exception as ex:
+        if args.debug:
+            print(traceback.format_exc())
+        raise ex
+
+if __name__ == "__main__":
+    main()

pyopensourceprojects-0.2.1/osprojects/editor.py

@@ -0,0 +1,132 @@
+"""
+Created on 2022-11-27
+
+@author: wf
+"""
+
+import os
+import platform
+import subprocess
+import tempfile
+from pathlib import Path
+from urllib.request import urlopen
+
+from bs4 import BeautifulSoup
+
+
+class Editor:
+    """
+    helper class to open the system defined editor
+
+    see https://stackoverflow.com/questions/1442841/lauch-default-editor-like-webbrowser-module
+    """
+
+    @classmethod
+    def open_filepath(cls, filepath: str):
+        if platform.system() == "Darwin":  # macOS
+            subprocess.call(("open", filepath))
+        elif platform.system() == "Windows":  # Windows
+            os.startfile(filepath, "open")
+        else:  # linux variants
+            subprocess.call(("xdg-open", filepath))
+
+    @classmethod
+    def extract_text(cls, html_text: str) -> str:
+        """
+        extract the text from the given html_text
+
+        Args:
+            html_text(str): the input for the html text
+
+        Returns:
+            str: the plain text
+        """
+        soup = BeautifulSoup(html_text, features="html.parser")
+
+        # kill all script and style elements
+        for script in soup(["script", "style"]):
+            script.extract()  # rip it out
+
+        # get text
+        text = soup.get_text()
+
+        # break into lines and remove leading and trailing space on each
+        lines = (line.strip() for line in text.splitlines())
+        # break multi-headlines into a line each
+        chunks = (phrase.strip() for line in lines for phrase in line.split("  "))
+        # drop blank lines
+        text = "\n".join(chunk for chunk in chunks if chunk)
+        return text
+
+    @classmethod
+    def open(
+        cls,
+        file_source: str,
+        extract_text: bool = True,
+        default_editor_cmd: str = "/usr/local/bin/atom",
+    ) -> str:
+        """
+        open an editor for the given file_source
+
+        Args:
+            file_source(str): the path to the file
+            extract_text(bool): if True extract the text from html sources
+
+        Returns:
+            str: the path to the file e.g. a temporary file if the file_source points to an url
+        """
+        # handle urls
+        # https://stackoverflow.com/a/45886824/1497139
+        if file_source.startswith("http"):
+            url_source = urlopen(file_source)
+            # https://stackoverflow.com/a/19156107/1497139
+            charset = url_source.headers.get_content_charset()
+            # if charset fails here you might want to set it to utf-8 as a default!
+            text = url_source.read().decode(charset)
+            if extract_text:
+                # https://stackoverflow.com/a/24618186/1497139
+                text = cls.extract_text(text)
+
+            return cls.open_tmp_text(text)
+
+        editor_cmd = None
+        editor_env = os.getenv("EDITOR")
+        if editor_env:
+            editor_cmd = editor_env
+        if platform.system() == "Darwin":
+            if not editor_env:
+                # https://stackoverflow.com/questions/22390709/how-can-i-open-the-atom-editor-from-the-command-line-in-os-x
+                editor_cmd = default_editor_cmd
+        if editor_cmd:
+            os_cmd = f"{editor_cmd} {file_source}"
+            os.system(os_cmd)
+        return file_source
+
+    @classmethod
+    def open_tmp_text(cls, text: str, file_name: str = None) -> str:
+        """
+        open an editor for the given text in a newly created temporary file
+
+        Args:
+            text(str): the text to write to a temporary file and then open
+            file_name(str): the name to use for the file
+
+        Returns:
+            str: the path to the temp file
+        """
+        # see https://stackoverflow.com/a/8577226/1497139
+        # https://stackoverflow.com/a/3924253/1497139
+        with tempfile.NamedTemporaryFile(delete=False) as tmp:
+            with open(tmp.name, "w") as tmp_file:
+                tmp_file.write(text)
+                tmp_file.close()
+            if file_name is None:
+                file_path = tmp.name
+            else:
+                # https://stackoverflow.com/questions/3167154/how-to-split-a-dos-path-into-its-components-in-python
+                path = Path(tmp.name)
+                # https://stackoverflow.com/a/49798311/1497139
+                file_path = path.parent / file_name
+                os.rename(tmp.name, file_path)
+
+            return cls.open(str(file_path))

{pyopensourceprojects-0.2.0 → pyopensourceprojects-0.2.1}/osprojects/osproject.py

@@ -333,7 +333,7 @@ class OsProject(object):
 
     @property
     def fqid(self):
-        fqid=f"{self.owner}/{self.id}"
+        fqid = f"{self.owner}/{self.id}"
         return fqid
 
     def __str__(self):

{pyopensourceprojects-0.2.0 → pyopensourceprojects-0.2.1}/pyproject.toml

@@ -18,7 +18,9 @@ dependencies = [
   "pyLodStorage>=0.11.6",
   "py-3rdparty-mediawiki>=0.11.3",
   # https://pypi.org/project/python-dateutil/
-  "python-dateutil>=2.8.2"
+  "python-dateutil>=2.8.2",
+  # https://github.com/pypa/packaging
+  "packaging>=24.1"
 ]
 requires-python = ">=3.9"
 

pyopensourceprojects-0.2.1/scripts/release

@@ -0,0 +1,8 @@
+#!/bin/bash
+# WF 2024-07-31
+# prepare a release
+scripts/doc -d
+
+# Commit with a message that includes the current ISO timestamp
+git commit -a -m "release commit"
+git push

pyopensourceprojects-0.2.0/osprojects/__init__.py

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

pyopensourceprojects-0.2.0/osprojects/checkos.py

@@ -1,138 +0,0 @@
-#!/usr/bin/env python
-"""
-Created on 2024-07-30
-
-@author: wf
-"""
-from dataclasses import dataclass
-import argparse
-from argparse import Namespace
-import os
-from typing import List
-
-from osprojects.osproject import GitHub, OsProject
-
-@dataclass
-class Check:
-    ok: bool=False
-    msg: str=""
-
-    @property
-    def marker(self) -> str:
-        return f"✅" if self.ok else f"❌"
-
-class CheckOS:
-    """
-    check the open source projects
-    """
-
-    def __init__(self, args:Namespace,project:OsProject):
-        self.args=args
-        self.verbose= args.verbose
-        self.workspace = args.workspace
-        self.project=project
-        self.project_path = os.path.join(self.workspace, project.id)
-
-
-    def check_local(self)->Check:
-        local=Check(ok=os.path.exists(self.project_path),msg=f"{self.project_path}")
-        return local
-
-    def check_readme(self) -> List[Check]:
-        checks=[]
-        readme_path = os.path.join(self.project_path, "README.md")
-        readme_exists=Check(ok=os.path.exists(readme_path),msg=readme_path)
-        checks.append(readme_exists)
-        if readme_exists.ok:
-            with open(readme_path, "r") as readme_file:
-                readme_content = readme_file.read()
-                badge_lines = [
-                "[![pypi](https://img.shields.io/pypi/pyversions/{self.project.id})](https://pypi.org/project/{self.project.id}/)",
-                "[![Github Actions Build](https://github.com/{self.project.fqid}/actions/workflows/build.yml/badge.svg)](https://github.com/{self.project.fqid}/actions/workflows/build.yml)",
-                "[![PyPI Status](https://img.shields.io/pypi/v/{self.project.id}.svg)](https://pypi.python.org/pypi/{self.project.id}/)",
-                "[![GitHub issues](https://img.shields.io/github/issues/{self.project.fqid}.svg)](https://github.com/{self.project.fqid}/issues)",
-                "[![GitHub closed issues](https://img.shields.io/github/issues-closed/{self.project.fqid}.svg)](https://github.com/{self.project.fqid}/issues/?q=is%3Aissue+is%3Aclosed)",
-                "[![API Docs](https://img.shields.io/badge/API-Documentation-blue)](https://{self.project.owner}.github.io/{self.project.id}/)",
-                "[![License](https://img.shields.io/github/license/{self.project.fqid}.svg)](https://www.apache.org/licenses/LICENSE-2.0)"
-            ]
-            for line in badge_lines:
-                formatted_line = line.format(self=self)
-                checks.append(Check(ok=formatted_line in readme_content, msg=formatted_line))
-
-
-        return checks
-
-    def check(self) -> List[Check]:
-        """
-        Check the given project and print results
-        """
-        checks = []
-        checks.append(self.check_local())
-        checks.extend(self.check_readme())
-        total=len(checks)
-        ok_checks = [check for check in checks if check.ok]
-        failed_checks = [check for check in checks if not check.ok]
-        #ok_count=len(ok_checks)
-        failed_count=len(failed_checks)
-        summary=f"❌ {failed_count}/{total}" if failed_count>0 else "✅"
-        print(f"{self.project} {summary}: {self.project.url}")
-        if failed_count>0:
-            sorted_checks = ok_checks + failed_checks if self.verbose else failed_checks
-
-            for i,check in enumerate(sorted_checks):
-                print(f"    {i+1:3}{check.marker}:{check.msg}")
-            return checks
-
-def main(_argv=None):
-    """
-    main command line entry point
-    """
-    parser = argparse.ArgumentParser(description="Check open source projects")
-    parser.add_argument(
-        "-o", "--owner", help="project owner or organization", required=True
-    )
-    parser.add_argument("-p", "--project", help="name of the project")
-    parser.add_argument("-l", "--language", help="filter projects by language")
-    parser.add_argument(
-        "--local", action="store_true", help="check only locally available projects"
-    )
-    parser.add_argument(
-        "-v","--verbose", action="store_true", help="show verbose output"
-    )
-    parser.add_argument(
-        "-ws",
-        "--workspace",
-        help="(Eclipse) workspace directory",
-        default=os.path.expanduser("~/py-workspace"),
-    )
-
-    args = parser.parse_args(args=_argv)
-
-    github = GitHub()
-    if args.project:
-        # Check specific project
-        projects = [
-            github.list_projects_as_os_projects(args.owner, project_name=args.project)
-        ]
-    else:
-        # Check all projects
-        projects = github.list_projects_as_os_projects(args.owner)
-
-    if args.language:
-        projects = [p for p in projects if p.language == args.language]
-
-    if args.local:
-        local_projects = []
-        for project in projects:
-            checker = CheckOS(args=args,project=project)
-            if checker.check_local().ok:
-                local_projects.append(project)
-        projects=local_projects
-
-
-    for project in projects:
-        checker = CheckOS(args=args,project=project)
-        checker.check()
-
-if __name__ == "__main__":
-    main()