pyflyby 1.10.1__tar.gz → 1.10.2__tar.gz

{pyflyby-1.10.1 → pyflyby-1.10.2}/.github/workflows/docs.yml

@@ -9,7 +9,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v5
-      - uses: actions/setup-python@v5
+      - uses: actions/setup-python@v6
       - name: Install dependencies
         run: |
           pip install -U pip

{pyflyby-1.10.1 → pyflyby-1.10.2}/.github/workflows/lint.yml

@@ -8,7 +8,7 @@ jobs:
     steps:
     - uses: actions/checkout@v5
     - name: Set up Python
-      uses: actions/setup-python@v5
+      uses: actions/setup-python@v6
       with:
         python-version: 3.13
     - name: Install pyflyby

{pyflyby-1.10.1 → pyflyby-1.10.2}/.github/workflows/test.yml

@@ -27,7 +27,7 @@ jobs:
     steps:
     - uses: actions/checkout@v5
     - name: Set up Python ${{ matrix.python-version }}
-      uses: actions/setup-python@v5
+      uses: actions/setup-python@v6
       with:
         python-version: ${{ matrix.python-version }}
     - name: Install pyflyby

{pyflyby-1.10.1 → pyflyby-1.10.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyflyby
-Version: 1.10.1
+Version: 1.10.2
 Summary: pyflyby - Python development productivity tools, in particular automatic import management
 Author-Email: Karl Chen <quarl@8166.clguba.z.quarl.org>
 License-Expression: MIT
@@ -210,6 +210,7 @@ For example:
 
    Replace /tmp/foo.py? [y/N]
 
+To exclude a file, use `--exclude <pattern>`.
 
 Quick start: import libraries
 =============================
@@ -481,21 +482,37 @@ Per-Project configuration of tidy-imports
 =========================================
 
 You can configure Pyflyby on a per-repository basis by using the
-`[tool.pyflyby]` section of `pyproject.toml` files. Pyflyby will look in current
-working directory and all it's parent until it find a `pyproject.toml` file from
+``[tool.pyflyby]`` section of ``pyproject.toml`` files. Pyflyby will look in current
+working directory and all it's parent until it find a ``pyproject.toml`` file from
 which it will load the defaults.
 
 
 Most of the long command line flags default values can be configured in this
-section. Simply use the long form option name by replacing dashes `-` by
-underscore `_`. For long option that have the form `--xxx` and `--no-xxx`, you
-can assign a boolean to `xxx`. For example::
+section. Simply use the long form option name by replacing dashes ``-`` by
+underscore ``_``. For long option that have the form ``--xxx`` and ``--no-xxx``, you
+can assign a boolean to ``xxx``. For example::
+
+.. code:: toml
 
     [tool.pyflyby]
     add_missing=true
     from_spaces=7
     remove_unused=false
 
+To exclude files from ``tidy-imports``, add an exclusion pattern to
+``tool.pyflyby.tidy-imports.exclude``:
+
+.. code:: toml
+
+    [tool.pyflyby.tidy-imports]
+    exclude = [
+        "foo.py",
+        "baz/*.py"
+    ]
+
+Exclusions are assumed to be relative to the project root if a ``pyproject.toml`` exists, unless an
+absolute path is specified. Consult the documentation for ``pathlib.Path.match`` for information about
+valid exclusion patterns.
 
 Emacs support
 =============

{pyflyby-1.10.1 → pyflyby-1.10.2}/README.rst

@@ -167,6 +167,7 @@ For example:
 
    Replace /tmp/foo.py? [y/N]
 
+To exclude a file, use `--exclude <pattern>`.
 
 Quick start: import libraries
 =============================
@@ -438,21 +439,37 @@ Per-Project configuration of tidy-imports
 =========================================
 
 You can configure Pyflyby on a per-repository basis by using the
-`[tool.pyflyby]` section of `pyproject.toml` files. Pyflyby will look in current
-working directory and all it's parent until it find a `pyproject.toml` file from
+``[tool.pyflyby]`` section of ``pyproject.toml`` files. Pyflyby will look in current
+working directory and all it's parent until it find a ``pyproject.toml`` file from
 which it will load the defaults.
 
 
 Most of the long command line flags default values can be configured in this
-section. Simply use the long form option name by replacing dashes `-` by
-underscore `_`. For long option that have the form `--xxx` and `--no-xxx`, you
-can assign a boolean to `xxx`. For example::
+section. Simply use the long form option name by replacing dashes ``-`` by
+underscore ``_``. For long option that have the form ``--xxx`` and ``--no-xxx``, you
+can assign a boolean to ``xxx``. For example::
+
+.. code:: toml
 
     [tool.pyflyby]
     add_missing=true
     from_spaces=7
     remove_unused=false
 
+To exclude files from ``tidy-imports``, add an exclusion pattern to
+``tool.pyflyby.tidy-imports.exclude``:
+
+.. code:: toml
+
+    [tool.pyflyby.tidy-imports]
+    exclude = [
+        "foo.py",
+        "baz/*.py"
+    ]
+
+Exclusions are assumed to be relative to the project root if a ``pyproject.toml`` exists, unless an
+absolute path is specified. Consult the documentation for ``pathlib.Path.match`` for information about
+valid exclusion patterns.
 
 Emacs support
 =============

{pyflyby-1.10.1 → pyflyby-1.10.2}/bin/tidy-imports

@@ -85,6 +85,8 @@ def _addopts(parser):
                         default=True, action='store_false',
                         help=hfmt('''
                             Don't canonicalize imports.'''))
