pyOpenSourceProjects 0.0.9__tar.gz → 0.1.1__tar.gz

pyopensourceprojects-0.1.1/.github/workflows/build.yml

@@ -0,0 +1,41 @@
+# This workflow will install Python dependencies, run tests and lint with a variety of Python versions
+# For more information see: https://help.github.com/actions/language-and-framework-guides/using-python-with-github-actions
+
+name: Build
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+env:
+  GHACTIONS: ACTIVE
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+        #os: [ubuntu-latest]
+        python-version: [3.9, "3.10", "3.11", "3.12"]
+        #python-version: ["3.10"]
+
+    steps:
+    - uses: actions/checkout@v4
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v5
+      with:
+        python-version: ${{ matrix.python-version }}
+    - 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

pyopensourceprojects-0.1.1/.github/workflows/upload-to-pypi.yml

@@ -0,0 +1,27 @@
+name: Upload Python Package
+
+on:
+  release:
+    types: [created]
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    permissions:
+      # IMPORTANT: this permission is mandatory for trusted publishing
+      id-token: write
+    steps:
+    - uses: actions/checkout@v4
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with:
+        python-version: '3.x'
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install hatch
+    - name: Build and publish
+      run: |
+        hatch build
+    - name: Publish distribution to PyPI
+      uses: pypa/gh-action-pypi-publish@release/v1

pyopensourceprojects-0.1.1/.gitignore

@@ -0,0 +1,131 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+# no docs
+docs

pyopensourceprojects-0.1.1/.project

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>pyOpenSourceProjects</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.python.pydev.PyDevBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.python.pydev.pythonNature</nature>
+	</natures>
+</projectDescription>

pyopensourceprojects-0.1.1/.pydevproject

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<?eclipse-pydev version="1.0"?><pydev_project>
+    <pydev_pathproperty name="org.python.pydev.PROJECT_SOURCE_PATH">
+        <path>/${PROJECT_DIR_NAME}</path>
+    </pydev_pathproperty>
+    <pydev_property name="org.python.pydev.PYTHON_PROJECT_VERSION">python interpreter</pydev_property>
+    <pydev_property name="org.python.pydev.PYTHON_PROJECT_INTERPRETER">Default</pydev_property>
+</pydev_project>

{pyOpenSourceProjects-0.0.9/pyOpenSourceProjects.egg-info → pyopensourceprojects-0.1.1}/PKG-INFO

@@ -1,20 +1,25 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: pyOpenSourceProjects
-Version: 0.0.9
-Home-page: https://github.com/WolfgangFahl/pyOpenSourceProjects
-Author: Wolfgang Fahl
-Author-email: wf@bitplan.com
-Maintainer: Wolfgang Fahl
-License: Apache License
+Version: 0.1.1
+Dynamic: Summary
+Project-URL: Home, https://github.com/WolfgangFahl/pyOpenSourceProjects
 Project-URL: Documentation, http://wiki.bitplan.com/index.php/pyOpenSourceProjects
-Project-URL: Code, https://github.com/WolfgangFahl/pyOpenSourceProjects
-Project-URL: Issue tracker, https://github.com/WolfgangFahl/pyOpenSourceProjects/issues
+Project-URL: Source, https://github.com/WolfgangFahl/pyOpenSourceProjects
+Author-email: Wolfgang Fahl <wf@bitplan.com>
+Maintainer-email: Wolfgang Fahl <wf@bitplan.com>
+License-Expression: Apache-2.0
+License-File: LICENSE
 Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.9
+Requires-Dist: py-3rdparty-mediawiki>=0.11.3
+Requires-Dist: pylodstorage>=0.11.6
+Requires-Dist: python-dateutil>=2.8.2
+Provides-Extra: test
 Description-Content-Type: text/markdown
-License-File: LICENSE
 
 # pyOpenSourceProjects
 Helper Library to organize open source Projects
