git-editlog 1.0.1__py3-none-any.whl

git_editlog/pyinotify_watcher.py

@@ -0,0 +1,127 @@
+import sys
+import re
+import time
+import os
+import argparse
+import subprocess
+import traceback
+import select
+import logging
+
+from pathlib import Path
+
+from . import repo_watcher
+from . import pyinotify
+from .pyinotify import WatchManager, Notifier, ProcessEvent
+
+log = logging.getLogger(__name__)
+
+EVENTS = (
+    pyinotify.IN_CLOSE_WRITE | pyinotify.IN_CREATE |
+    pyinotify.IN_DELETE | pyinotify.IN_DELETE_SELF |
+    pyinotify.IN_MOVED_FROM | pyinotify.IN_MOVED_TO |
+    pyinotify.IN_MOVE_SELF
+)
+
+class Processor(ProcessEvent):
+    def my_init(self, repo_watcher):
+        self.watcher = repo_watcher
+
+
+class RepoWatcher(repo_watcher.BaseRepoWatcher):
+    def process_event(self, event):
+        path = Path(event.pathname)
+        triggered = self.path_modified(path)
+        if triggered:
+
+            try:
+                relpath = path.relative_to(self.repo_path)
+                log.debug(f'{self.repo_path}: [{event.maskname}] {relpath}')
+            except ValueError:
+                log.debug(f'{self.repo_path}: [{event.maskname}] {path}')
+
+    def exclude_filter(self, path):
+        path = Path(path)
+
+        cpath = path
+        while cpath != self.repo_path:
+            if cpath == self.git_dir:
+                return True
+
+            if cpath.name == '.git':
+                return True
+
+            nextpath = cpath.parent
+            if nextpath == cpath:
+                break
+            cpath = nextpath
+
+        return False
+
+    def setup_watch(self, wm):
+        wm.add_watch(
+            str(self.repo_path),
+            EVENTS,
+            rec = True,
+            auto_add = True,
+            proc_fun = self.process_event,
+            exclude_filter = self.exclude_filter
+        )
+
+        wm.add_watch(
+            str(self.git_dir),
+            EVENTS,
+            rec = False,
+            auto_add = False,
+            proc_fun = self.process_event
+        )
+
+        wm.add_watch(
+            str(self.git_dir / 'refs'),
+            EVENTS,
+            rec = True,
+            auto_add = True,
+            proc_fun = self.process_event
+        )
+
+        wm.add_watch(
+            str(self.git_dir / 'info'),
+            EVENTS,
+            rec = True,
+            auto_add = True,
+            proc_fun = self.process_event
+        )
+
+    @staticmethod
+    def run(repo_watchers):
+        wm = WatchManager()
+        fd = wm.get_fd()
+
+        for watcher in repo_watchers:
+            watcher.setup_watch(wm)
+
+        notifier = Notifier(wm)
+
+        next_check_time = 0
+
+        while True:
+            ctime = time.time()
+            remain = next_check_time - ctime
+
+            ms_sleep = int(max(0, min(5, remain)) * 1000)
+            if notifier.check_events(ms_sleep):
+                notifier.read_events()
+            notifier.process_events()
+
+            if remain <= 0:
+
+                ctime = time.time()
+                next_check_time += 1.0
+                if next_check_time < ctime:
+                    next_check_time = ctime + 1
+
+                for watcher in repo_watchers:
+                    try:
+                        watcher.check()
+                    except Exception:
+                        log.exception(f'ERROR checking {watcher.repo_path}')

git_editlog/repo_watcher.py

