add[patcher]: add diff functionality to the patcher

Author: dhkatz

.github/workflows/diff.yml

@@ -0,0 +1,28 @@
+name: Diff Checker
+
+on:
+  schedule:
+    - cron: '0 0 * * *'
+
+# Check if any previous run
+
+jobs:
+    diff:
+        runs-on: windows-latest
+        steps:
+        - uses: actions/checkout@v4
+          with:
+              fetch-depth: 0
+        - name: Setup Python 2.7
+          uses: LizardByte/setup-python-action@master
+          with:
+            python-version: '2.7'
+        - run: pip install -r requirements.txt
+        - name: Setup IMVU Version
+          run: |
+            $ENV:IMVU_VERSION = $(cat VERSION)
+            echo ("IMVU_VERSION=" + $ENV:IMVU_VERSION) >> $ENV:GITHUB_ENV
+        - name: Echo Versions
+          run: |
+            echo "IMVU_VERSION=${{ env.IMVU_VERSION }}"
+        - run: python -m t5de --diff

.github/workflows/t5de.yml

@@ -55,7 +55,7 @@ jobs:
 
       - name: Patch Installer
         run: |
-          python -m t5de
+          python -m t5de --patch
 
       - name: Install NSIS
         run: |

scripts/version.py

@@ -1,4 +1,7 @@
 import os
+import sys
+import argparse
+
 import requests
 
 from bs4 import BeautifulSoup
@@ -7,6 +10,28 @@
 VERSION_URL = 'https://www.imvu.com/download.php'
 
 if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description='Check for updates')
+    parser.add_argument('--latest', action='store_true', help='Print the latest version')
+    parser.add_argument('--current', action='store_true', help='Print the current version')
+    parser.add_argument('--update', action='store_true', help='Check for updates')
+
+    args = parser.parse_args()
+
+    if args.latest:
+        response = requests.get(VERSION_URL)
+        soup = BeautifulSoup(response.content, 'html.parser')
+        h2 = soup.find('h2', text='IMVU Classic:')
+        b = h2.find_next('b')
+        latest_version = b.text.strip(':')
+        print(latest_version)
+        sys.exit(0)
+
+    if args.current:
+        with open(VERSION_PATH, 'r') as f:
+            version = f.read().strip()
+            print(version)
+            sys.exit(0)
+
     cwd = os.getcwd()
 
     print('READING VERSION: {}'.format(VERSION_PATH))
@@ -25,5 +50,7 @@
 
     if version != latest_version:
         print('UPDATE AVAILABLE')
+        sys.exit(1)
     else:
         print('NO UPDATE AVAILABLE')
+        sys.exit(0)

t5de/Client.py

@@ -4,17 +4,32 @@
 
 import autogui
 import requests
+from bs4 import BeautifulSoup
 
 from typing import List
 
 
+# noinspection PyBroadException
 class Client:
+    """
+    A class to manage the IMVU client
+
+    Attributes:
+        cwd (str): The current working directory
+        version (str): The version of IMVU to manipulate
+    """
+
     BASE_URL = 'https://static-akm.imvu.com/imvufiles/installers/InstallIMVU_{}.exe'
+    VERSION_URL = 'https://www.imvu.com/download.php'
     CLIENT_PATH = '{}/IMVUClient'.format(os.getenv('APPDATA'))
 
-    def __init__(self, cwd, version):
-        self.cwd = cwd
-        self.version = version
+    def __init__(self, version=None, cwd=None):
+        """
+        :param str|None version: The version of IMVU to manipulate, if None, the latest version is used
+        :param str|None cwd: The current working directory
+        """
+        self.cwd = cwd or os.getcwd()
+        self.version = version or self._latest_version()
 
     def __enter__(self):
         return self
@@ -23,27 +38,58 @@ def __exit__(self, exc_type, exc_val, exc_tb):
         self.cleanup()
 
     def download(self):
+        """
+        Download the IMVU client executable if it does not exist
+
+        :return: True if the executable was downloaded, False otherwise
+        :rtype: bool
+        """
         print('DOWNLOADING: IMVU {}'.format(self.version))
         if os.path.isfile(os.path.join(self.cwd, 'InstallIMVU_%s.exe' % self.version)):
-            return
+            return False
 
         r = requests.get(Client.BASE_URL.format(self.version))
 
         with open(os.path.join(self.cwd, 'InstallIMVU_%s.exe' % self.version), 'wb') as f:
             f.write(r.content)
 
