codexctl 1.1.0__tar.gz → 1.2.1__tar.gz

{codexctl-1.1.0 → codexctl-1.2.1}/PKG-INFO

@@ -1,20 +1,22 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: codexctl
-Version: 1.1.0
+Version: 1.2.1
 Summary: Automated update managment for the ReMarkable tablet
 License: GPLv3
+License-File: LICENSE
 Author: Jayy001
 Author-email: github@skii.dev
-Requires-Python: >=3.12,<4.0
+Requires-Python: >=3.12,<3.14
 Classifier: License :: Other/Proprietary License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
-Requires-Dist: loguru (==0.7.2)
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: loguru (==0.7.3)
 Requires-Dist: paramiko (==3.4.1)
 Requires-Dist: psutil (==6.0.0)
-Requires-Dist: remarkable-update-fuse (==1.1.2) ; sys_platform == "linux"
-Requires-Dist: remarkable-update-image (==1.1.3) ; sys_platform != "linux"
-Requires-Dist: requests (==2.31.0)
+Requires-Dist: remarkable-update-fuse (==1.3) ; sys_platform == "linux"
+Requires-Dist: remarkable-update-image (==1.3) ; sys_platform != "linux"
+Requires-Dist: requests (==2.32.4)
 Description-Content-Type: text/markdown
 
 