@@ -32,4 +37,4 @@ Helper Library to organize open source Projects
 
 ### Authors
 * [Tim Holzheim](https://www.semantic-mediawiki.org/wiki/Tim_Holzheim)
-* [Wolfgang Fahl](http://www.bitplan.com/Wolfgang_Fahl)
+* [Wolfgang Fahl](http://www.bitplan.com/Wolfgang_Fahl)

pyopensourceprojects-0.1.1/osprojects/__init__.py

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

pyopensourceprojects-0.1.1/osprojects/osproject.py

@@ -0,0 +1,407 @@
+"""
+Created on 2022-01-24
+
+@author: wf
+"""
+from __future__ import annotations
+import os
+import argparse
+import datetime
+import json
+import re
+import subprocess
+import sys
+from typing import List, Type
+
+import requests
+from dateutil.parser import parse
+
+
+class TicketSystem(object):
+    """
+    platform for hosting OpenSourceProjects and their issues
+    """
+
+    @classmethod
+    def getIssues(self, project: OsProject, **kwargs) -> List[Ticket]:
+        """
+        get issues from the TicketSystem for a project
+        """
+        return NotImplemented
+
+    @staticmethod
+    def projectUrl(project: OsProject):
+        """
+        url of the project
+        """
+        return NotImplemented
+
+    @staticmethod
+    def ticketUrl(project: OsProject):
+        """
+        url of the ticket/issue list
+        """
+        return NotImplemented
+
+    @staticmethod
+    def commitUrl(project: OsProject, id: str):
+        """
+        url of the ticket/issue list
+        """
+        return NotImplemented
+
+
+class GitHub(TicketSystem):
+    """
+    wrapper for the GitHub api
+    """
+    @classmethod
+    def load_access_token(cls)->str:
+        """
+        if $HOME/.github/access_token.json exists read the token from there
+        """
+        # Specify the path to the access token file
+        token_file_path = os.path.join(os.getenv('HOME'), '.github', 'access_token.json')
+        
+        # Check if the file exists and read the token
+        if os.path.exists(token_file_path):
+            with open(token_file_path, 'r') as token_file:
+                token_data = json.load(token_file)
+                return token_data.get('access_token')
+        
+        # Return None if no token file is found
+        return None
+
+    @classmethod
+    def getIssues(cls, 
+        project: OsProject, 
+        access_token:str=None,
+        limit: int = None,
+        **params) -> List[Ticket]:
+        payload = {}
+        headers = {}
+        if access_token is None:
+            access_token = cls.load_access_token()
+        if access_token:
+            headers = {
+                'Authorization': f'token {access_token}'
+            }
+        issues = []
+        nextResults = True
+        params["per_page"] = 100
+        params["page"] = 1
+        fetched_count = 0  # Counter to track the number of issues fetched
+        while nextResults:
+            response = requests.request(
+                "GET",
+                GitHub.ticketUrl(project),
+                headers=headers,
+                data=payload,
+                params=params,
+            )
+            if response.status_code == 403 and 'rate limit' in response.text:
+                raise Exception("rate limit - you might want to use an access token")
+            issue_records = json.loads(response.text)
+            for record in issue_records:
+                tr = {
+                    "project": project,
+                    "title": record.get("title"),
+                    "body": record.get("body", ""),  
+                    "createdAt": parse(record.get("created_at"))
+                    if record.get("created_at")
+                    else "",
+                    "closedAt": parse(record.get("closed_at"))
+                    if record.get("closed_at")
+                    else "",
+                    "state": record.get("state"),
+                    "number": record.get("number"),
+                    "url": f"{cls.projectUrl(project)}/issues/{record.get('number')}",
+                }
+                issues.append(Ticket.init_from_dict(**tr))
+                fetched_count += 1
+                # Check if we have reached the limit
+                if limit is not None and fetched_count >= limit:
+                    nextResults=False
+                    break
+
+            if len(issue_records) < 100:
+                nextResults = False
+            else:
+                params["page"] += 1
+        return issues
+
+    @staticmethod
+    def projectUrl(project: OsProject):
+        return f"https://github.com/{project.owner}/{project.id}"
+
+    @staticmethod
+    def ticketUrl(project: OsProject):
+        return f"https://api.github.com/repos/{project.owner}/{project.id}/issues"
+
+    @staticmethod
+    def commitUrl(project: OsProject, id: str):
+        return f"{GitHub.projectUrl(project)}/commit/{id}"
+
+    @staticmethod
+    def resolveProjectUrl(url: str) -> (str, str):
+        """
+        Resolve project url to owner and project name
+
+        Returns:
+            (owner, project)
+        """
+        # https://www.rfc-editor.org/rfc/rfc3986#appendix-B
+        pattern = r"((https?:\/\/github\.com\/)|(git@github\.com:))(?P<owner>[^/?#]+)\/(?P<project>[^\./?#]+)(\.git)?"
+        match = re.match(pattern=pattern, string=url)
+        owner = match.group("owner")
+        project = match.group("project")
+        if owner and project:
+            return owner, project
+
+
+class Jira(TicketSystem):
+    """
+    wrapper for Jira api
+    """
+
+
+class OsProject(object):
+    """
+    an Open Source Project
+    """
+
+    def __init__(
+        self,
+        owner: str = None,
+        id: str = None,
+        ticketSystem: Type[TicketSystem] = GitHub,
+    ):
+        """
+        Constructor
+        """
+        self.owner = owner
+        self.id = id
+        self.ticketSystem = ticketSystem
+
+    @staticmethod
+    def getSamples():
+        samples = [
+            {
+                "id": "pyOpenSourceProjects",
+                "state": "",
+                "owner": "WolfgangFahl",
+                "title": "pyOpenSourceProjects",
+                "url": "https://github.com/WolfgangFahl/pyOpenSourceProjects",
+                "version": "",
+                "desciption": "Helper Library to organize open source Projects",
+                "date": datetime.datetime(year=2022, month=1, day=24),
+                "since": "",
+                "until": "",
+            }
+        ]
+        return samples
+
+    @classmethod
+    def fromRepo(cls):
+        """
+        Init OsProject from repo in current working directory
+        """
+        url = subprocess.check_output(["git", "config", "--get", "remote.origin.url"])
+        url = url.decode().strip("\n")
+        osProject = cls.fromUrl(url)
+        return osProject
+
+    @classmethod
+    def fromUrl(cls, url: str) -> OsProject:
+        """
+        Init OsProject from given url
+        """
+        if "github.com" in url:
+            owner, project = GitHub.resolveProjectUrl(url)
+            if owner and project:
+                return OsProject(owner=owner, id=project, ticketSystem=GitHub)
+        raise Exception(f"Could not resolve the url '{url}' to a OsProject object")
+
+    def getIssues(self, **params) -> list:
+        tickets = self.ticketSystem.getIssues(self, **params)
+        tickets.sort(key=lambda r: getattr(r, "number"), reverse=True)
+        return tickets
+
+    def getAllTickets(self, limit:int=None,**params):
+        """
+        Get all Tickets of the project -  closed and open ones
+        
+        Args:
+            limit(int): if set limit the number of tickets retrieved
+        """
+        issues= self.getIssues(state="all",limit=limit, **params)
+        return issues
+
+    def getCommits(self) -> List[Commit]:
+        commits = []
+        gitlogCmd = [
+            "git",
+            "--no-pager",
+            "log",
+            "--reverse",
+            r'--pretty=format:{"name":"%cn","date":"%cI","hash":"%h"}',
+        ]
+        gitLogCommitSubject = ["git", "log", "--format=%s", "-n", "1"]
+        rawCommitLogs = subprocess.check_output(gitlogCmd).decode()
+        for rawLog in rawCommitLogs.split("\n"):
+            log = json.loads(rawLog)
+            if log.get("date", None) is not None:
+                log["date"] = datetime.datetime.fromisoformat(log["date"])
+            log["project"] = self.id
+            log["host"] = self.ticketSystem.projectUrl(self)
+            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)
+            commits.append(commit)
+        return commits
+
+
+class Ticket(object):
+    """
+    a Ticket
+    """
+
+    @staticmethod
+    def getSamples():
+        samples = [
+            {
+                "number": 2,
+                "title": "Get Tickets in Wiki notation from github API",
+                "createdAt": datetime.datetime.fromisoformat(
+                    "2022-01-24 07:41:29+00:00"
+                ),
+                "closedAt": datetime.datetime.fromisoformat(
+                    "2022-01-25 07:43:04+00:00"
+                ),
+                "url": "https://github.com/WolfgangFahl/pyOpenSourceProjects/issues/2",
+                "project": "pyOpenSourceProjects",
+                "state": "closed",
+            }
+        ]
+        return samples
+
+    @classmethod
+    def init_from_dict(cls, **records):
+        """
+        inits Ticket from given args
+        """
+        issue = Ticket()
+        for k, v in records.items():
+            setattr(issue, k, v)
+        return issue
+
+    def toWikiMarkup(self) -> str:
+        """
+        Returns Ticket in wiki markup
+        """
+        return f"""# {{{{Ticket
+|number={self.number}
+|title={self.title}
+|project={self.project.id}
+|createdAt={self.createdAt if self.createdAt else ""}
+|closedAt={self.closedAt if self.closedAt else ""}
+|state={self.state}
+}}}}"""
+
+
+class Commit(object):
+    """
+    a commit
+    """
+
+    @staticmethod
+    def getSamples():
+        samples = [
+            {
+                "host": "https://github.com/WolfgangFahl/pyOpenSourceProjects",
+                "path": "",
+                "project": "pyOpenSourceProjects",
+                "subject": "Initial commit",
+                "name": "GitHub",  # TicketSystem
+                "date": datetime.datetime.fromisoformat("2022-01-24 07:02:55+01:00"),
+                "hash": "106254f",
+            }
+        ]
+        return samples
+
+    def toWikiMarkup(self):
+        """
+        Returns Commit as wiki markup
+        """
+        params = [
+            f"{attr}={getattr(self, attr, '')}" for attr in self.getSamples()[0].keys()
+        ]
+        markup = f"{{{{commit|{'|'.join(params)}|storemode=subobject|viewmode=line}}}}"
+        return markup
+
+
+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)
+
+    osProject = OsProject.fromRepo()
+    commits = osProject.getCommits()
+    print("\n".join([c.toWikiMarkup() for c in commits]))
+
+
+def main(_argv=None):
+    """
+    main command line entry point
+    """
+    parser = argparse.ArgumentParser(description="Issue2ticket")
+    parser.add_argument("-o", "--owner", help="project owner or organization")
+    parser.add_argument("-p", "--project", help="name of the project")
+    parser.add_argument(
+        "--repo",
+        action="store_true",
+        help="get needed information form repository of current location",
+    )
+    parser.add_argument(
+        "-ts",
+        "--ticketsystem",
+        default="github",
+        choices=["github", "jira"],
+        help="platform the project is hosted",
+    )
+    parser.add_argument(
+        "-s",
+        "--state",
+        choices=["open", "closed", "all"],
+        default="all",
+        help="only issues with the given state",
+    )
+    parser.add_argument("-V", "--version", action="version", version="gitlog2wiki 0.1")
+
+    args = parser.parse_args(args=_argv)
+    # resolve ticketsystem
+    ticketSystem = GitHub
+    if args.ticketsystem == "jira":
+        ticketSystem = Jira
+    if args.project and args.owner:
+        osProject = OsProject(
+            owner=args.owner, id=args.project, ticketSystem=ticketSystem
+        )
+    else:
+        osProject = OsProject.fromRepo()
+    tickets = osProject.getIssues(state=args.state)
+    print("\n".join([t.toWikiMarkup() for t in tickets]))
+
+
+if __name__ == "__main__":
+    # sys.exit(main())
+    sys.exit(gitlog2wiki())