@@ -0,0 +1,247 @@
+import sys
+import re
+import time
+import os
+import argparse
+import subprocess
+import traceback
+import logging
+import copy
+from pathlib import Path
+
+from ktpanda import git_helper
+
+log = logging.getLogger(__name__)
+
+EDITLOG_BRANCH = 'editlog'
+EDITLOG_BASE_BRANCH = EDITLOG_BRANCH + '-base'
+
+EXCLUDE_EXT = {'.3mf', '.stl', '.zip', '.jpg', '.jpeg', '.png'}
+
+def gitdir_allow_trigger(relpath):
+    if relpath == 'HEAD':
+        return True
+
+    if relpath.startswith('refs'):
+        if relpath.startswith('refs/heads/editlog'):
+            return False
+        return True
+
+    if relpath.startswith('info'):
+        return True
+
+    return False
+
+class BaseRepoWatcher:
+    def __init__(self, repo_path):
+        self.git = git_helper.Git(repo_path)
+        self.repo_path = self.git.get_toplevel()
+
+        info = self.git.run_capt(['rev-parse', '--show-toplevel', '--git-dir']).split('\n')
+
+        repo_path = self.repo_path = self.git.repo_path = Path(info[0]).absolute()
+        git_dir = self.git_dir = (repo_path / info[1]).absolute()
+
+        self.main_index = git_dir / 'index'
+        self.main_index_lock = git_dir / 'index.lock'
+
+        self.editlog_dir = git_dir / 'editlog'
+        self.editlog_index = self.editlog_dir / 'index'
+        self.editlog_head_file = self.editlog_dir / 'HEAD'
+
+        self.git.env_vars['GIT_INDEX_FILE'] = str(self.editlog_index)
+
+        self.git_with_editdir = copy.copy(self.git)
+        self.git_with_editdir.env_vars = self.git.env_vars | {'GIT_DIR': str(self.editlog_dir)}
+
+        self.do_not_log_if_exists = [
+            git_dir / 'MERGE_HEAD',
+            git_dir / 'rebase-apply',
+            git_dir / 'rebase-merge',
+        ]
+
+        # self.trigger_ignore = {
+        #     str(self.git_dir),
+        #     str(self.editlog_dir),
+        #     str(self.main_index_lock),
+        # }
+
+        self.last_check_event_time = 0
+        self.last_event_time = 1
+        self.deferred_check_time = None
+
+        self.editlog_branch_head = get_branch(self.git, EDITLOG_BRANCH)
+        self.last_head = get_branch(self.git, EDITLOG_BASE_BRANCH)
+
+        if not self.editlog_branch_head:
+            # Create an empty tree to start with
+            empty_blob = self.git.run_capt(['hash-object', '-w', '-t', 'blob', '--stdin'], input=b'')
+            tree_data = f'100644 .gitkeep\0'.encode('ascii') + bytes.fromhex(empty_blob.strip())
+            self.editlog_tree = self.git.run_capt(['hash-object', '-w', '-t', 'tree', '--stdin'], input=tree_data)
+            self.editlog_branch_head = self.git.run_capt(['commit-tree', self.editlog_tree, '-m', 'Empty initial editlog commit'])
+            self.git.run_capt(['branch', '-f', EDITLOG_BRANCH, self.editlog_branch_head])
+        else:
+            self.editlog_tree = self.git.run_capt(['log', '-n', '1', '--format=%T', self.editlog_branch_head])
+
+        self.setup_editlog_dir()
+
+    def setup_editlog_dir(self):
+        dir = self.editlog_dir
+        dir.mkdir(exist_ok=True)
+
+        if not (f := dir / 'commondir').exists():
+            f.write_text('..\n')
+
+        if not (f := dir / 'HEAD').exists():
+            current_head = self.git.run_capt(['rev-parse', '--verify', 'HEAD'])
+            f.write_text(current_head + '\n')
+
+    def path_modified(self, path):
+        try:
+            # ignore all paths under gitdir except specific files
+            relpath = path.relative_to(self.git_dir)
+            if not gitdir_allow_trigger(str(relpath)):
+                return False
+        except ValueError: # path is not relative to gitdir
+            pass
+
+        self.last_event_time = time.time()
+        return True
+
+    def should_check(self):
+        event_time = self.last_event_time
+        if self.last_check_event_time == event_time:
+            return False
+
+        ctime = time.time()
+        time_since_last_event = ctime - event_time
+
+        # Wait for idle of at least 3 seconds before checking
+        if time_since_last_event < 3:
+            # If this is the first time we've seen an event since the last check, note
+            # the time and return False.
+            if self.deferred_check_time is None:
+                self.deferred_check_time = event_time
+                return False
+
+            # If it's been less than 30 seconds after the first deferred check, return False.
+            # Otherwise, continue and force a check.
+            if ctime < self.deferred_check_time + 30:
+                return False
+
+        self.last_check_event_time = event_time
+        return True
+
+    def check(self):
+        if self.main_index_lock.exists():
+            return
+
+        if not self.should_check():
+            return
+
+        print()
+        print(f'{self.repo_path}: possible changes detected, checking git...')
+
+
+        if any(f.exists() for f in self.do_not_log_if_exists):
+            print(f'{self.repo_path}: rebase/merge in progress, not logging')
+            return
+
+        current_head = self.git.run_capt(['rev-parse', '--verify', 'HEAD'])
+
+        # Force our head to be the head of the editlog branch so git status won't try to
+        # read the actual head
+        self.editlog_head_file.write_text(self.editlog_branch_head + '\n')
+
+        # reset our index to editlog head
+        self.git_with_editdir.run(['reset'])
+
+        changes = self.git_with_editdir.status(['--untracked=all', '--ignored=traditional', '--no-renames'])
+
+        add_files = []
+        delete_files = []
+        for relpath, statidx, stattree, renfrom in changes:
+            is_excluded = Path(relpath).suffix.lower() in EXCLUDE_EXT
+            if is_excluded:
+                # If file is excluded, but is not untracked, excluded, or staged for deletion,
+                # then force a deletion.
+                if stattree not in {'D', '?', '!'}:
+                    delete_files.append(relpath)
+            else:
+                if stattree not in {'!'}:
+                    add_files.append(relpath)
+
+
+        if add_files:
+            input = '\0'.join(add_files)
+            self.git_with_editdir.run_capt(['add', '-f', '--pathspec-from-file=-', '--pathspec-file-nul'], input=input)
+
+        if delete_files:
+            input = ''.join(f'0 0000000000000000000000000000000000000000\t{path}\0' for path in delete_files)
+            self.git_with_editdir.run_capt(['update-index', '-z', '--index-info'], input=input)
+
+        tree_hash = self.git.run_capt(['write-tree'])
+
+        if (tree_hash == self.editlog_tree and current_head == self.last_head):
+            print(f'{self.repo_path}: no changes')
+            return
+
+        ctime = time.time()
+        timestamp = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(ctime))
+
+        commit_message = f'editlog auto commit @{timestamp}'
+
+        changed_files = []
+        if self.editlog_tree:
+            changed_files = self.git.run_capt(['diff', '-z', '--name-only', self.editlog_tree, tree_hash]).split('\0')
+            while changed_files and not changed_files[-1]:
+                changed_files.pop()
+
+        commit_subject = []
+        commit_body = []
+
+        if current_head != self.last_head:
+            commit_subject.append(f'head -> {current_head[:10]}')
+
+        if len(changed_files) > 1:
+            commit_subject.append(f'edit {changed_files[0]} [+{len(changed_files) - 1}]')
+            for fn in changed_files[1:10]:
+                commit_body.append(f'   + {fn}')
+            if len(changed_files) >= 11:
+                commit_body.append('   + ...')
+        elif len(changed_files) == 1:
+            commit_subject.append(f'edit {changed_files[0]}')
+
+        commit_subject = ", ".join(commit_subject) + f' @{timestamp}'
+        print(f'{self.repo_path}: changes detected, new tree = {tree_hash}, making commit: {commit_subject}')
+
+        if commit_body:
+            commit_message = [commit_subject, ''] + commit_body
+        else:
+            commit_message = [commit_subject]
+
+        git_args = ['commit-tree', tree_hash, '-m', '\n'.join(commit_message)]
+        if self.editlog_branch_head:
+            git_args.append('-p')
+            git_args.append(self.editlog_branch_head)
+
+        if current_head != self.last_head or not self.editlog_branch_head:
+            git_args.append('-p')
+            git_args.append(current_head)
+
+        new_editlog_head = self.git.run_capt(git_args)
+
+        print(f'{self.repo_path}: created commit {new_editlog_head}')
+        self.git.run(['branch', '-f', EDITLOG_BRANCH, new_editlog_head])
+        if self.last_head != current_head:
+            self.git.run(['branch', '-f', EDITLOG_BASE_BRANCH, current_head])
+
+        self.editlog_branch_head = new_editlog_head
+        self.editlog_tree = tree_hash
+        self.last_head = current_head
+
+def get_branch(git, branch_name):
+    try:
+        return git.run_capt(['rev-parse', '--verify', f'refs/heads/{branch_name}'], print_error=False)
+    except subprocess.CalledProcessError:
+        return None

