Rework exceptions, class methods for open files

.github/workflows/build-exe.yml

@@ -0,0 +1,28 @@
+on:
+  workflow_call:
+
+name: Workflow - Build exe
+
+jobs:
+  build:
+    runs-on: windows-latest
+    name: Build Windows exe
+
+    steps:
+      - uses: actions/checkout@v3
+        name: Checkout
+      - uses: actions/setup-python@v4
+        name: Setup Python
+        with:
+          python-version: ${{ vars.PYTHON_VERSION}}
+      - name: Install deps
+        run: |
+          python -m pip install --upgrade pip
+          pip install .[build]
+      - name: Build
+        run: pyinstaller dyn2py.spec
+      - uses: actions/upload-artifact@v3
+        name: Upload artifact
+        with:
+          name: dyn2py.exe
+          path: dist/dyn2py.exe

.github/workflows/build-installer.yml

@@ -0,0 +1,29 @@
+on:
+  workflow_call:
+
+name: Workflow - Build installer
+
+jobs:
+  build-installer:
+    runs-on: windows-latest
+    name: Build Windows installer
+
+    steps:
+      - uses: actions/checkout@v3
+        name: Checkout
+      - name: Install Inno Setup
+        run: |
+          Invoke-WebRequest -Uri https://jrsoftware.org/download.php/is.exe -OutFile is.exe
+          .\is.exe /verysilent
+      - name: Download artifact
+        uses: actions/download-artifact@v3
+        with:
+          name: dyn2py.exe
+      - name: Build
+        run: |
+          .\dyn2py-installer.ps1
+      - uses: actions/upload-artifact@v3
+        name: Upload artifact
+        with:
+          name: dyn2py-installer.exe
+          path: Output/dyn2py-installer.exe

.github/workflows/release.yml

@@ -10,39 +10,29 @@ permissions:
 
 jobs:
   test:
+    name: Test
     strategy:
       matrix:
         os: [ubuntu-latest, windows-latest]
     uses: ./.github/workflows/test.yml
     with:
-      python-version: ${{ vars.PYTHON_VERSION}}
+      python-version: ${{ vars.PYTHON_VERSION }}
       os: ${{ matrix.os }}
 
-  build:
+  build-exe:
-    runs-on: windows-latest
+    name: Build Windows exe
     needs: test
-    steps:
+    uses: ./.github/workflows/build-exe.yml
-      - uses: actions/checkout@v3
+
-        name: Checkout
+  build-installer:
-      - uses: actions/setup-python@v4
+    name: Build Windows installer
-        name: Setup Python
+    needs: build-exe
-        with:
+    uses: ./.github/workflows/build-installer.yml
-          python-version: ${{ vars.PYTHON_VERSION}}
-      - name: Install deps
-        run: |
-          python -m pip install --upgrade pip
-          pip install .[build]
-      - name: Build
-        run: pyinstaller dyn2py.spec
-      - uses: actions/upload-artifact@v3
-        name: Upload artifact
-        with:
-          name: dyn2py.exe
-          path: dist/dyn2py.exe
 
   release:
+    name: Create Github release
     runs-on: ubuntu-latest
-    needs: build
+    needs: build-installer
     steps:
       - uses: actions/checkout@v3
         name: Checkout
@@ -51,26 +41,33 @@ jobs:
         uses: metcalfc/changelog-generator@v4.1.0
         with:
           myToken: ${{ secrets.GITHUB_TOKEN }}
-      - name: Download artifact
+      - name: Download exe
         uses: actions/download-artifact@v3
         with:
           name: dyn2py.exe
+      - name: Download installer
+        uses: actions/download-artifact@v3
+        with:
+          name: dyn2py-installer.exe
       - name: Release
         uses: softprops/action-gh-release@v1
         with:
-          files: dyn2py.exe
+          files: |
-          body: ${{ steps.modified.outputs.log }}
+            dyn2py.exe
+            dyn2py-installer.exe
+          body: ${{ steps.changelog.outputs.changelog }}
 
   pip:
+    name: Publish to PyPI
     runs-on: ubuntu-latest
-    needs: release
+    needs: test
     steps:
       - uses: actions/checkout@v3
         name: Checkout
       - uses: actions/setup-python@v4
         name: Setup Python
         with:
-          python-version: ${{ vars.PYTHON_VERSION}}
+          python-version: ${{ vars.PYTHON_VERSION }}
       - name: Install deps
         run: |
           python -m pip install --upgrade pip

.github/workflows/test.yml

@@ -8,11 +8,15 @@ on:
         required: true
         type: string
 
+name: Workflow - Test
+
 jobs:
   test:
+    name: Run tests
     runs-on: ${{ inputs.os }}
     steps:
       - uses: actions/checkout@v3
+        name: Checkout
       - name: Set up Python ${{ inputs.python-version }}
         uses: actions/setup-python@v4
         with:
@@ -21,5 +25,5 @@ jobs:
         run: |
           python -m pip install --upgrade pip
           pip install .
-      - name: Test
+      - name: Run tests
         run: python -m unittest discover -v -s ./tests -p "test_*.py"

.github/workflows/unittests.yml

@@ -5,12 +5,14 @@ on:
     branches: ["main"]
   pull_request:
     branches: ["main"]
+  workflow_dispatch:
 
 permissions:
   contents: read
 
 jobs:
   tests:
+    name: Unit tests
     strategy:
       matrix:
         os: [ubuntu-latest, windows-latest]