@@ -22,11 +24,15 @@ Description-Content-Type: text/markdown
 # Codexctl
 A utility program that helps to manage the remarkable device version utilizing [ddvks update server](https://github.com/ddvk/remarkable-update) 
 
-## Caveat for downgrading to a version below 3.11 
+## Caveat for downgrading from 3.11.2.5 or greater to a version less than 3.11.2.5
 
-If your reMarkable device is above 3.11 and you want to downgrade to a version below 3.11, codexctl cannot do this currently. Please refer to #71 for manual instructions.
+If your reMarkable device is at or above 3.11.2.5 and you want to downgrade to a version below 3.11.2.5, codexctl cannot do this currently. Please refer to https://github.com/Jayy001/codexctl/issues/95#issuecomment-2305529048 for manual instructions.
 
-## Installation 
+## Paper Pro bootloader updates
+
+When downgrading a Paper Pro device across the 3.20/3.22 firmware boundary, codexctl automatically handles bootloader updates. It will download the current version's firmware if needed and extract the necessary bootloader files (`update-bootloader.sh` and `imx-boot`) to ensure a safe downgrade.
+
+## Installation
 
 You can find pre-compiled binaries on the [releases](https://github.com/Jayy001/codexctl/releases/) page. This includes a build for the reMarkable itself, as well as well as builds for linux, macOS, and Windows. Alternatively, you can install directly from pypi with `pip install codexctl`. Codexctl currently only has support for a **command line interfaces** but a graphical interface is soon to come.
 
@@ -44,9 +50,9 @@ positional arguments:
     install             Install the specified version (will download if not available on the device)
     download            Download the specified version firmware file
     backup              Download remote files to local directory
-    cat                 Cat the contents of a file inside a firmware image
+    cat                 Cat the contents of a file inside a firmwareimage
     ls                  List files inside a firmware image
-    extract             Extract the specified version firmware file
+    extract             Extract the specified version update file
     mount               Mount the specified version firmware filesystem
     upload              Upload folder/files to device (pdf only)
     status              Get the current version of the device and other information
@@ -69,18 +75,27 @@ codexctl install latest
 ```
 - Downloading rmpp version 3.15.4.2 to a folder named `out` and then installing it
 ```
-codexctl download 3.15.4.2 -hw rmpp -o out
+codexctl download 3.15.4.2 --hardware rmpp -o out
 codexctl install ./out/remarkable-ct-prototype-image-3.15.4.2-ferrari-public.swu
 ```
+- Downloading rmppm version 3.23.0.64 to a folder named `out` and then installing it
+```
+codexctl download 3.23.0.64 --hardware rmppm -o out
+codexctl install ./out/remarkable-production-image-3.23.0.64-chiappa-public.swu
+```
 - Backing up all documents to the cwd
 ```
 codexctl backup 
 ```
+- Backing up modified/newer documents only, overwrites out-of-date files on disk
+```
+codexctl backup --incremental
+```
 - Backing up only documents in a folder named "FM" to cwd, without overwriting any current files
 ```
 codexctl backup -l root -r FM --no-recursion --no-overwrite
 ```
-- Getting the version of the device and then switching to previous version (restore only for rm1/rm2)
+- Getting the version of the device and then switching to previous version
 ```
 codexctl status
 codexctl restore
@@ -90,7 +105,8 @@ codexctl restore
 codexctl download 3.8.0.1944 --hardware rm2
 codexctl cat 3.8.0.1944_reMarkable2-7eGpAv7sYB.signed /etc/version
 ```
-
-
-
+- Extract the filesystem image of an upgrade file as a file named `extracted`
+```
+codexctl extract remarkable-production-image-3.22.0.64-ferrari-public.swu -o extracted
+```
 

{codexctl-1.1.0 → codexctl-1.2.1}/README.md

@@ -3,11 +3,15 @@
 # Codexctl
 A utility program that helps to manage the remarkable device version utilizing [ddvks update server](https://github.com/ddvk/remarkable-update) 
 
-## Caveat for downgrading to a version below 3.11 
+## Caveat for downgrading from 3.11.2.5 or greater to a version less than 3.11.2.5
 
-If your reMarkable device is above 3.11 and you want to downgrade to a version below 3.11, codexctl cannot do this currently. Please refer to #71 for manual instructions.
+If your reMarkable device is at or above 3.11.2.5 and you want to downgrade to a version below 3.11.2.5, codexctl cannot do this currently. Please refer to https://github.com/Jayy001/codexctl/issues/95#issuecomment-2305529048 for manual instructions.
 
-## Installation 
+## Paper Pro bootloader updates
+
+When downgrading a Paper Pro device across the 3.20/3.22 firmware boundary, codexctl automatically handles bootloader updates. It will download the current version's firmware if needed and extract the necessary bootloader files (`update-bootloader.sh` and `imx-boot`) to ensure a safe downgrade.
+
+## Installation
 
 You can find pre-compiled binaries on the [releases](https://github.com/Jayy001/codexctl/releases/) page. This includes a build for the reMarkable itself, as well as well as builds for linux, macOS, and Windows. Alternatively, you can install directly from pypi with `pip install codexctl`. Codexctl currently only has support for a **command line interfaces** but a graphical interface is soon to come.
 
@@ -25,9 +29,9 @@ positional arguments:
     install             Install the specified version (will download if not available on the device)
     download            Download the specified version firmware file
     backup              Download remote files to local directory
-    cat                 Cat the contents of a file inside a firmware image
+    cat                 Cat the contents of a file inside a firmwareimage
     ls                  List files inside a firmware image
-    extract             Extract the specified version firmware file
+    extract             Extract the specified version update file
     mount               Mount the specified version firmware filesystem
     upload              Upload folder/files to device (pdf only)
     status              Get the current version of the device and other information
@@ -50,18 +54,27 @@ codexctl install latest
 ```
 - Downloading rmpp version 3.15.4.2 to a folder named `out` and then installing it
 ```
-codexctl download 3.15.4.2 -hw rmpp -o out
+codexctl download 3.15.4.2 --hardware rmpp -o out
 codexctl install ./out/remarkable-ct-prototype-image-3.15.4.2-ferrari-public.swu
 ```
+- Downloading rmppm version 3.23.0.64 to a folder named `out` and then installing it
+```
+codexctl download 3.23.0.64 --hardware rmppm -o out
+codexctl install ./out/remarkable-production-image-3.23.0.64-chiappa-public.swu
+```
 - Backing up all documents to the cwd
 ```
 codexctl backup 
 ```
+- Backing up modified/newer documents only, overwrites out-of-date files on disk
+```
+codexctl backup --incremental
+```
 - Backing up only documents in a folder named "FM" to cwd, without overwriting any current files
 ```
 codexctl backup -l root -r FM --no-recursion --no-overwrite
 ```
-- Getting the version of the device and then switching to previous version (restore only for rm1/rm2)
+- Getting the version of the device and then switching to previous version
 ```
 codexctl status
 codexctl restore
@@ -71,6 +84,7 @@ codexctl restore
 codexctl download 3.8.0.1944 --hardware rm2
 codexctl cat 3.8.0.1944_reMarkable2-7eGpAv7sYB.signed /etc/version
 ```
-
-
-
+- Extract the filesystem image of an upgrade file as a file named `extracted`
+```
+codexctl extract remarkable-production-image-3.22.0.64-ferrari-public.swu -o extracted
+```

{codexctl-1.1.0 → codexctl-1.2.1}/codexctl/__init__.py

@@ -10,6 +10,7 @@ import shutil
 import json
 import re
 
+from typing import cast
 from os import listdir
 
 try:
@@ -22,6 +23,7 @@ if importlib.util.find_spec("requests") is None:
         "Requests is required for accessing remote files. Please install it."
     )
 
+from .device import HardwareType
 from .updates import UpdateManager
 
 
@@ -49,12 +51,13 @@ class Manager:
             args: What arguments to pass into the function
         """
 
-        if "remarkable" not in self.device:
-            remarkable_version = args.get("hardware")
-        else:
-            remarkable_version = self.device
+        try:
+            remarkable_version = HardwareType.parse(self.device)
+        except ValueError:
+            hw = args.get("hardware")
+            remarkable_version = HardwareType.parse(hw) if hw else None
 
-        version = args.get("version", None)
+        version = cast(str | None, args.get("version", None))
 
         if remarkable_version:
             if version == "latest":
@@ -64,16 +67,30 @@ class Manager:
 
         ### Download functionalities
         if function == "list":
-            remarkable_pp_versions = "\n".join(self.updater.remarkablepp_versions.keys())
+            remarkable_pp_versions = "\n".join(
+                self.updater.remarkablepp_versions.keys()
+            )
+            remarkable_ppm_versions = "\n".join(
+                self.updater.remarkableppm_versions.keys()
+            )
             remarkable_2_versions = "\n".join(self.updater.remarkable2_versions.keys())
             remarkable_1_versions = "\n".join(self.updater.remarkable1_versions.keys())
 
-            print(
-                f"ReMarkable Paper Pro:\n{remarkable_pp_versions}\n\nReMarkable 2:\n{remarkable_2_versions}\n\nReMarkable 1:\n{remarkable_1_versions}"
-            )
+            version_blocks = []
+            if remarkable_version is None or remarkable_version == HardwareType.RMPP:
+                version_blocks.append(f"ReMarkable Paper Pro:\n{remarkable_pp_versions}")
+            if remarkable_version is None or remarkable_version == HardwareType.RMPPM:
+                version_blocks.append(f"ReMarkable Paper Pro Move:\n{remarkable_ppm_versions}")
+            if remarkable_version is None or remarkable_version == HardwareType.RM2:
+                version_blocks.append(f"ReMarkable 2:\n{remarkable_2_versions}")
+            if remarkable_version is None or remarkable_version == HardwareType.RM1:
+                version_blocks.append(f"ReMarkable 1:\n{remarkable_1_versions}")
+
+            print("\n\n".join(version_blocks))
 
         elif function == "download":
             logger.debug(f"Downloading version {version}")
+            assert remarkable_version is not None
             filename = self.updater.download_version(
                 remarkable_version, version, args["out"]
             )
@@ -83,24 +100,35 @@ class Manager:
 
         ### Mounting functionalities
         elif function in ("extract", "mount"):
-            try:
-                from .analysis import get_update_image
-            except ImportError:
-                raise ImportError(
-                    "remarkable_update_image is required for analysis. Please install it!"
-                )
-
             if function == "extract":
                 if not args["out"]:
                     args["out"] = os.getcwd() + "/extracted"
 
                 logger.debug(f"Extracting {args['file']} to {args['out']}")
-                image, volume = get_update_image(args["file"])
+
+                try:
+                    from remarkable_update_image import UpdateImage
+                except ImportError:
+                    raise ImportError(
+                        "remarkable_update_image is required for extraction. Please install it!"
+                    ) from None
+
+                image = UpdateImage(args["file"])
                 image.seek(0)
 
                 with open(args["out"], "wb") as f:
                     f.write(image.read())
+
+                logger.info(f"Extracted image to {args['out']}")
             else:
+                try:
+                    from .analysis import get_update_image
+                    from remarkable_update_fuse import UpdateFS
+                except ImportError:
+                    raise ImportError(
+                        "remarkable_update_fuse is required for mounting. Please install it!"
+                    )
+
                 if args["out"] is None:
                     args["out"] = "/opt/remarkable/"
 
@@ -110,8 +138,6 @@ class Manager:
                 if not os.path.exists(args["filesystem"]):
                     raise SystemExit("Firmware file does not exist!")
 
-                from remarkable_update_fuse import UpdateFS
-
                 server = UpdateFS()
                 server.parse(
                     args=[args["filesystem"], args["out"]], values=server, errex=1
@@ -161,25 +187,16 @@ class Manager:
                     remoteFolder=args["remote"],
                     recursive=not args["no_recursion"],
                     overwrite=not args["no_overwrite"],
+                    incremental=args["incremental"],
                 )
             else:
                 rmWeb.upload(input_paths=args["paths"], remoteFolder=args["remote"])
 
-        ### Transfer & Download functionalities
-        elif function in ("transfer", "download"):
-            remarkable = DeviceManager(
-                remote=remote,
-                address=args["address"],
-                logger=self.logger,
-                authentication=args["password"],
-            )
-
-
         ### Update & Version functionalities
         elif function in ("install", "status", "restore"):
             remote = False
 
-            if "remarkable" not in self.device:
+            if "reMarkable" not in self.device:
                 if importlib.util.find_spec("paramiko") is None:
                     raise ImportError(
                         "Paramiko is required for SSH access. Please install it."
@@ -190,6 +207,13 @@ class Manager:
                     )
                 remote = True
 
+            try:
+                from remarkable_update_image import UpdateImage
+            except ImportError:
+                raise ImportError(
+                    "remarkable_update_image is required for install. Please install it!"
+                ) from None
+
             from .device import DeviceManager
             from .server import get_available_version
 
@@ -206,17 +230,15 @@ class Manager:
                 version = self.updater.get_toltec_version(remarkable.hardware)
 
             if function == "status":
-                beta, prev, current, version_id = remarkable.get_device_status()
+                beta, prev, current, version_id, backup = remarkable.get_device_status()
                 print(
-                    f"\nCurrent version: {current}\nOld update engine: {prev}\nBeta active: {beta}\nVersion id: {version_id}"
+                    f"\nCurrent version: {current}\nBackup version: {backup}\nOld update engine: {prev}\nBeta active: {beta}\nVersion id: {version_id}"
                 )
 
             elif function == "restore":
-                if remarkable.hardware == "ferrari":
-                    raise SystemError("Restore not available for rmpro.")
                 remarkable.restore_previous_version()
                 print(
-                    f"Device restored to previous version [{remarkable.get_device_status()[1]}]"
+                    f"Device restored to previous version [{remarkable.get_device_status()[4]}]"
                 )
                 remarkable.reboot_device()
                 print("Device rebooted")
@@ -229,16 +251,60 @@ class Manager:
                 # Do we have a specific update file to serve?
 
                 update_file = version if os.path.isfile(version) else None
-                
-                version_lookup = lambda version: re.search(r'\b\d+\.\d+\.\d+\.\d+\b', version)
-                version_number = version_lookup(version)
+
+                def version_lookup(version: str | None) -> re.Match[str] | None:
+                    return re.search(r"\b\d+\.\d+\.\d+\.\d+\b", cast(str, version))
+
+                version_number = None
+                swu_hardware = None
+
+                if update_file:
+                    try:
+                        from remarkable_update_image import UpdateImage
+                        from remarkable_update_image.image import CPIOUpdateImage
+
+                        image = UpdateImage(update_file)
+                        if isinstance(image, CPIOUpdateImage):
+                            if image.version is None:
+                                raise SystemError(f"Could not determine version from SWU file: {update_file}")
+
+                            version_number = image.version
+                            hw_map = {
+                                "reMarkable1": HardwareType.RM1,
+                                "reMarkable2": HardwareType.RM2,
+                                "ferrari": HardwareType.RMPP,
+                                "chiappa": HardwareType.RMPPM,
+                            }
+                            if image.hardware_type not in hw_map:
+                                raise SystemError(f"Unsupported hardware type in SWU file: {update_file}")
+
+                            swu_hardware = hw_map[image.hardware_type]
+                            logger.info(f"Extracted from SWU: version={version_number}, hardware={swu_hardware.name}")
+
+                            if swu_hardware != remarkable.hardware:
+                                raise SystemError(
+                                    f"Hardware mismatch!\n"
+                                    f"SWU file is for: {swu_hardware.name}\n"
+                                    f"Connected device is: {remarkable.hardware.name}\n"
+                                    f"Cannot install firmware for different hardware."
+                                )
+                    except ValueError as e:
+                        logger.warning(f"Could not extract metadata from update file: {e}")
 
                 if not version_number:
-                    version_number = input("Failed to get the version number from the filename, please enter it: ") 
-                    if not version_lookup(version_number):
-                        raise SystemError("Invalid version!")
+                    version_match = version_lookup(version)
+                    if not version_match:
+                        version_match = version_lookup(
+                            input(
+                                "Failed to get the version number from the filename, please enter it: "
+                            )
+                        )
+                        if not version_match:
+                            raise SystemError("Invalid version!")
 
-                version_number = version_number.group()
+                    version_number = version_match.group()
+                else:
+                    version_number = str(version_number)
 
                 update_file_requires_new_engine = UpdateManager.uses_new_update_engine(
                     version_number
@@ -251,23 +317,91 @@ class Manager:
 
                 if device_version_uses_new_engine:
                     if not update_file_requires_new_engine:
-                        raise SystemError("Cannot downgrade to this version as it uses the old update engine, please manually downgrade.")
+                        raise SystemError(
+                            "Cannot downgrade to this version as it uses the old update engine, please manually downgrade."
+                        )
                         # TODO: Implement manual downgrading.
                         # `codexctl download --out . 3.11.2.5`
                         # `codexctl extract --out 3.11.2.5.img 3.11.2.5_reMarkable2-qLFGoqPtPL.signed`
                         # `codexctl transfer 3.11.2.5.img ~/root`
                         # `dd if=/home/root/3.11.2.5.img of=/dev/mmcblk2p2` (depending on fallback partition)
                         # `codexctl restore`
-                        
+
                 else:
                     if update_file_requires_new_engine:
-                        raise SystemError("This version requires the new update engine, please upgrade your device to version 3.11.2.5 first.")
+                        raise SystemError(
+                            "This version requires the new update engine, please upgrade your device to version 3.11.2.5 first."
+                        )
 
                 #############################################################
 
+                bootloader_files_for_install = None
+
+                if (device_version_uses_new_engine and
+                    remarkable.hardware == HardwareType.RMPP):
+
+                    current_version = remarkable.get_device_status()[2]
+
+                    if UpdateManager.is_bootloader_boundary_downgrade(current_version, version_number):
+                        print("\n" + "="*60)
+                        print("WARNING: Bootloader Update Required")
+                        print("="*60)
+                        print(f"Current version: {current_version}")
+                        print(f"Target version:  {version_number}")
+                        print()
+                        print("Downgrading from 3.22+ to <3.22 requires updating the")
+                        print("bootloader on both partitions. This process will:")
+                        print("  1. Download the current version's bootloader files")
+                        print("  2. Download the target OS version")
+                        print("  3. Install the target OS version")
+                        print("  4. Update bootloader on both partitions")
+                        print("  5. Reboot")
+                        print()
+
+                        response = input("Do you want to continue? (y/N): ")
+                        if response.lower() != 'y':
+                            raise SystemExit("Installation cancelled by user")
+
+                        expected_swu_name = f"remarkable-production-memfault-image-{current_version}-{remarkable.hardware.new_download_hw}-public"
+                        expected_swu_path = f"./{expected_swu_name}"
+
+                        if os.path.isfile(expected_swu_path):
+                            print(f"\nUsing existing {expected_swu_name} for bootloader extraction...")
+                            current_swu_path = expected_swu_path
+                        else:
+                            print("\nDownloading current version's SWU for bootloader extraction...")
+                            current_swu_path = self.updater.download_version(
+                                remarkable.hardware,
+                                current_version,
+                                "./"
+                            )
+
+                        if not current_swu_path:
+                            raise SystemError(
+                                f"Failed to download current version {current_version} for bootloader extraction. "
+                                f"This is required for safe downgrade across bootloader boundary."
+                            )
+
+                        print("Extracting bootloader files...")
+                        from remarkable_update_image import UpdateImage
+                        swu_image = UpdateImage(current_swu_path)
+                        bootloader_files_for_install = {
+                            'update-bootloader.sh': swu_image.archive[b'update-bootloader.sh'].read(),
+                            'imx-boot': swu_image.archive[b'imx-boot'].read(),
+                        }
+
+                        if not all(bootloader_files_for_install.values()):
+                            raise SystemError("Failed to extract bootloader files from current version")
+
+                        print(f"✓ Extracted update-bootloader.sh ({len(bootloader_files_for_install['update-bootloader.sh'])} bytes)")
+                        print(f"✓ Extracted imx-boot ({len(bootloader_files_for_install['imx-boot'])} bytes)")
+                        print()
+
                 if not update_file_requires_new_engine:
-                    if update_file: # Check if file exists
-                        if not (os.path.dirname(os.path.abspath(update_file)) == os.path.abspath("updates")):
+                    if update_file:  # Check if file exists
+                        if os.path.dirname(
+                            os.path.abspath(update_file)
+                        ) != os.path.abspath("updates"):
                             if not os.path.exists("updates"):
                                 os.mkdir("updates")
                             shutil.move(update_file, "updates")
@@ -303,7 +437,7 @@ class Manager:
                         )
 
                 if device_version_uses_new_engine:
-                    remarkable.install_sw_update(update_file)
+                    remarkable.install_sw_update(update_file, bootloader_files=bootloader_files_for_install)
                 else:
                     remarkable.install_ohma_update(update_file)
 
@@ -328,6 +462,7 @@ def main() -> None:
         required=False,
         help="Enable verbose logging",
         action="store_true",
+        dest="verbose",
     )
     parser.add_argument(
         "--address",
@@ -335,12 +470,14 @@ def main() -> None:
         required=False,
         help="Specify the address of the device",
         default=None,
+        dest="address",
     )
     parser.add_argument(
         "--password",
         "-p",
         required=False,
         help="Specify password or path to SSH key for remote access",
+        dest="password",
     )
     subparsers = parser.add_subparsers(dest="command")
     subparsers.required = True  # This fixes a bug with older versions of python
@@ -359,7 +496,12 @@ def main() -> None:
     download.add_argument("version", help="Version to download")
     download.add_argument("--out", "-o", help="Folder to download to", default=None)
     download.add_argument(
-        "--hardware", "-hd", help="Hardware to download for", required=True
+        "--hardware",
+        "--device",
+        "-d",
+        help="Hardware to download for",
+        required=True,
+        dest="hardware",
     )
 
     ### Backup subcommand
@@ -371,21 +513,34 @@ def main() -> None:
         "--remote",
         help="Remote directory to backup. Defaults to download folder",
         default="",
+        dest="remote",
     )
     backup.add_argument(
         "-l",
         "--local",
         help="Local directory to backup to. Defaults to download folder",
         default="./",
+        dest="local",
     )
     backup.add_argument(
-        "-nr",
+        "-R",
         "--no-recursion",
         help="Disables recursively backup remote directory",
         action="store_true",
+        dest="no_recursion",
     )
     backup.add_argument(
-        "-no-ow", "--no-overwrite", help="Disables overwrite", action="store_true"
+        "-O",
+        "--no-overwrite",
+        help="Disables overwrite",
+        action="store_true",
+        dest="no_overwrite",
+    )
+    backup.add_argument(
+        "-i",
+        "--incremental",
+        help="Overwrite out-of-date files only",
+        action="store_true",
     )
 
     ### Cat subcommand
@@ -405,7 +560,7 @@ def main() -> None:
         "extract", help="Extract the specified version update file"
     )
     extract.add_argument("file", help="Path to update file to extract", default=None)
-    extract.add_argument("--out", help="Folder to extract to", default=None)
+    extract.add_argument("--out", help="Folder to extract to", default=None, dest="out")
 
     ### Mount subcommand
     mount = subparsers.add_parser(
@@ -430,6 +585,7 @@ def main() -> None:
         "--remote",
         help="Remote directory to upload to. Defaults to root folder",
         default="",
+        dest="remote",
     )
 
     ### Status subcommand
@@ -443,7 +599,14 @@ def main() -> None:
     )
 
     ### List subcommand
-    subparsers.add_parser("list", help="List all available versions")
+    list_ = subparsers.add_parser("list", help="List all available versions")
+    list_.add_argument(
+        "--hardware",
+        "--device",
+        "-d",
+        help="Hardware to list for",
+        dest="hardware",
+    )
 
     ### Setting logging level
     args = parser.parse_args()

{codexctl-1.1.0 → codexctl-1.2.1}/codexctl/analysis.py

@@ -1,9 +1,10 @@
 import ext4
-import warnings 
+import warnings
 import errno
 
 from remarkable_update_image import UpdateImage
 from remarkable_update_image import UpdateImageSignatureException
+from .device import HardwareType
 
 
 def get_update_image(file: str):