git_editlog/watchdog_watcher.py

@@ -0,0 +1,61 @@
+import sys
+import re
+import time
+import os
+import argparse
+import subprocess
+import logging
+import traceback
+import copy
+from pathlib import Path
+
+from ktpanda import git_helper
+from watchdog import events, observers
+
+from . import repo_watcher
+
+log = logging.getLogger(__name__)
+
+EVENTS = [
+    events.FileCreatedEvent, events.DirCreatedEvent,
+    events.FileDeletedEvent, events.DirDeletedEvent,
+    events.FileMovedEvent, events.DirMovedEvent,
+    events.FileModifiedEvent, events.DirModifiedEvent,
+]
+
+class RepoWatcher(repo_watcher.BaseRepoWatcher, events.FileSystemEventHandler):
+    def on_any_event(self, event):
+        path = Path(event.src_path)
+        if self.path_modified(path):
+            log.debug(f'{self.repo_path}: {event}')
+
+    def setup_observer(self, observer):
+        observer.schedule(self, self.repo_path, recursive=True, event_filter=EVENTS)
+        if not self.git_dir.is_relative_to(self.repo_path):
+            observer.schedule(self, self.git_dir, recursive=False, event_filter=EVENTS)
+
+    @staticmethod
+    def run(repo_watchers):
+        observer = observers.Observer()
+        for watcher in repo_watchers:
+            watcher.setup_observer(observer)
+
+        observer.start()
+
+        next_check_time = 0
+
+        while True:
+            ctime = time.time()
+            remain = next_check_time - ctime
+            if remain > 0:
+                time.sleep(min(5, remain))
+
+            ctime = time.time()
+            next_check_time = ctime + 1
+
+
+            for watcher in repo_watchers:
+                try:
+                    watcher.check()
+                except Exception:
+                    log.exception(f'ERROR checking {watcher.repo_path}')