-    def install(self):
+        return True
+
+    def install(self, download=False):
+        """
+        Install the IMVU client using the downloaded executable
+        :param bool download: Download the executable if it does not exist
+        """
+        if not os.path.isfile(os.path.join(self.cwd, 'InstallIMVU_%s.exe' % self.version)):
+            if download:
+                self.download()
+            else:
+                raise IOError('Could not find InstallIMVU_{}.exe'.format(self.version))
+
         print('INSTALLING: IMVU {}'.format(self.version))
         autogui.open(os.path.join(self.cwd, 'InstallIMVU_%s.exe' % self.version), setActive=False)
-        autogui.setWindow('IMVU Setup')
-        autogui.click('Install', 0, 4)
+        attempts = 0
+        while attempts < 5:
+            attempts += 1
+            try:
+                autogui.setWindow('IMVU Setup')
+                autogui.click('Install', 0, 4)
+                break
+            except Exception:
+                if attempts > 5:
+                    raise RuntimeError('Could not automate IMVU install! Failed to find Setup window.')
+                print('SLEEPING: 5 SECONDS...')
+                time.sleep(5)
         print('SLEEPING: 15 SECONDS...')
         time.sleep(15)
 
         attempts = 0
         while attempts < 5:
             attempts += 1
             try:
+                if autogui.exists('Update Available'):
+                    autogui.setWindow('Update Available')
+                    autogui.click('Close', 0, 4)
                 autogui.setWindow('IMVU Login')
                 autogui.click('Close', 0, 4)
                 break
@@ -68,10 +114,13 @@ def copy(self):
 
     def patch(self, patchers, dry_run=False):
         """
-        :param List patchers:
-        :param dry_run:
-        :return:
+        Patch the IMVU client
+        :param List patchers: A list of patchers to run
+        :param bool dry_run: Do not apply patches, only simulate
         """
+        if not os.path.isdir(os.path.join(self.cwd, 'IMVUClient')):
+            raise IOError('Could not find IMVUClient directory')
+
         for Patcher in patchers:
             patcher = Patcher(self.cwd)
             patcher.setup()
@@ -83,3 +132,71 @@ def cleanup(self):
         executable = os.path.join(self.cwd, 'InstallIMVU_%s.exe' % self.version)
         if os.path.isfile(executable):
             os.remove(executable)
+
+    def diff(self, generators, version=None):
+        """
+        :param List[constructor] generators: A list of diff generators
+        :param str version: The version to diff against, if None, the latest version is used
+        """
+        if version is None:
+            version = self._latest_version()
+
+        if self.version == version:
+            print('SKIPPED: IMVU {} and IMVU {} are the same'.format(self.version, version))
+            return
+
+        if os.path.isdir(os.path.join(self.cwd, 'IMVUClient-{}'.format(self.version))):
+            shutil.rmtree(os.path.join(self.cwd, 'IMVUClient-{}'.format(self.version)))
+
+        print('DIFFING: IMVU {} and IMVU {}'.format(self.version, version))
+
+        # Download the previous version first
+        self.download()
+        self.install()
+        self.copy()
+
+        # Rename the previous version to IMVUClient-{version}
+        if os.path.isdir(os.path.join(self.cwd, 'IMVUClient-{}'.format(self.version))):
+            shutil.rmtree(os.path.join(self.cwd, 'IMVUClient-{}'.format(self.version)))
+
+        shutil.move(os.path.join(self.cwd, 'IMVUClient'), os.path.join(self.cwd, 'IMVUClient-{}'.format(self.version)))
+
+        # Download the current version
+        current_version = self.version
+        self.version = version
+
+        self.download()
+        self.install()
+        self.copy()
+
+        # Rename the current version to IMVUClient-{current}
+        if os.path.isdir(os.path.join(self.cwd, 'IMVUClient-{}'.format(version))):
+            shutil.rmtree(os.path.join(self.cwd, 'IMVUClient-{}'.format(version)))
+
+        shutil.move(os.path.join(self.cwd, 'IMVUClient'), os.path.join(self.cwd, 'IMVUClient-{}'.format(version)))
+
+        self.version = current_version
+
+        previous_cwd = os.path.join(self.cwd, 'IMVUClient-{}'.format(self.version))
+        current_cwd = os.path.join(self.cwd, 'IMVUClient-{}'.format(version))
+
+        for Generator in generators:
+            print('PROCESSING DIFF GENERATOR: {}'.format(Generator.__name__))
+            with Generator(self.cwd, self.version, version, previous_cwd, current_cwd) as generator:
+                generator.diff()
+
+        executable = os.path.join(self.cwd, 'InstallIMVU_%s.exe' % version)
+        if os.path.isfile(executable):
+            os.remove(executable)
+
+    def _latest_version(self):
+        """
+        Get the latest version of IMVU
+        :return: The latest version of IMVU
+        :rtype: str
+        """
+        response = requests.get(Client.VERSION_URL)
+        soup = BeautifulSoup(response.content, 'html.parser')
+        h2 = soup.find('h2', text='IMVU Classic:')
+        b = h2.find_next('b')
+        return b.text.strip(':')