.github/workflows/website.yml

@@ -5,7 +5,6 @@ on:
     branches:
       - main
 
-  # Allows you to run this workflow manually from the Actions tab
   workflow_dispatch:
 
 # security: restrict permissions for CI jobs.
@@ -18,19 +17,22 @@ concurrency:
   cancel-in-progress: true
 
 jobs:
-  # Build the documentation and upload the static HTML files as an artifact.
   build:
+    name: Build documentation
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v3
+        name: Checkout
       - uses: actions/setup-python@v4
+        name: Setup Python
         with:
-          python-version: "3.11"
+          python-version: ${{ vars.PYTHON_VERSION }}
-
       - run: pip install -e .[doc]
+        name: Install deps
       - run: pdoc -d google -o docs dyn2py
-
+        name: Generate docs
       - uses: actions/upload-pages-artifact@v1
+        name: Upload artifact
         with:
           path: docs/
 
@@ -38,6 +40,7 @@ jobs:
   # This is a separate job so that only actions/deploy-pages has the necessary permissions.
   deploy:
     needs: build
+    name: Publish documentation
     runs-on: ubuntu-latest
     permissions:
       pages: write
@@ -47,4 +50,5 @@ jobs:
       url: ${{ steps.deployment.outputs.page_url }}
     steps:
       - id: deployment
+        name: Deploy page
         uses: actions/deploy-pages@v1

.github/workflows/windows-build.yml

@@ -0,0 +1,17 @@
+name: Build Windows exe and installer
+
+on:
+  workflow_dispatch:
+  pull_request:
+    branches: ["main"]
+  # push:
+
+jobs:
+  build-exe:
+    uses: ./.github/workflows/build-exe.yml
+    name: Build Windows exe
+
+  build-installer:
+    name: Build Windows installer
+    needs: build-exe
+    uses: ./.github/workflows/build-installer.yml

.gitignore

@@ -6,3 +6,5 @@ build
 dist
 docs
 tests/output_files
+Output
+dyn2py.exe

README.md