+    parser.add_option('--exclude', type='string', dest='exclude',
+                        action='append', help=hfmt('Files to exclude from formatting.'))
 
 
     def transform_callback(option, opt_str, value, group):
@@ -156,7 +158,12 @@ def main() -> None:
             cannonical_imports = sorted_imports
         return cannonical_imports
 
-    process_actions(args, options.actions, modify)
+    cmdline_exclude = getattr(options, "exclude")
+    process_actions(
+        args,
+        options.actions, modify,
+        exclude=default_config.get('tidy-imports', {}).get('exclude', []) + (cmdline_exclude if cmdline_exclude else [])
+    )
 
 
 if __name__ == '__main__':

{pyflyby-1.10.1 → pyflyby-1.10.2}/lib/python/pyflyby/_cmdline.py

@@ -27,6 +27,10 @@ else:
     from tomllib import loads
 
 
+class ConfigurationError(Exception):
+    """Exception class indicating a configuration error."""
+
+
 def hfmt(s):
     return dedent(s).strip()
 
@@ -232,26 +236,17 @@ def parse_args(addopts=None, import_format_params=False, modify_action_params=Fa
                              only if it is necessary to prevent exceeding the
                              width (by default 79).
                          '''))
-        def uniform_callback(option, opt_str, value, parser):
-            parser.values.separate_from_imports = False
-            parser.values.from_spaces           = 3
-            parser.values.align_imports         = '32'
-        group.add_option('--uniform', '-u', action="callback",
-                         callback=uniform_callback,
+        group.add_option('--uniform', '-u', action="store_true",
                          help=hfmt('''
                              (Default) Shortcut for --no-separate-from-imports
                              --from-spaces=3 --align-imports=32.'''))
-        def unaligned_callback(option, opt_str, value, parser):
-            parser.values.separate_from_imports = True
-            parser.values.from_spaces           = 1
-            parser.values.align_imports         = '0'
-        group.add_option('--unaligned', '-n', action="callback",
-                         callback=unaligned_callback,
+        group.add_option('--unaligned', '-n', action="store_true",
                          help=hfmt('''
                              Shortcut for --separate-from-imports
                              --from-spaces=1 --align-imports=0.'''))
 
         parser.add_option_group(group)
+
     if addopts is not None:
         addopts(parser)
     # This is the only way to provide a default value for an option with a
@@ -260,7 +255,22 @@ def parse_args(addopts=None, import_format_params=False, modify_action_params=Fa
         args = ["--symlinks=error"] + sys.argv[1:]
     else:
         args = None
+
     options, args = parser.parse_args(args=args)
+
+    # Set these manually rather than in a callback option because callback
+    # options don't get triggered by OptionParser.set_default (which is
+    # used when setting values via pyproject.toml)
+    if getattr(options, "unaligned", False):
+        parser.values.separate_from_imports = True
+        parser.values.from_spaces = 1
+        parser.values.align_imports = '0'
+
+    if getattr(options, "uniform", False):
+        parser.values.separate_from_imports = False
+        parser.values.from_spaces = 3
+        parser.values.align_imports = '32'
+
     if import_format_params:
         align_imports_args = [int(x.strip())
                               for x in options.align_imports.split(",")]
@@ -380,14 +390,35 @@ class Modifier(object):
 
 
 def process_actions(filenames:List[str], actions, modify_function,
-                    reraise_exceptions=()):
+                    reraise_exceptions=(), exclude=()):
+
+    if not isinstance(exclude, (list, tuple)):
+        raise ConfigurationError(
+            "Exclusions must be a list of filenames/patterns to exclude."
+        )
+
     errors = []
     def on_error_filename_arg(arg):
         print("%s: bad filename %s" % (sys.argv[0], arg), file=sys.stderr)
         errors.append("%s: bad filename" % (arg,))
-    filenames = filename_args(filenames, on_error=on_error_filename_arg)
+    filename_objs = filename_args(filenames, on_error=on_error_filename_arg)
     exit_code = 0
-    for filename in filenames:
+    for filename in filename_objs:
+
+        # Log any matching exclusion patterns before ignoring, if applicable
+        matching_excludes = []
+        for pattern in exclude:
+            if Path(str(filename)).match(str(pattern)):
+                matching_excludes.append(pattern)
+        if any(matching_excludes):
+            msg = f"{filename} matches exclusion pattern"
+            if len(matching_excludes) == 1:
+                msg += f": {matching_excludes[0]}"
+            else:
+                msg += f"s: {matching_excludes}"
+            logger.info(msg)
+            continue
+
         try:
             m = Modifier(modify_function, filename)
             for action in actions:
@@ -533,16 +564,28 @@ symlink_callbacks = {
     'replace': symlink_replace,
 }
 
-def _get_pyproj_toml_config():
-    """
-    Try to find current project pyproject.toml
+def _get_pyproj_toml_file():
+    """Try to find the location of the current project pyproject.toml
     in cwd or parents directories.
+
+    If no pyproject.toml can be found, None is returned.
     """
     cwd = Path(os.getcwd())
 
     for pth in [cwd] + list(cwd.parents):
         pyproj_toml = pth /'pyproject.toml'
         if pyproj_toml.exists() and pyproj_toml.is_file():
-            return loads(pyproj_toml.read_text())
+            return pyproj_toml
 
     return None
+
+def _get_pyproj_toml_config():
+    """Return the toml contents of the current pyproject.toml.
+
+    If no pyproject.toml can be found in cwd or parent directories,
+    None is returned.
+    """
+    pyproject_toml = _get_pyproj_toml_file()
+    if pyproject_toml is not None:
+        return loads(pyproject_toml.read_text())
+    return None

{pyflyby-1.10.1 → pyflyby-1.10.2}/lib/python/pyflyby/_modules.py

@@ -595,6 +595,12 @@ def _cached_module_finder(
         Tuples containing (prefix+module name, a bool indicating whether the module is a
         package or not)
     """
+    if os.environ.get("PYFLYBY_DISABLE_CACHE", "0") == "1":
+        modules = _iter_file_finder_modules(importer, SUFFIXES)
+        for module, ispkg in modules:
+            yield prefix + module, ispkg
+        return
+
     cache_dir = pathlib.Path(
         platformdirs.user_cache_dir(appname='pyflyby', appauthor=False)
     ) / hashlib.sha256(str(importer.path).encode()).hexdigest()
@@ -610,7 +616,7 @@ def _cached_module_finder(
         for path in cache_dir.iterdir():
             _remove_import_cache_dir(path)
 
-        if os.environ.get("PYFLYBY_SUPPRESS_CACHE_REBUILD_LOGS", 0) != "1":
+        if os.environ.get("PYFLYBY_SUPPRESS_CACHE_REBUILD_LOGS", "1") != "1":
             logger.info(f"Rebuilding cache for {_format_path(importer.path)}...")
 
         modules = _iter_file_finder_modules(importer, SUFFIXES)

{pyflyby-1.10.1 → pyflyby-1.10.2}/lib/python/pyflyby/_version.py

@@ -4,4 +4,4 @@
 # http://creativecommons.org/publicdomain/zero/1.0/
 
 
-__version__ = "1.10.1"
+__version__ = "1.10.2"

{pyflyby-1.10.1 → pyflyby-1.10.2}/meson.build

@@ -1,7 +1,7 @@
 project(
   'pyflyby',
   'cpp',
-  version: '1.10.1',
+  version: '1.10.2',
   default_options: 'cpp_std=c++17'
 )
 

{pyflyby-1.10.1 → pyflyby-1.10.2}/src/_fast_iter_modules.cpp

@@ -62,24 +62,35 @@ _iter_file_finder_modules(
     return ret;
   }
 
-  for (auto const &entry : fs::directory_iterator(path)) {
-    fs::path entry_path = entry.path();
-    fs::path filename = entry_path.filename();
-    std::string modname = getmodulename(filename, suffixes);
+  // Attempt to iterate the directory. If the directory is unreadable for any reason
+  // (e.g., permissions, non-existent, or other system errors), fs::directory_iterator
+  // will throw a filesystem_error. We catch this and return an empty list for this path.
+  try {
+    for (auto const &entry : fs::directory_iterator(path)) {
+      fs::path entry_path = entry.path();
+      fs::path filename = entry_path.filename();
+      std::string modname = getmodulename(filename, suffixes);
 
 
-    if (modname == "" && fs::is_directory(entry_path) &&
-        filename.string().find(".") == std::string::npos &&
-        fs::is_regular_file(entry_path / "__init__.py") // Is this a package?
-    ) {
-      ret.push_back(std::make_tuple(filename.string(), true));
-    } else if (modname == "__init__") {
-      continue;
-    } else if (modname != "" && modname.find(".") == std::string::npos) {
-      ret.push_back(std::make_tuple(modname,
-                                    false // This is definitely not a package
-                                    ));
+      if (modname == "" && fs::is_directory(entry_path) &&
+          filename.string().find(".") == std::string::npos &&
+          fs::is_regular_file(entry_path / "__init__.py") // Is this a package?
+      ) {
+        ret.push_back(std::make_tuple(filename.string(), true));
+      } else if (modname == "__init__") {
+        continue;
+      } else if (modname != "" && modname.find(".") == std::string::npos) {
+        ret.push_back(std::make_tuple(modname,
+                                      false // This is definitely not a package
+                                      ));
+      }
     }
+  } catch (const fs::filesystem_error& e) {
+    // If an error occurs during directory iteration (e.g., permissions denied,
+    // directory removed concurrently), we treat it as unreadable/inaccessible
+    // and return the current (potentially empty) list, effectively skipping this path.
+    // We could log the error 'e.what()' here if desired for debugging.
+    return ret;
   }
 
   return ret;

{pyflyby-1.10.1 → pyflyby-1.10.2}/tests/test_cmdline.py

@@ -934,7 +934,267 @@ def test_load_pyproject_toml(tmp_path, pyproject_text):
     os.chdir(tmp_path)
     assert _get_pyproj_toml_config() == loads(pyproject_text)
 
+
 def test_load_no_pyproject_toml(tmp_path):
-    """Test that a directory pyproject.toml that has mixed array types can be loaded."""
+    """Test that a directory without a pyproject.toml is correctly handled."""
     os.chdir(tmp_path)
     assert _get_pyproj_toml_config() is None
+
+
+def test_pyproject_unaligned(tmp_path):
+    """Test that having an unaligned option in pyproject.toml works as intended."""
+    with open(tmp_path / 'pyproject.toml', 'w') as f:
+        f.write(
+            dedent(
+                """
+                [tool.pyflyby]
+                remove_unused = false
+                add_mandatory = false
+                unaligned = true
+                """
+            )
+        )
+
+    with open(tmp_path / "foo.py", 'w') as f:
+        f.write(
+            dedent(
+                """
+                from math import pi
+                import numpy
+                from os import open
+                import pandas
+                from urllib import request
+                """
+            )
+        )
+
+    child = pexpect.spawn(
+        python,
+        [BIN_DIR + "/tidy-imports", "./"],
+        timeout=5.0,
+        cwd=tmp_path,
+        logfile=BytesIO(),
+    )
+    child.expect_exact("foo.py? [y/N]")
+    child.send("y\n")
+    child.expect(pexpect.EOF)
+
+    with open(tmp_path / "foo.py") as f:
+        assert f.read() == dedent(
+            """
+            import numpy
+            import pandas
+            from math import pi
+            from os import open
+            from urllib import request
+            """
+        )
+
+
+def test_no_unaligned(tmp_path):
+    """Test that not having an unaligned option in pyproject.toml works as intended."""
+    with open(tmp_path / 'pyproject.toml', 'w') as f:
+        f.write(
+            dedent(
+                """
+                [tool.pyflyby]
+                remove_unused = false
+                add_mandatory = false
+                """
+            )
+        )
+
+    with open(tmp_path / "foo.py", 'w') as f:
+        f.write(
+            dedent(
+                """
+                from math import pi
+                import numpy
+                from os import open
+                import pandas
+                from urllib import request
+                """
+            )
+        )
+
+    child = pexpect.spawn(
+        python,
+        [BIN_DIR + "/tidy-imports", "./"],
+        timeout=5.0,
+        cwd=tmp_path,
+        logfile=BytesIO(),
+    )
+    child.expect_exact("foo.py? [y/N]")
+    child.send("y\n")
+    child.expect(pexpect.EOF)
+
+    with open(tmp_path / "foo.py") as f:
+        assert f.read() == dedent(
+            """
+            from   math                     import pi
+            import numpy
+            from   os                       import open
+            import pandas
+            from   urllib                   import request
+            """
+        )
+
+
+def test_tidy_imports_exclude_pyproject(tmp_path):
+    """Test that a pyproject.toml can be used to exclude files for tidy-imports."""
+    with open(tmp_path / "pyproject.toml", 'w') as f:
+        f.write(
+            dedent(
+                """
+                [tool.pyflyby.tidy-imports]
+                exclude = [
+                    'foo.py',
+                    'bar/*.py',
+                ]
+                """
+            )
+        )
+
+    (tmp_path / "bar").mkdir()
+    (tmp_path / "baz" / "blah").mkdir(parents=True)
+
+    txt = dedent(
+        """
+        # hello
+        def foo():
+            foo() + os + sys
+        """
+    )
+    for path in [
+        tmp_path / "foo.py",
+        tmp_path / "what.py",
+        tmp_path / "bar" / "foo2.py",
+        tmp_path / "baz" / "foo3.py",
+    ]:
+        with open(path, "w") as f:
+            f.write(txt)
+
+    child = pexpect.spawn(
+        python,
+        [BIN_DIR+'/tidy-imports', './'],
+        timeout=5.0,
+        cwd=tmp_path,
+        logfile=BytesIO()
+    )
+    child.expect_exact("baz/foo3.py? [y/N]")
+    child.send("y\n")
+    child.expect_exact("what.py? [y/N]")
+    child.send("y\n")
+    child.expect(pexpect.EOF)
+
+    # Check that the tidy-imports output has log messages about exclusion patterns
+    output = child.logfile.getvalue().decode()
+    assert "bar/foo2.py matches exclusion pattern: bar/*.py" in output
+    assert "foo.py matches exclusion pattern: foo.py" in output
+
+    # Check that the two modified files have imports
+    with open(tmp_path / "baz" / "foo3.py") as f:
+        foo3 = f.read()
+
+    with open(tmp_path / "what.py") as f:
+        what = f.read()
+
+    expected = dedent(
+        """
+        # hello
+        import os
+        import sys
+
+        def foo():
+            foo() + os + sys
+        """
+    )
+    assert foo3 == expected
+    assert what == expected
+
+    # Check that the two unmodified files don't have imports
+    with open(tmp_path / "foo.py") as f:
+        foo = f.read()
+
+    with open(tmp_path / "bar" / "foo2.py") as f:
+        foo2 = f.read()
+
+    assert foo == txt
+    assert foo2 == txt
+
+
+def test_tidy_imports_exclude_arg(tmp_path):
+    """Test that a command line arg can be used to exclude files for tidy-imports."""
+    (tmp_path / "bar").mkdir()
+    (tmp_path / "baz" / "blah").mkdir(parents=True)
+
+    txt = dedent(
+        """
+        # hello
+        def foo():
+            foo() + os + sys
+        """
+    )
+    for path in [
+        tmp_path / "foo.py",
+        tmp_path / "what.py",
+        tmp_path / "bar" / "foo2.py",
+        tmp_path / "baz" / "foo3.py",
+    ]:
+        with open(path, "w") as f:
+            f.write(txt)
+
+    child = pexpect.spawn(
+        python,
+        [
+            BIN_DIR + "/tidy-imports",
+            "./",
+            "--exclude",
+            "foo.py",
+            "--exclude",
+            "bar/*.py",
+        ],
+        timeout=5.0,
+        cwd=tmp_path,
+        logfile=BytesIO(),
+    )
+    child.expect_exact("baz/foo3.py? [y/N]")
+    child.send("y\n")
+    child.expect_exact("what.py? [y/N]")
+    child.send("y\n")
+    child.expect(pexpect.EOF)
+
+    # Check that the tidy-imports output has log messages about exclusion patterns
+    output = child.logfile.getvalue().decode()
+    assert "bar/foo2.py matches exclusion pattern: bar/*.py" in output
+    assert "foo.py matches exclusion pattern: foo.py" in output
+
+    # Check that the two modified files have imports
+    with open(tmp_path / "baz" / "foo3.py") as f:
+        foo3 = f.read()
+
+    with open(tmp_path / "what.py") as f:
+        what = f.read()
+
+    expected = dedent(
+        """
+        # hello
+        import os
+        import sys
+
+        def foo():
+            foo() + os + sys
+        """
+    )
+    assert foo3 == expected
+    assert what == expected
+
+    # Check that the two unmodified files don't have imports
+    with open(tmp_path / "foo.py") as f:
+        foo = f.read()
+
+    with open(tmp_path / "bar" / "foo2.py") as f:
+        foo2 = f.read()
+
+    assert foo == txt
+    assert foo2 == txt

{pyflyby-1.10.1 → pyflyby-1.10.2}/tests/test_modules.py

@@ -13,9 +13,11 @@ from   pyflyby._log             import logger
 from   pyflyby._modules         import (ModuleHandle, _fast_iter_modules,
                                         _iter_file_finder_modules)
 import re
+import os
 import subprocess
 import sys
 from   textwrap                 import dedent
+from   tempfile                 import TemporaryDirectory
 from   unittest                 import mock
 
 import pytest
@@ -122,7 +124,7 @@ def test_fast_iter_modules():
 
     assert fast == slow
 
-
+@mock.patch.dict(os.environ, {"PYFLYBY_SUPPRESS_CACHE_REBUILD_LOGS": "0"})
 @mock.patch("platformdirs.user_cache_dir")
 def test_import_cache(mock_user_cache_dir, tmp_path):
     """Test that the import cache is built when iterating modules.
@@ -195,3 +197,20 @@ def test_import_cache(mock_user_cache_dir, tmp_path):
     assert len(mock_logger.info.call_args_list) == 1
     assert len(list(tmp_path.iterdir())) == n_cached_paths
     mock_iffm.assert_called_once()
+
+@mock.patch.dict(os.environ, {"PYFLYBY_DISABLE_CACHE": "1"})
+@mock.patch("platformdirs.user_cache_dir")
+def test_import_perms(mock_user_cache_dir, tmp_path):
+    """Test that the import cache does not fail on unreadable paths."""
+
+    mock_user_cache_dir.return_value = tmp_path
+
+    with TemporaryDirectory(suffix="_pyflyby_restricted") as restricted:
+        try:
+            os.chmod(restricted, 0o000)
+
+            sys.path.append(restricted)
+
+            list(_fast_iter_modules())
+        finally:
+            sys.path.remove(restricted)