git_editlog-1.0.1.dist-info/METADATA

@@ -0,0 +1,22 @@
+Metadata-Version: 2.4
+Name: git-editlog
+Version: 1.0.1
+Summary: Auto commit edit log for Git
+Home-page: https://ktpanda.org/software/git-editlog
+Author: Katie Rust
+Author-email: katie@ktpanda.org
+License: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: ktpanda-modules>=1.0.47
+Requires-Dist: watchdog>=4.0.0; sys_platform != "linux"
+Dynamic: license-file
+
+git_editlog
+===========
+
+Watches a repository for changes, and auto-commits to a branch called 'editlog'.

git_editlog-1.0.1.dist-info/RECORD

@@ -0,0 +1,12 @@
+git_editlog/__init__.py,sha256=bEJJgqdVW0DfyPul3EnXyFiGwFmiA6T2ZDM8X-p5dHA,158
+git_editlog/__main__.py,sha256=5k3OaMoR5NRYRujPvH2LC5tC0qCzaodI_2G_WTcjtHM,1832
+git_editlog/pyinotify.py,sha256=j5A8fbdNJLruflh92mvHnilRki1MTANLUWC2jyzNo_0,88060
+git_editlog/pyinotify_watcher.py,sha256=Iv1928J3txA0oQ-Jx9Zvy0jyp7pNm5Y2yITz_qe1fnc,3213
+git_editlog/repo_watcher.py,sha256=Cny2rRD1p_bTNs85cNnroEKRokH1F65RZVlr5UqMmG8,8914
+git_editlog/watchdog_watcher.py,sha256=Bln_d-XzHGbKInZArK0QB_1t7VLyjhzV1c_XQaEq72g,1693
+git_editlog-1.0.1.dist-info/licenses/LICENSE,sha256=LoQcm7r6ZGThI7UUgEFfPCsGjz3unuyDRcIFIqVFIhE,1074
+git_editlog-1.0.1.dist-info/METADATA,sha256=agsVYEg5YYX2_J_-DcA0k0Wro3svx-NH3OewmfYJlBo,672
+git_editlog-1.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+git_editlog-1.0.1.dist-info/entry_points.txt,sha256=Q_6mNNNHvf3j5xdAwb4gueYS3HzX5KfDGdvko2qpZtE,58
+git_editlog-1.0.1.dist-info/top_level.txt,sha256=Cd5CM3pr3G26WVRXXeE-kQJ6UkobcGcSRlYcS1Po-Fg,12
+git_editlog-1.0.1.dist-info/RECORD,,

git_editlog-1.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

git_editlog-1.0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+git_editlog = git_editlog.__main__:main

git_editlog-1.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,20 @@
+Copyright (C) 2026 Katie Rust (katie@ktpanda.org)
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

git_editlog-1.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+git_editlog