@@ -1,3 +1,10 @@
+[![GitHub release (latest by date)](https://img.shields.io/github/v/release/infeeeee/dyn2py?style=flat-square)](https://github.com/infeeeee/dyn2py/releases/latest)
+[![PyPI](https://img.shields.io/pypi/v/dyn2py?style=flat-square)](https://pypi.org/project/dyn2py/)
+[![GitHub Release Date](https://img.shields.io/github/release-date/infeeeee/dyn2py?style=flat-square)](https://github.com/infeeeee/dyn2py/releases/latest)
+[![GitHub last commit (branch)](https://img.shields.io/github/last-commit/infeeeee/dyn2py/main?style=flat-square)](https://github.com/infeeeee/dyn2py/commits/main)
+[![GitHub Workflow Status](https://img.shields.io/github/actions/workflow/status/infeeeee/dyn2py/unittests.yml?label=tests&style=flat-square)](https://github.com/infeeeee/dyn2py/actions/workflows/unittests.yml)
+[![GitHub](https://img.shields.io/github/license/infeeeee/dyn2py?style=flat-square)](https://github.com/infeeeee/dyn2py/blob/main/LICENSE)
+
 # dyn2py
 
 Extract python code from Dynamo graphs
@@ -5,27 +12,30 @@ Extract python code from Dynamo graphs
 Use cases:
 
 - Track changes in python nodes in source control systems like git
-- Work on python code in your favorite code editor outside Dynamo. `dyn2py` can also update Dynamo graphs from the previously exported python files.
+- Work on python code in your favorite code editor outside Dynamo. `dyn2py` can also update Dynamo graphs from previously exported python files.
 
 ## Installation
 
-### Windows portable
+### Windows portable and installer
 
-Prebuilt exe available from github releases.
+Prebuilt portable exe and installer available from github releases.
 
-No requirements, just download `dyn2py.exe` from release assets:
+No requirements, just download `dyn2py.exe` or `dyn2py-installer.exe` from release assets:
 
 https://github.com/infeeeee/dyn2py/releases/latest
 
-### With pip from Github
+Installer automatically adds the install folder to the path, so simply `dyn2py` can be called from anywhere.
 
-Requirements: git, python, pip
+### With pip
+
+For usage as a module or as a command line program
+
+Requirements: python, pip
 
 ```
-pip install "dyn2py @ git+https://github.com/infeeeee/dyn2py"
+pip install dyn2py
 ```
 
-
 ## Usage
 
 ### As a standalone command line program
@@ -43,7 +53,7 @@ options:
   -h, --help            show this help message and exit
   -v, --version         show program's version number and exit
   -l LOGLEVEL, --loglevel LOGLEVEL
-                        set log level, possible options: CRITICAL, ERROR, WARNING, INFO, DEBUG
+                        set log level, possible options: HEADLESS, CRITICAL, ERROR, WARNING, INFO, DEBUG
   -n, --dry-run         do not modify files, only show log
   -F, --force           overwrite even if the files are older
   -b, --backup          create a backup for updated files
@@ -58,20 +68,49 @@ dynamo options, only for processing Dynamo graphs:
 The script by default overwrites older files with newer files.
 Do not move the source Dynamo graphs, or update won't work with them later.
 Multiple sources are supported, separate them by spaces.
+HEADLESS loglevel only prints modified filenames.
 ```
 
+#### Examples
+
+*Notes: In Windows cmd use backward slashes as path separators, in any other shells use forward slashes. Powershell accepts both of them. Wrap paths with spaces in double quotes.*
+
+```shell
+# Extract all nodes next to a Dynamo file:
+dyn2py path/to/dynamofile.dyn
+
+# Update a Dynamo file from previously exported and modified python files:
+dyn2py --update path/to/dynamofile.dyn
+
+# Extract python nodes to a specific folder, process multiple Dynamo files:
+dyn2py --python-folder path/to/pythonfiles path/to/dynamofile1.dyn path/to/dynamofile2.dyn
+
+# Update Dynamo files from python files from a folder. Only check python files, create backups:
+dyn2py --filter py --backup path/to/pythonfiles
+```
+
+#### Git hooks
+
+Git Hooks are a built-in feature of Git that allow developers to automate tasks throughout the Git workflow. Read more here: https://githooks.com/
+
+With the `pre-commit` hook it's possible to add more files to the currently initialized commit.
+
+You can find an example pre-commit hook here: [pre-commit](pre-commit). Copy this file to the `.git/hooks` folder of your repo of Dynamo graph. This folder is hidden by default, but it should exist in all initialized git repo. Do not rename this file.
+
+This script will go through staged `.dyn` files and export python scripts from them, and add them to the current commit. Now you can check check changed lines in a diff tool!
+
 ### As a python module
 
 Full API documentation available here: https://infeeeee.github.io/dyn2py
 
-Most basic example to extract all nodes next to a dynamo file:
+Most basic example to extract all nodes next to a Dynamo file:
 
 ```python
 import dyn2py
 
 dynamo_file = dyn2py.DynamoFile("path/to/dynamofile.dyn")
-python_files = dynamo_file.extract_python()
+dynamo_file.extract_python()
-[python_file.write() for python_file in python_files]
+dyn2py.PythonFile.write_open_files()
 ```
 
 Change options like with the command line switches with the `Options` class:
@@ -94,11 +133,27 @@ python_files = dynamo_file.get_related_python_files(options)
 dynamo_file.write(options)
 ```
 
+For more examples check tests in the [tests folder on Github](https://github.com/infeeeee/dyn2py/tree/main/tests)
+
+They should work in Dynamo, inside CPython3 nodes.
+
+## Troubleshooting
+
+If you have a problem, open an [issue on Github](https://github.com/infeeeee/dyn2py/issues)
+
+You can also ask about this project on [Dynamo Forum](https://forum.dynamobim.com/), don't forget to ping me: [@infeeeee](https://forum.dynamobim.com/u/infeeeee)
+
+## Limitations
+
+Only supports Dynamo 2 files, Dynamo 1 files are reported and ignored. Please update them to Dynamo 2 by opening them in Dynamo 2.
+
+Both IronPython2 and CPython3 nodes are supported! IronPython2 nodes won't be updated to CPython3, they will be imported as-is.
+
 ## Development
 
 ### Installation
 
-Requirements: git, pip
+Requirements: git, python, pip
 
 ```
 git clone https://github.com/infeeeee/dyn2py
@@ -116,16 +171,42 @@ venv .venv
 pip install -e .
 ```
 
-### Build
+### Build for Windows
 
 ```
 pip install -e .[build]
 pyinstaller dyn2py.spec
 ```
 
+### Create installer for Windows
+
+- Install Inno Setup: https://jrsoftware.org/isdl.php
+- Build an exe
+- Run `dyn2py-installer.ps1` in powershell
+
 ### Live module documentation
 
 ```
 pip install -e .[doc]
 pdoc -d google dyn2py
 ```
+
+### Unit tests
+
+VSCode should automatically discover unit tests. 
+
+To run them manually:
+
+```
+python -m unittest discover -v -s ./tests -p "test_*.py"
+```
+
+### New release
+
+1. Update version number in `pyproject.toml`
+2. Create a publish a git tag with that number
+
+## License
+
+GPL-3.0
+

TODO.md

@@ -15,16 +15,16 @@
 - [x] Tests on Windows
 - [x] Windows Build
 - [x] Pip
+- [x] Windows Installer
 
 ## Documentation
 
 - [x] API docs
-- [ ] Installation in readme
+- [x] Installation in readme
-- [ ] Terminal examples in readme
+- [x] Terminal examples in readme
-- [ ] About git hooks in readme
+- [x] About git hooks in readme
 
 ## Extra features maybe later
 
-- [ ] Windows Installer
 - [ ] Autocomplete
 - [ ] Winget

dyn2py-installer.iss

@@ -0,0 +1,86 @@
+[Setup]
+AppId={{E924F481-6909-43F8-8469-11155A5EB9A2}
+AppName=dyn2py
+AppVersion=x.x.x
+AppPublisher=infeeeee
+AppPublisherURL=https://github.com/infeeeee/dyn2py
+AppSupportURL=https://github.com/infeeeee/dyn2py/issues
+AppUpdatesURL=https://github.com/infeeeee/dyn2py/releases/latest
+DefaultDirName={autopf}\dyn2py
+DisableProgramGroupPage=auto
+DefaultGroupName=dyn2py
+LicenseFile=LICENSE
+PrivilegesRequired=admin
+OutputBaseFilename=dyn2py-installer
+Compression=lzma
+SolidCompression=yes
+WizardStyle=modern
+ChangesEnvironment=yes
+
+[Languages]
+Name: "english"; MessagesFile: "compiler:Default.isl"
+
+[Files]
+Source: "dyn2py.exe"; DestDir: "{app}"; Flags: ignoreversion
+
+[Icons]
+Name: "{group}\dyn2py (cmd)"; Filename: "{cmd}"; WorkingDir: "{userdocs}"; Parameters: "/k dyn2py"
+Name: "{group}\dyn2py (powershell)"; Filename: "powershell"; WorkingDir: "{userdocs}"; Parameters: "-noexit -command dyn2py"
+
+[Code]
+const EnvironmentKey = 'SYSTEM\CurrentControlSet\Control\Session Manager\Environment';
+
+procedure EnvAddPath(Path: string);
+var
+    Paths: string;
+begin
+    { Retrieve current path (use empty string if entry not exists) }
+    if not RegQueryStringValue(HKEY_LOCAL_MACHINE, EnvironmentKey, 'Path', Paths)
+    then Paths := '';
+
+    { Skip if string already found in path }
+    if Pos(';' + Uppercase(Path) + ';', ';' + Uppercase(Paths) + ';') > 0 then exit;
+
+    { App string to the end of the path variable }
+    Paths := Paths + ';'+ Path +';'
+
+    { Overwrite (or create if missing) path environment variable }
+    if RegWriteStringValue(HKEY_LOCAL_MACHINE, EnvironmentKey, 'Path', Paths)
+    then Log(Format('The [%s] added to PATH: [%s]', [Path, Paths]))
+    else Log(Format('Error while adding the [%s] to PATH: [%s]', [Path, Paths]));
+end;
+
+procedure EnvRemovePath(Path: string);
+var
+    Paths: string;
+    P: Integer;
+begin
+    { Skip if registry entry not exists }
+    if not RegQueryStringValue(HKEY_LOCAL_MACHINE, EnvironmentKey, 'Path', Paths) then
+        exit;
+
+    { Skip if string not found in path }
+    P := Pos(';' + Uppercase(Path) + ';', ';' + Uppercase(Paths) + ';');
+    if P = 0 then exit;
+
+    { Update path variable }
+    Delete(Paths, P - 1, Length(Path) + 1);
+
+    { Overwrite path environment variable }
+    if RegWriteStringValue(HKEY_LOCAL_MACHINE, EnvironmentKey, 'Path', Paths)
+    then Log(Format('The [%s] removed from PATH: [%s]', [Path, Paths]))
+    else Log(Format('Error while removing the [%s] from PATH: [%s]', [Path, Paths]));
+end;
+
+
+procedure CurStepChanged(CurStep: TSetupStep);
+begin
+    if CurStep = ssPostInstall 
+     then EnvAddPath(ExpandConstant('{app}'));
+end;
+
+procedure CurUninstallStepChanged(CurUninstallStep: TUninstallStep);
+begin
+    if CurUninstallStep = usPostUninstall
+    then EnvRemovePath(ExpandConstant('{app}'));
+end;

dyn2py-installer.ps1

@@ -0,0 +1,24 @@
+$InnoSetupPath = "C:\Program Files (x86)\Inno Setup 6\ISCC.exe"
+
+# Check if innosetup installed
+if (-not (Test-Path -Path $InnoSetupPath -PathType Leaf)) {
+    throw "Innosetup not found!"    
+} 
+
+# Copy dyn2py.exe from default folder:
+if (Test-Path -Path ".\dist\dyn2py.exe" -PathType Leaf) {
+    Copy-Item ".\dist\dyn2py.exe" -Destination "." -Force
+} 
+
+# Check if dyn2py.exe exists at all
+if (-not(Test-Path -Path "dyn2py.exe" -PathType Leaf)) {
+    throw "dyn2py.exe not found!"    
+}
+
+# Read version number from pyproject.toml and update in innosetup:
+$regex = Select-String -Path pyproject.toml -Pattern '^version = "((?:\d\.){2}\d)"$'
+$version = $regex.Matches.Groups[1].Value
+(Get-Content dyn2py-installer.iss).Replace("x.x.x", $version) | Set-Content dyn2py-installer.iss
+
+# Build:
+& $InnoSetupPath -Qp $(Join-Path $PWD.Path dyn2py-installer.iss)

dyn2py/__init__.py

@@ -22,11 +22,7 @@ __all__ = [
     "File",
     "DynamoFile",
     "PythonFile",
-    "PythonNode",
+    "PythonNode"
-    "DynamoFileException",
-    "PythonNodeNotFoundException",
-    "PythonNodeException",
-    "PythonFileException"
 ]
 
 
@@ -45,6 +41,7 @@ def __command_line() -> None:
             The script by default overwrites older files with newer files.
             Do not move the source Dynamo graphs, or update won't work with them later.
             Multiple sources are supported, separate them by spaces.
+            HEADLESS loglevel only prints modified filenames.
             """)
     )
 
@@ -117,8 +114,13 @@ def run(options: Options) -> None:
     from_command_line = bool(inspect.stack()[1].function == "__command_line")
 
     # Set up logging:
+    if options.loglevel == "HEADLESS":
+        loglevel = "CRITICAL"
+    else:
+        loglevel = options.loglevel
+
     logging.basicConfig(format='%(levelname)s: %(message)s',
-                        level=options.loglevel)
+                        level=loglevel)
     logging.debug(f"Run options: {vars(options)}")
 
     # Set up sources:
@@ -149,13 +151,13 @@ def run(options: Options) -> None:
     for f in source_files:
         try:
             files.append(File(f))
-        except DynamoFileException as e:
+        except DynamoFile.Error as e:
             # It's a dynamo1 file
-            logging.warning(e)
+            logging.warning(f"This is a Dynamo 1 file! {e.file.filepath}")
             continue
-        except PythonNodeNotFoundException as e:
+        except DynamoFile.PythonNodeNotFound as e:
-            # No python node in this file
+            # No python nodes in this file
-            logging.warning(e)
+            logging.warning(f"This file has no Python nodes! {e.file.filepath} ")
             continue
 
     # Dynamo files come first, sort sources:
@@ -193,8 +195,13 @@ def run(options: Options) -> None:
 
         elif f.is_python_file():
             logging.debug("Source is a Python file")
-            f.update_dynamo(options)
+            try:
+                f.update_dynamo(options)
+            except FileNotFoundError:
+                logging.error(f"{f.filepath} Source Dynamo file not found! ")
 
     # Write files at the end:
-    for f in DynamoFile.open_files | PythonFile.open_files:
+    try:
-        f.write(options)
+        File.write_open_files()
+    except File.Error as e:
+        logging.error(f"Cannot save file! {e.file.filepath}")

dyn2py/exceptions.py

@@ -1,16 +0,0 @@
-class DynamoFileException(Exception):
-    """Something wrong in this DynamoFile"""
-    pass
-
-
-class PythonNodeNotFoundException(Exception):
-    """PythonNode not found"""
-    pass
-
-
-class PythonNodeException(Exception):
-    pass
-
-
-class PythonFileException(Exception):
-    pass

dyn2py/files.py

@@ -9,7 +9,6 @@ from decimal import Decimal
 from pathvalidate import sanitize_filename
 from importlib_metadata import metadata
 
-from dyn2py.exceptions import *
 from dyn2py.options import Options
 
 
@@ -20,6 +19,9 @@ HEADER_SEPARATOR = "*" * 60
 class File():
     """Base class for managing files"""
 
+    open_files: set[File] = set()
+    """A set of open files."""
+
     def __init__(self, filepath: pathlib.Path | str, read_from_disk: bool = True) -> None:
         """Generate a file object. If the path is correct it will become a DynamoFile or PythonFile object.
             Calls DynamoFile.read_file() and PythonFile.read_file()
@@ -120,6 +122,7 @@ class File():
 
         Raises:
             TypeError: If called on a File object
+            File.Error: Target folder does not exist
         """
 
         if not options:
@@ -136,18 +139,24 @@ class File():
         # Create backup:
         if not options.dry_run and self.filepath.exists() and options.backup:
             backup_filename = sanitize_filename(
-                f"{self.basename}_{self.mtimeiso}{self.extension}")
+                filename=f"{self.basename}_{self.mtimeiso}{self.extension}")
             backup_path = self.dirpath.joinpath(backup_filename)
             logging.info(f"Creating backup to {backup_path}")
             self.filepath.rename(backup_path)
+            if options.loglevel == "HEADLESS":
+                print(backup_path)
 
         # Call filetype specific methods:
         if options.dry_run:
             logging.info(
                 f"Should write file, but it's a dry-run: {self.filepath}")
         else:
+            if not self.dirpath.exists():
+                raise File.Error("File dir does not exist!", self)
             logging.info(f"Writing file: {self.filepath}")
             self._write_file()
+            if options.loglevel == "HEADLESS":
+                print(self.filepath)
 
     def _write_file(self):
         """Should be implemented in subclasses
@@ -158,6 +167,45 @@ class File():
         raise NotImplementedError(
             "Should be called only on DynamoFile and PythonFile objects!")
 
+    @classmethod
+    def get_open_files(cls) -> set:
+        """Get open files of this class and subclasses
+
+        Returns:
+            set: A set of open files
+        """
+        return {f for f in File.open_files if
+                isinstance(f, cls)}
+
+    @classmethod
+    def write_open_files(cls, options: Options | None = None) -> None:
+        """Write open files of this class and subclasses
+
+        Args:
+            options (Options | None, optional): Run options. Defaults to None.
+        """
+        if not options:
+            options = Options()
+
+        for f in cls.get_open_files():
+            f.write(options)
+
+    @classmethod
+    def close_open_files(cls) -> None:
+        """Close open files of this class and subclasses"""
+        File.open_files = File.open_files - cls.get_open_files()
+
+    class Error(Exception):
+        def __init__(self, message: str, file: File) -> None:
+            """There is some problem with this file
+
+            Args:
+                message (str): The message to display
+                file (File): The problem File
+            """
+            super().__init__(message)
+            self.file = file
+
 
 class DynamoFile(File):
     """A Dynamo file, subclass of File()"""
@@ -171,9 +219,6 @@ class DynamoFile(File):
     python_nodes: set[PythonNode]
     """Python node objects, read from this file."""
 
-    open_files: set[DynamoFile] = set()
-    """A set of open Dynamo files, before saving. Self added by read()"""
-
     def extract_python(self, options: Options | None = None) -> list[PythonFile]:
         """Extract python files from Dynamo graphs, add them to open_files
 
@@ -222,9 +267,9 @@ class DynamoFile(File):
 
         Raises:
             FileNotFoundError: The file does not exist
-            DynamoFileException: If the file is a Dynamo 1 file
+            DynamoFile.Error: If the file is a Dynamo 1 file
             json.JSONDecodeError: If there are any other problem with the file
-            PythonNodeNotFoundException: No python nodes in the file
+            DynamoFile.PythonNodeNotFound: No python nodes in the file
         """
 
         if not self.exists:
@@ -242,7 +287,7 @@ class DynamoFile(File):
             except json.JSONDecodeError as e:
                 with open(self.filepath, "r", encoding="utf-8") as input_json:
                     if input_json.readline().startswith("<Workspace Version="):
-                        raise DynamoFileException("This is a Dynamo 1 file!")
+                        raise self.Error("This is a Dynamo 1 file!", self)
                     else:
                         raise e
 
@@ -257,8 +302,8 @@ class DynamoFile(File):
             node_views = self.full_dict["View"]["NodeViews"]
 
             if not full_python_nodes:
-                raise PythonNodeNotFoundException(
+                raise self.PythonNodeNotFound(
-                    "No python nodes in this file!")
+                    "No python nodes in this file!", self, "")
 
             self.python_nodes = set()
 
@@ -279,7 +324,7 @@ class DynamoFile(File):
             PythonNode: The PythonNode with the given id
 
         Raises:
-            PythonNodeNotFoundException: No python node with this id
+            DynamoFile.PythonNodeNotFound: No python node with this id
         """
 
         python_node = next((
@@ -287,8 +332,8 @@ class DynamoFile(File):
         ), None)
 
         if not python_node:
-            raise PythonNodeNotFoundException(
+            raise self.PythonNodeNotFound(
-                f"Node not found with id {node_id}")
+                "Node not found", self, node_id)
 
         return python_node
 
@@ -299,7 +344,7 @@ class DynamoFile(File):
             python_node (PythonNode): The new node
 
         Raises:
-            PythonNodeNotFoundException: Existing node not found
+            DynamoFile.PythonNodeNotFound: Existing node not found
         """
 
         # Find the old node:
@@ -309,8 +354,9 @@ class DynamoFile(File):
             n for n in self.full_dict["Nodes"] if n["Id"] == python_node.id
         ), {})
 
-        if not node_dict or not python_node_in_file:
+        if not node_dict:
-            raise PythonNodeNotFoundException()
+            raise self.PythonNodeNotFound(
+                "Existing node not found in file", self, python_node.id)
 
         # Remove the old and add the new:
         self.python_nodes.remove(python_node_in_file)
@@ -361,11 +407,24 @@ class DynamoFile(File):
         Returns:
             DynamoFile: The file. None if not found
         """
-        f = next((d for d in DynamoFile.open_files if d.uuid == uuid), None)
+        f = next((d for d in DynamoFile.get_open_files() if d.uuid == uuid), None)
         if f:
             logging.debug(f"Found open file {f.uuid}")
         return f
 
+    class PythonNodeNotFound(Exception):
+        def __init__(self, message: str, file: DynamoFile, node_id: str) -> None:
+            """Python node not found with this id
+
+            Args:
+                message (str): The message to display
+                file (DynamoFile): The problem DynamoFile
+                node_id (str): The missing id
+            """
+            super().__init__(message)
+            self.file = file
+            self.node_id = node_id
+
 
 class PythonFile(File):
     """A Python file, subclass of File()"""
@@ -377,9 +436,6 @@ class PythonFile(File):
     text: str
     """Full contents of the file."""
 
-    open_files: set[PythonFile] = set()
-    """A set of open Python files."""
-
     def __init__(self,
                  filepath: pathlib.Path | str,
                  dynamo_file: DynamoFile | None = None,
@@ -403,10 +459,11 @@ class PythonFile(File):
                 "Do not edit this section, if you want to update the Dynamo graph!"
             ])
 
-            # Double escape path:
+            # Calculate relative path, change to forward slash
-            dyn_path_string = str(dynamo_file.realpath)
+            dyn_path_string = os.path.relpath(
+                dynamo_file.filepath, self.dirpath)
             if "\\" in dyn_path_string:
-                dyn_path_string = dyn_path_string.replace("\\", "\\\\")
+                dyn_path_string = dyn_path_string.replace("\\", "/")
 
             self.header_data = {
                 "dyn2py_version": METADATA["Version"],
@@ -451,7 +508,7 @@ class PythonFile(File):
 
         Raises:
             FileNotFoundError: The file does not exist
-            PythonFileException: Some error reading the file
+            PythonFile.Error: Some error reading the file
         """
         if not self.exists:
             raise FileNotFoundError
@@ -486,7 +543,7 @@ class PythonFile(File):
                     # Find the location of the separator
                     sl = line.find(":")
                     if sl == -1:
-                        raise PythonFileException("Error reading header!")
+                        raise self.Error("Error reading header!", self)
                     self.header_data[line[0:sl]] = line[sl+1:]
 
             self.code = python_lines[code_start_line:]
@@ -528,7 +585,7 @@ class PythonFile(File):
         """Get the source Dynamo file of this PythonFile
 
         Raises:
-            DynamoFileException: The uuid of the dynamo file changed
+            DynamoFile.Error: The uuid of the dynamo file changed
 
         Returns:
             DynamoFile: The DynamoFile
@@ -541,12 +598,21 @@ class PythonFile(File):
         # Open if it's the first time:
         if not dynamo_file:
 
-            dynamo_file = DynamoFile(
+            cwd = pathlib.Path(os.getcwd()).resolve()
-                pathlib.Path(self.header_data["dyn_path"]))
+            # Change to pythonfiles' dir:
+            os.chdir(self.dirpath)
+
+            dynpath = os.path.realpath(self.header_data["dyn_path"])
+            logging.debug(f"Resolved path: {dynpath}")
+
+            # Change back to the original path:
+            os.chdir(cwd)
+            dynamo_file = DynamoFile(pathlib.Path(dynpath))
 
             # Check if uuid is ok:
             if not dynamo_file.uuid == self.header_data["dyn_uuid"]:
-                raise DynamoFileException(f"Dynamo graph uuid changed!")
+                raise DynamoFile.Error(
+                    "Dynamo graph uuid changed!", dynamo_file)
 
         return dynamo_file
 
@@ -587,7 +653,7 @@ class PythonNode():
             python_file (PythonFile, optional): The python file to be converted to node. Defaults to None.
 
         Raises:
-            PythonNodeException: Wrong arguments were given
+            Error: Wrong arguments were given
         """
         # Initialize from dynamo file:
         if node_dict_from_dyn and dynamo_file and not python_file:
@@ -627,9 +693,18 @@ class PythonNode():
             self.filename = python_file.basename + ".py"
             self.filepath = python_file.filepath
 
+        elif python_file and node_dict_from_dyn and dynamo_file:
+            raise self.Error("Too much arguments given!")
+
+        elif not python_file and not node_dict_from_dyn and not dynamo_file:
+            raise self.Error("No arguments given!")
+
         else:
-            raise PythonNodeException
+            raise self.Error("Something wrong!")
 
         # Calculate checksum:
         checksums = [hashlib.md5(l.encode()).hexdigest() for l in self.code]
         self.checksum = hashlib.md5("".join(checksums).encode()).hexdigest()
+
+    class Error(Exception):
+        pass

dyn2py/options.py

@@ -3,7 +3,7 @@ import argparse
 import pathlib
 
 
-LOGLEVELS = ["CRITICAL", "ERROR", "WARNING", "INFO", "DEBUG"]
+LOGLEVELS = ["HEADLESS", "CRITICAL", "ERROR", "WARNING", "INFO", "DEBUG"]
 DEFAULT_LOGLEVEL = "INFO"
 FILTERS = ["py", "dyn"]
 

pre-commit

@@ -0,0 +1,27 @@
+#!/bin/sh
+
+# Create a list of files from staged files:
+mapfile -t NEW_FILES <<<$(git diff --name-only --cached)
+
+# Go through staged files:
+for f in "${NEW_FILES[@]}"; do
+
+    # Export python files, only from Dynamo files.
+    # On Windows line ending is always CRLF, so remove CR with tr.
+    mapfile -t PY_FILES <<<$(dyn2py --force --filter dyn --loglevel HEADLESS "$f" | tr -d "\r")
+
+    # Check if something was exported:
+    if [[ "${PY_FILES[@]}" ]]; then
+
+        # Go through exported files:
+        for p in "${PY_FILES[@]}"; do
+
+            # Check if file exists:
+            if [ -f "$p" ]; then
+
+                # Stage file:
+                git add "$p"
+            fi
+        done
+    fi
+done

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "dyn2py"
-version = "0.3.1"
+version = "0.3.3"
 description = "Extract python code from Dynamo graphs"
 readme = "README.md"
 requires-python = ">=3.8"
@@ -34,3 +34,6 @@ dyn2py = "dyn2py:__command_line"
 
 [build-system]
 requires = ["setuptools", "wheel"]
+
+[tool.setuptools]
+packages = ["dyn2py"]

tests/support.py

@@ -31,8 +31,7 @@ def extract_single_node_dyn(modify_py: bool = False):
     pythonfiles = dyn.extract_python(options)
     pythonfiles[0].write()
 
-    dyn2py.PythonFile.open_files.clear()
+    dyn2py.File.open_files.clear()
-    dyn2py.DynamoFile.open_files.clear()
 
     if modify_py:
         # Open the extracted file and replace a string:

tests/test_DynamoFile.py

@@ -19,7 +19,7 @@ class TestDynamoFile(unittest.TestCase):
         self.assertTrue(dyn in dyn2py.DynamoFile.open_files)
 
         # Dynamo 1 file:
-        with self.assertRaises(dyn2py.DynamoFileException):
+        with self.assertRaises(dyn2py.DynamoFile.Error):
             dyn1 = dyn2py.DynamoFile(f"{INPUT_DIR}/dynamo1file.dyn")
 
         # Not existing file:
@@ -27,7 +27,7 @@ class TestDynamoFile(unittest.TestCase):
             dyn2 = dyn2py.DynamoFile(f"{INPUT_DIR}/not_existing.dyn")
 
         # No python nodes:
-        with self.assertRaises(dyn2py.PythonNodeNotFoundException):
+        with self.assertRaises(dyn2py.DynamoFile.PythonNodeNotFound):
             dyn2 = dyn2py.DynamoFile(f"{INPUT_DIR}/no_python.dyn")
 
     def test_get_python_nodes(self):
@@ -39,7 +39,7 @@ class TestDynamoFile(unittest.TestCase):
         self.assertIn(py_node, dyn.python_nodes)
         self.assertEqual(py_node.checksum, "e830a6ae6b395bcfd4e5a40da48f3bfc")
 
-        with self.assertRaises(dyn2py.PythonNodeNotFoundException):
+        with self.assertRaises(dyn2py.DynamoFile.PythonNodeNotFound):
             dyn.get_python_node_by_id("wrongid")
 
     def test_extract_python(self):
@@ -50,10 +50,9 @@ class TestDynamoFile(unittest.TestCase):
         dyn = dyn2py.DynamoFile(f"{INPUT_DIR}/python_nodes.dyn")
         dyn.extract_python(options=opt)
 
-        self.assertEqual(len(dyn2py.PythonFile.open_files), 6)
+        self.assertEqual(len(dyn2py.PythonFile.get_open_files()), 6)
 
-        for f in dyn2py.PythonFile.open_files:
+        dyn2py.PythonFile.write_open_files()
-            f.write()
 
         output_dir = pathlib.Path(OUTPUT_DIR)
         self.assertEqual(len(list(output_dir.iterdir())), 6)
@@ -139,6 +138,6 @@ class TestDynamoFile(unittest.TestCase):
         self.assertTrue(node2)
         self.assertEqual(node1.checksum, node2.checksum)
 
-        with self.assertRaises(dyn2py.PythonNodeNotFoundException):
+        with self.assertRaises(dyn2py.DynamoFile.PythonNodeNotFound):
             node2.id = "wrong_id"
             dyn2.update_python_node(node2)

tests/test_PythonFile.py

@@ -12,9 +12,10 @@ class TestPythonFile(unittest.TestCase):
     def test_init(self):
         extract_single_node_dyn()
 
-        py1 = dyn2py.PythonFile(f"{OUTPUT_DIR}/single_node_1c5d99792882409e97e132b3e9f814b0.py")
+        dyn2py.File.open_files.clear()
 
-        dyn2py.DynamoFile.open_files.clear()
+        py1 = dyn2py.PythonFile(
+            f"{OUTPUT_DIR}/single_node_1c5d99792882409e97e132b3e9f814b0.py")
         dyn = dyn2py.DynamoFile(f"{INPUT_DIR}/single_node.dyn")
         node = list(dyn.python_nodes)[0]
         py2 = dyn2py.PythonFile(filepath=node.filepath,
@@ -23,9 +24,10 @@ class TestPythonFile(unittest.TestCase):
         for py in [py1, py2]:
 
             self.assertEqual(len(py.code), 17)
-            self.assertEqual(len(py.text.split(os.linesep)), 32, msg=py.filepath)
+            self.assertEqual(len(py.text.split(os.linesep)),
+                             32, msg=py.filepath)
             self.assertIs(type(py.header_data), dict)
-            self.assertTrue(py in dyn2py.PythonFile.open_files)
+            self.assertTrue(py in dyn2py.PythonFile.get_open_files())
 
     def test_update_dynamo(self):
         extract_single_node_dyn(modify_py=True)
@@ -68,14 +70,13 @@ class TestPythonFile(unittest.TestCase):
 
     def test_get_source_dynamo_file(self):
         extract_single_node_dyn()
-        dyn2py.DynamoFile.open_files.clear()
+        dyn2py.File.open_files.clear()
-        dyn2py.PythonFile.open_files.clear()
 
         py1 = dyn2py.PythonFile(
             f"{OUTPUT_DIR}/single_node_1c5d99792882409e97e132b3e9f814b0.py")
 
         dyn1 = py1.get_source_dynamo_file()
-        self.assertEqual(len(dyn2py.DynamoFile.open_files), 1)
+        self.assertEqual(len(dyn2py.DynamoFile.get_open_files()), 1)
         self.assertIn(dyn1, dyn2py.DynamoFile.open_files)
 
         dyn2 = py1.get_source_dynamo_file()
@@ -83,14 +84,13 @@ class TestPythonFile(unittest.TestCase):
 
         dyn2py.DynamoFile.open_files.clear()
 
-        with self.assertRaises(dyn2py.DynamoFileException):
+        with self.assertRaises(dyn2py.DynamoFile.Error):
             py1.header_data["dyn_uuid"] = "wrong-uuid"
             py1.get_source_dynamo_file()
 
     def test_write(self):
         extract_single_node_dyn()
-        dyn2py.DynamoFile.open_files.clear()
+        dyn2py.File.open_files.clear()
-        dyn2py.PythonFile.open_files.clear()
 
         py1 = dyn2py.PythonFile(
             f"{OUTPUT_DIR}/single_node_1c5d99792882409e97e132b3e9f814b0.py")
@@ -98,7 +98,7 @@ class TestPythonFile(unittest.TestCase):
         dyn1 = py1.get_source_dynamo_file()
         node = list(dyn1.python_nodes)[0]
         py2 = dyn2py.PythonFile(
-            node.filepath, dynamo_file=dyn1, python_node=node)
+            f"{OUTPUT_DIR}/{node.filename}", dynamo_file=dyn1, python_node=node)
         self.assertIsNot(py1, py2)
         self.assertEqual(py1.code, py2.code)
         for d in py1.header_data:

tests/test_PythonNode.py

@@ -48,11 +48,12 @@ class TestPythonNode(unittest.TestCase):
 
         py = dyn2py.PythonFile(f"{OUTPUT_DIR}/single_node_mod.py")
 
-        with self.assertRaises(dyn2py.PythonNodeException):
+        with self.assertRaises(dyn2py.PythonNode.Error):
             node1 = dyn2py.PythonNode(
                 node_dict_from_dyn=node_dict,
                 dynamo_file=dyn,
                 python_file=py
             )
         
+        with self.assertRaises(dyn2py.PythonNode.Error):
             node2 = dyn2py.PythonNode()