t5de/__main__.py

@@ -3,24 +3,50 @@
 import os
 import sys
 import dotenv
+import argparse
 
 from .patchers import InterfacePatcher, PythonPatcher, ChecksumPatcher
+from .diff import InterfaceDiff, PythonDiff
 from . import Client
 
 
 def main():
-    IMVU_VERSION = os.getenv('IMVU_VERSION')
-    T5DE_VERSION = os.getenv('T5DE_VERSION')
+    imvu_version = os.getenv('IMVU_VERSION')
+    t5de_version = os.getenv('T5DE_VERSION')
 
-    print('Running T5DE patcher v%s for IMVU v%s' % (T5DE_VERSION, IMVU_VERSION))
+    if not imvu_version:
+        print('IMVU_VERSION environment variable not set')
+        return 1
 
-    with Client(os.getcwd(), IMVU_VERSION) as patcher:
-        patcher.download()
-        patcher.install()
-        patcher.copy()
-        patcher.patch(patchers=[InterfacePatcher, PythonPatcher, ChecksumPatcher], dry_run=False)
+    if not t5de_version:
+        print('T5DE_VERSION environment variable not set')
+        return 1
+
+    print('Running T5DE patcher v%s for IMVU v%s' % (t5de_version, imvu_version))
+
+    parser = argparse.ArgumentParser(prog='t5de', description='The T5DE patcher for IMVU')
+    parser.add_argument('--dry-run', action='store_true', help='Perform a dry run')
+    parser.add_argument('--diff', help='Generate a diff between two IMVU versions', const='latest', nargs='?', type=str)
+    parser.add_argument('--version', help='The current IMVU version')
+    parser.add_argument('--patch', action='store_true', help='Patch the current IMVU version')
+
+    args = parser.parse_args()
+
+    if args.diff:
+        version = None if args.diff == 'latest' else args.diff
+        with Client(args.version or imvu_version) as client:
+            client.diff(generators=[InterfaceDiff, PythonDiff], version=version)
+
+    if args.patch:
+        with Client(args.version or imvu_version) as patcher:
+            patcher.download()
+            patcher.install()
+            patcher.copy()
+            patcher.patch(patchers=[InterfacePatcher, PythonPatcher, ChecksumPatcher], dry_run=False)
+
+    return 0
 
 
 if __name__ == '__main__':
-    dotenv.load_dotenv()
+    dotenv.load_dotenv(override=True)
     sys.exit(main())

t5de/diff/Diff.py

@@ -0,0 +1,54 @@
+from abc import ABCMeta, abstractmethod
+
+
+class Diff(object):
+    __metaclass__ = ABCMeta
+    """
+    Base class for diff generators
+
+    Attributes:
+        cwd (str): The current working directory
+        previous (str): The previous version
+        current (str): The current version
+        previous_cwd (str): The previous version's working directory
+        current_cwd (str): The current version's working directory
+    """
+
+    def __init__(self, cwd, previous, current, previous_cwd, current_cwd):
+        """
+        :param str cwd:
+        :param str previous:
+        :param str current:
+        :param str previous_cwd:
+        :param str current_cwd:
+        """
+        self.cwd = cwd
+        self.previous = previous
+        self.current = current
+        self.previous_cwd = previous_cwd
+        self.current_cwd = current_cwd
+
+    @abstractmethod
+    def setup(self):
+        raise NotImplementedError
+
+    @abstractmethod
+    def diff(self):
+        """
+        Generate a diff between the previous and current versions
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def cleanup(self):
+        raise NotImplementedError
+
+    def __enter__(self):
+        self.setup()
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self.cleanup()
+
+    def _diff(self):
+        self.diff()