Changed reproducibility info to use path to Python file that is run

swansonk14 · swansonk14 · commit 980738499ee8 · 2021-08-15T21:30:19.000+01:00
diff --git a/README.md b/README.md
@@ -373,12 +373,12 @@ Specifically, Tap has a method called `get_reproducibility_info` that returns a
     - The time when the command was run
     - Ex. `Thu Aug 15 00:09:13 2019`
 - Git root
-    - The root of the git repo containing the code
+    - The root of the git repo containing the code that was run
     - Ex. `/Users/swansonk14/typed-argument-parser`
 - Git url
     - The url to the git repo, specifically pointing to the current git hash (i.e. the hash of HEAD in the local repo)
     - Ex. [https://github.com/swansonk14/typed-argument-parser/tree/446cf046631d6bdf7cab6daec93bf7a02ac00998](https://github.com/swansonk14/typed-argument-parser/tree/446cf046631d6bdf7cab6daec93bf7a02ac00998)
-- Uncommited changes
+- Uncommitted changes
     - Whether there are any uncommitted changes in the git repo (i.e. whether the code is different from the code at the above git hash)
     - Ex. `True` or `False`
 
diff --git a/tap/tap.py b/tap/tap.py
@@ -3,6 +3,7 @@
 from copy import deepcopy
 from functools import partial
 import json
+from pathlib import Path
 from pprint import pformat
 from shlex import quote
 import sys
@@ -15,12 +16,9 @@
 from tap.utils import (
     get_class_variables,
     get_argument_name,
-    get_git_root,
     get_dest,
-    get_git_url,
     get_origin,
-    has_git,
-    has_uncommitted_changes,
+    GitInfo,
     is_option_arg,
     type_to_str,
     get_literals,
@@ -337,7 +335,7 @@ def configure(self) -> None:
         pass
 
     @staticmethod
-    def get_reproducibility_info() -> Dict[str, str]:
+    def get_reproducibility_info(repo_path: Optional[str] = None) -> Dict[str, str]:
         """Gets a dictionary of reproducibility information.
 
         Reproducibility information always includes:
@@ -350,27 +348,37 @@ def get_reproducibility_info() -> Dict[str, str]:
                    Ex. https://github.com/swansonk14/rationale-alignment/tree/<hash>
         - git_has_uncommitted_changes: Whether the current git repo has uncommitted changes.
 
+        :param repo_path: Path to the git repo to examine for reproducibility info.
+                          If None, uses the git repo of the Python file that is run.
         :return: A dictionary of reproducibility information.
         """
+        # Get the path to the Python file that is being run
+        if repo_path is None:
+            repo_path = (Path.cwd() / Path(sys.argv[0]).parent).resolve()
+
         reproducibility = {
             'command_line': f'python {" ".join(quote(arg) for arg in sys.argv)}',
             'time': time.strftime('%c')
         }
 
-        if has_git():
-            reproducibility['git_root'] = get_git_root()
-            reproducibility['git_url'] = get_git_url(commit_hash=True)
-            reproducibility['git_has_uncommitted_changes'] = has_uncommitted_changes()
+        git_info = GitInfo(repo_path=repo_path)
+
+        if git_info.has_git():
+            reproducibility['git_root'] = git_info.get_git_root()
+            reproducibility['git_url'] = git_info.get_git_url(commit_hash=True)
+            reproducibility['git_has_uncommitted_changes'] = git_info.has_uncommitted_changes()
 
         return reproducibility
 
-    def _log_all(self) -> Dict[str, Any]:
+    def _log_all(self, repo_path: Optional[str] = None) -> Dict[str, Any]:
         """Gets all arguments along with reproducibility information.
 
+        :param repo_path: Path to the git repo to examine for reproducibility info.
+                          If None, uses the git repo of the Python file that is run.
         :return: A dictionary containing all arguments along with reproducibility information.
         """
         arg_log = self.as_dict()
-        arg_log['reproducibility'] = self.get_reproducibility_info()
+        arg_log['reproducibility'] = self.get_reproducibility_info(repo_path=repo_path)
 
         return arg_log
 
@@ -590,12 +598,17 @@ def from_dict(self, args_dict: Dict[str, Any], skip_unsettable: bool = False) ->
 
         return self
 
-    def save(self, path: str, with_reproducibility: bool = True, skip_unpicklable: bool = False) -> None:
+    def save(self,
+             path: str, with_reproducibility: bool = True,
+             skip_unpicklable: bool = False,
+             repo_path: Optional[str] = None) -> None:
         """Saves the arguments and reproducibility information in JSON format, pickling what can't be encoded.
 
         :param path: Path to the JSON file where the arguments will be saved.
         :param with_reproducibility: If True, adds a "reproducibility" field with information (e.g. git hash)
                                      to the JSON file.
+        :param repo_path: Path to the git repo to examine for reproducibility info.
+                          If None, uses the git repo of the Python file that is run.
         :param skip_unpicklable: If True, does not save attributes whose values cannot be pickled.
         """
         with open(path, 'w') as f:
@@ -605,14 +618,17 @@ def save(self, path: str, with_reproducibility: bool = True, skip_unpicklable: b
     def load(self,
              path: str,
              check_reproducibility: bool = False,
-             skip_unsettable: bool = False) -> TapType:
+             skip_unsettable: bool = False,
+             repo_path: Optional[str] = None) -> TapType:
         """Loads the arguments in JSON format. Note: Due to JSON, tuples are loaded as lists.
 
         :param path: Path to the JSON file where the arguments will be loaded from.
         :param check_reproducibility: When True, raises an error if the loaded reproducibility
                                       information doesn't match the current reproducibility information.
         :param skip_unsettable: When True, skips attributes that cannot be set in the Tap object,
                                 e.g. properties without setters.
+        :param repo_path: Path to the git repo to examine for reproducibility info.
+                          If None, uses the git repo of the Python file that is run.
         :return: Returns self.
         """
         with open(path) as f:
@@ -621,7 +637,7 @@ def load(self,
         # Remove loaded reproducibility information since it is no longer valid
         saved_reproducibility_data = args_dict.pop('reproducibility', None)
         if check_reproducibility:
-            current_reproducibility_data = self.get_reproducibility_info()
+            current_reproducibility_data = self.get_reproducibility_info(repo_path=repo_path)
             enforce_reproducibility(saved_reproducibility_data, current_reproducibility_data, path)
 
         self.from_dict(args_dict, skip_unsettable=skip_unsettable)
diff --git a/tap/utils.py b/tap/utils.py
@@ -31,7 +31,7 @@
 PRIMITIVES = (str, int, float, bool)
 
 
-def check_output(command: List[str], suppress_stderr: bool = True) -> str:
+def check_output(command: List[str], suppress_stderr: bool = True, **kwargs) -> str:
     """Runs subprocess.check_output and returns the result as a string.
 
     :param command: A list of strings representing the command to run on the command line.
@@ -40,77 +40,79 @@ def check_output(command: List[str], suppress_stderr: bool = True) -> str:
     """
     with open(os.devnull, 'w') as devnull:
         devnull = devnull if suppress_stderr else None
-        output = subprocess.check_output(command, stderr=devnull).decode('utf-8').strip()
+        output = subprocess.check_output(command, stderr=devnull, **kwargs).decode('utf-8').strip()
     return output
 
 
-def has_git() -> bool:
-    """Returns whether git is installed.
+class GitInfo:
+    """Class with helper methods for extracting information about a git repo."""
 
-    :return: True if git is installed, False otherwise.
-    """
-    try:
-        output = check_output(['git', 'rev-parse', '--is-inside-work-tree'])
-        return output == 'true'
-    except (FileNotFoundError, subprocess.CalledProcessError):
-        return False
+    def __init__(self, repo_path: str):
+        self.repo_path = repo_path
 
+    def has_git(self) -> bool:
+        """Returns whether git is installed.
 
-def get_git_root() -> str:
-    """Gets the root directory of the git repo where the command is run.
-
-    :return: The root directory of the current git repo.
-    """
-    return check_output(['git', 'rev-parse', '--show-toplevel'])
-
+        :return: True if git is installed, False otherwise.
+        """
+        try:
+            output = check_output(['git', 'rev-parse', '--is-inside-work-tree'], cwd=self.repo_path)
+            return output == 'true'
+        except (FileNotFoundError, subprocess.CalledProcessError):
+            return False
 
-def get_git_url(commit_hash: bool = True) -> str:
-    """Gets the https url of the git repo where the command is run.
+    def get_git_root(self) -> str:
+        """Gets the root directory of the git repo where the command is run.
 
-    :param commit_hash: If True, the url links to the latest local git commit hash.
-    If False, the url links to the general git url.
-    :return: The https url of the current git repo.
-    """
-    # Get git url (either https or ssh)
-    try:
-        url = check_output(['git', 'remote', 'get-url', 'origin'])
-    except subprocess.CalledProcessError:
-        # For git versions <2.0
-        url = check_output(['git', 'config', '--get', 'remote.origin.url'])
+        :return: The root directory of the current git repo.
+        """
+        return check_output(['git', 'rev-parse', '--show-toplevel'], cwd=self.repo_path)
 
-    # Remove .git at end
-    url = url[:-len('.git')]
+    def get_git_url(self, commit_hash: bool = True) -> str:
+        """Gets the https url of the git repo where the command is run.
 
-    # Convert ssh url to https url
-    m = re.search('git@(.+):', url)
-    if m is not None:
-        domain = m.group(1)
-        path = url[m.span()[1]:]
-        url = f'https://{domain}/{path}'
+        :param commit_hash: If True, the url links to the latest local git commit hash.
+        If False, the url links to the general git url.
+        :return: The https url of the current git repo.
+        """
+        # Get git url (either https or ssh)
+        try:
+            url = check_output(['git', 'remote', 'get-url', 'origin'], cwd=self.repo_path)
+        except subprocess.CalledProcessError:
+            # For git versions <2.0
+            url = check_output(['git', 'config', '--get', 'remote.origin.url'], cwd=self.repo_path)
 
-    if commit_hash:
-        # Add tree and hash of current commit
-        url = f'{url}/tree/{get_git_hash()}'
+        # Remove .git at end
+        url = url[:-len('.git')]
 
-    return url
+        # Convert ssh url to https url
+        m = re.search('git@(.+):', url)
+        if m is not None:
+            domain = m.group(1)
+            path = url[m.span()[1]:]
+            url = f'https://{domain}/{path}'
 
+        if commit_hash:
+            # Add tree and hash of current commit
+            url = f'{url}/tree/{self.get_git_hash()}'
 
-def get_git_hash() -> str:
-    """Gets the git hash of HEAD of the git repo where the command is run.
+        return url
 
-    :return: The git hash of HEAD of the current git repo.
-    """
-    return check_output(['git', 'rev-parse', 'HEAD'])
+    def get_git_hash(self) -> str:
+        """Gets the git hash of HEAD of the git repo where the command is run.
 
+        :return: The git hash of HEAD of the current git repo.
+        """
+        return check_output(['git', 'rev-parse', 'HEAD'], cwd=self.repo_path)
 
-def has_uncommitted_changes() -> bool:
-    """Returns whether there are uncommitted changes in the git repo where the command is run.
+    def has_uncommitted_changes(self) -> bool:
+        """Returns whether there are uncommitted changes in the git repo where the command is run.
 
-    :return: True if there are uncommitted changes in the current git repo, False otherwise.
-    """
-    status = check_output(['git', 'status'])
+        :return: True if there are uncommitted changes in the current git repo, False otherwise.
+        """
+        status = check_output(['git', 'status'], cwd=self.repo_path)
 
-    return not status.endswith(NO_CHANGES_STATUS)
+        return not status.endswith(NO_CHANGES_STATUS)
 
 
 def type_to_str(type_annotation: Union[type, Any]) -> str:
diff --git a/tests/test_utils.py b/tests/test_utils.py
@@ -1,7 +1,6 @@
 from collections import OrderedDict
 import json
 import os
-import platform
 import subprocess
 from tempfile import TemporaryDirectory
 from typing import Any, Callable, List, Dict, Set, Tuple, Union
@@ -10,12 +9,9 @@
 from typing_extensions import Literal
 
 from tap.utils import (
-    has_git,
     get_class_column,
     get_class_variables,
-    get_git_root,
-    get_git_url,
-    has_uncommitted_changes,
+    GitInfo,
     type_to_str,
     get_literals,
     TupleTypeEnforcer,
@@ -37,6 +33,7 @@ def setUp(self) -> None:
         subprocess.check_output(['touch', 'README.md'])
         subprocess.check_output(['git', 'add', 'README.md'])
         subprocess.check_output(['git', 'commit', '-m', 'Initial commit'])
+        self.git_info = GitInfo(repo_path=self.temp_dir.name)
 
     def tearDown(self) -> None:
         os.chdir(self.prev_dir)
@@ -49,72 +46,74 @@ def tearDown(self) -> None:
         self.temp_dir.cleanup()
 
     def test_has_git_true(self) -> None:
-        self.assertTrue(has_git())
+        self.assertTrue(self.git_info.has_git())
 
     def test_has_git_false(self) -> None:
         with TemporaryDirectory() as temp_dir_no_git:
             os.chdir(temp_dir_no_git)
-            self.assertFalse(has_git())
+            self.git_info.repo_path = temp_dir_no_git
+            self.assertFalse(self.git_info.has_git())
+            self.git_info.repo_path = self.temp_dir.name
             os.chdir(self.temp_dir.name)
 
     def test_get_git_root(self) -> None:
         # Ideally should be self.temp_dir.name == get_git_root() but the OS may add a prefix like /private
-        self.assertTrue(get_git_root().endswith(self.temp_dir.name.replace('\\', '/')))
+        self.assertTrue(self.git_info.get_git_root().endswith(self.temp_dir.name.replace('\\', '/')))
 
     def test_get_git_root_subdir(self) -> None:
         subdir = os.path.join(self.temp_dir.name, 'subdir')
         os.makedirs(subdir)
         os.chdir(subdir)
 
         # Ideally should be self.temp_dir.name == get_git_root() but the OS may add a prefix like /private
-        self.assertTrue(get_git_root().endswith(self.temp_dir.name.replace('\\', '/')))
+        self.assertTrue(self.git_info.get_git_root().endswith(self.temp_dir.name.replace('\\', '/')))
 
         os.chdir(self.temp_dir.name)
 
     def test_get_git_url_https(self) -> None:
-        self.assertEqual(get_git_url(commit_hash=False), self.url)
+        self.assertEqual(self.git_info.get_git_url(commit_hash=False), self.url)
 
     def test_get_git_url_https_hash(self) -> None:
         url = f'{self.url}/tree/'
-        self.assertEqual(get_git_url(commit_hash=True)[:len(url)], url)
+        self.assertEqual(self.git_info.get_git_url(commit_hash=True)[:len(url)], url)
 
     def test_get_git_url_ssh(self) -> None:
         subprocess.run(['git', 'remote', 'set-url', 'origin', 'git@github.com:test_account/test_repo.git'])
-        self.assertEqual(get_git_url(commit_hash=False), self.url)
+        self.assertEqual(self.git_info.get_git_url(commit_hash=False), self.url)
 
     def test_get_git_url_ssh_hash(self) -> None:
         subprocess.run(['git', 'remote', 'set-url', 'origin', 'git@github.com:test_account/test_repo.git'])
         url = f'{self.url}/tree/'
-        self.assertEqual(get_git_url(commit_hash=True)[:len(url)], url)
+        self.assertEqual(self.git_info.get_git_url(commit_hash=True)[:len(url)], url)
 
     def test_get_git_url_https_enterprise(self) -> None:
         true_url = 'https://github.tap.com/test_account/test_repo'
         subprocess.run(['git', 'remote', 'set-url', 'origin', f'{true_url}.git'])
-        self.assertEqual(get_git_url(commit_hash=False), true_url)
+        self.assertEqual(self.git_info.get_git_url(commit_hash=False), true_url)
 
     def test_get_git_url_https_hash_enterprise(self) -> None:
         true_url = 'https://github.tap.com/test_account/test_repo'
         subprocess.run(['git', 'remote', 'set-url', 'origin', f'{true_url}.git'])
         url = f'{true_url}/tree/'
-        self.assertEqual(get_git_url(commit_hash=True)[:len(url)], url)
+        self.assertEqual(self.git_info.get_git_url(commit_hash=True)[:len(url)], url)
 
     def test_get_git_url_ssh_enterprise(self) -> None:
         true_url = 'https://github.tap.com/test_account/test_repo'
         subprocess.run(['git', 'remote', 'set-url', 'origin', 'git@github.tap.com:test_account/test_repo.git'])
-        self.assertEqual(get_git_url(commit_hash=False), true_url)
+        self.assertEqual(self.git_info.get_git_url(commit_hash=False), true_url)
 
     def test_get_git_url_ssh_hash_enterprise(self) -> None:
         true_url = 'https://github.tap.com/test_account/test_repo'
         subprocess.run(['git', 'remote', 'set-url', 'origin', 'git@github.tap.com:test_account/test_repo.git'])
         url = f'{true_url}/tree/'
-        self.assertEqual(get_git_url(commit_hash=True)[:len(url)], url)
+        self.assertEqual(self.git_info.get_git_url(commit_hash=True)[:len(url)], url)
 
     def test_has_uncommitted_changes_false(self) -> None:
-        self.assertFalse(has_uncommitted_changes())
+        self.assertFalse(self.git_info.has_uncommitted_changes())
 
     def test_has_uncommited_changes_true(self) -> None:
         subprocess.run(['touch', 'main.py'])
-        self.assertTrue(has_uncommitted_changes())
+        self.assertTrue(self.git_info.has_uncommitted_changes())
 
 
 class TypeToStrTests(TestCase):
