pyflyby 1.9.4__py3-none-any.whl → 1.9.5__py3-none-any.whl

pyflyby/_importdb.py

@@ -7,8 +7,15 @@
 from   collections              import defaultdict
 import os
 import re
+import sys
+import warnings
 
-from   pyflyby._file            import Filename, expand_py_files_from_args, UnsafeFilenameError
+from   pathlib                  import Path
+
+from   typing                   import Any, Dict, List, Tuple, Union
+
+from   pyflyby._file            import (Filename, UnsafeFilenameError,
+                                        expand_py_files_from_args)
 from   pyflyby._idents          import dotted_prefixes
 from   pyflyby._importclns      import ImportMap, ImportSet
 from   pyflyby._importstmt      import Import, ImportStatement
@@ -16,8 +23,12 @@ from   pyflyby._log             import logger
 from   pyflyby._parse           import PythonBlock
 from   pyflyby._util            import cached_attribute, memoize, stable_unique
 
-from   typing                   import Dict, Any
+if sys.version_info <= (3, 12):
+    from typing_extensions import Self
+else:
+    from typing import Self
 
+SUPPORT_DEPRECATED_BEHAVIOR = True
 
 @memoize
 def _find_etc_dirs():
@@ -83,8 +94,11 @@ def _get_python_path(env_var_name, default_path, target_dirname):
             .format(env_var_name=env_var_name, p=p))
     pathnames = [os.path.expanduser(p) for p in pathnames]
     pathnames = _expand_tripledots(pathnames, target_dirname)
-    pathnames = [Filename(fn) for fn in pathnames]
+    for fn in pathnames:
+        assert isinstance(fn, Filename)
     pathnames = stable_unique(pathnames)
+    for p in pathnames:
+        assert isinstance(p, Filename)
     pathnames = expand_py_files_from_args(pathnames)
     if not pathnames:
         logger.warning(
@@ -96,8 +110,8 @@ def _get_python_path(env_var_name, default_path, target_dirname):
 # TODO: stop memoizing here after using StatCache.  Actually just inline into
 # _ancestors_on_same_partition
 @memoize
-def _get_st_dev(filename):
-    filename = Filename(filename)
+def _get_st_dev(filename: Filename):
+    assert isinstance(filename, Filename)
     try:
         return os.stat(str(filename)).st_dev
     except OSError:
@@ -152,7 +166,7 @@ def _expand_tripledots(pathnames, target_dirname):
     :rtype:
       ``list`` of `Filename`
     """
-    target_dirname = Filename(target_dirname)
+    assert isinstance(target_dirname, Filename)
     if not isinstance(pathnames, (tuple, list)):
         pathnames = [pathnames]
     result = []
@@ -171,7 +185,7 @@ def _expand_tripledots(pathnames, target_dirname):
     return result
 
 
-class ImportDB(object):
+class ImportDB:
     """
     A database of known, mandatory, canonical imports.
 
@@ -186,6 +200,13 @@ class ImportDB(object):
       canonical_imports.
     """
 
+    forget_imports   : ImportSet
+    known_imports    : ImportSet
+    mandatory_imports: ImportSet
+    canonical_imports: ImportMap
+
+    _default_cache: Dict[Any, Any] = {}
+
     def __new__(cls, *args):
         if len(args) != 1:
             raise TypeError
@@ -196,8 +217,8 @@ class ImportDB(object):
             return cls._from_data(arg, [], [], [])
         return cls._from_args(arg) # PythonBlock, Filename, etc
 
+    
 
-    _default_cache: Dict[Any, Any] = {}
 
     @classmethod
     def clear_default_cache(cls):
@@ -208,24 +229,22 @@ class ImportDB(object):
         cached results.  Existing ImportDB instances are not affected by this
         call.
         """
-        if cls._default_cache:
-            if logger.debug_enabled:
-                allpyfiles = set()
-                for tup in cls._default_cache:
-                    if tup[0] != 2:
-                        continue
-                    for tup2 in tup[1:]:
-                        for f in tup2:
-                            assert isinstance(f, Filename)
-                            if f.ext == '.py':
-                                allpyfiles.add(f)
-                nfiles = len(allpyfiles)
-                logger.debug("ImportDB: Clearing default cache of %d files",
-                             nfiles)
-            cls._default_cache.clear()
+        if logger.debug_enabled:
+            allpyfiles = set()
+            for tup in cls._default_cache:
+                if tup[0] != 2:
+                    continue
+                for tup2 in tup[1:]:
+                    for f in tup2:
+                        assert isinstance(f, Filename)
+                        if f.ext == ".py":
+                            allpyfiles.add(f)
+            nfiles = len(allpyfiles)
+            logger.debug("ImportDB: Clearing default cache of %d files", nfiles)
+        cls._default_cache.clear()
 
     @classmethod
-    def get_default(cls, target_filename):
+    def get_default(cls, target_filename: Union[Filename, str], /):
         """
         Return the default import library for the given target filename.
 
@@ -242,7 +261,7 @@ class ImportDB(object):
         :rtype:
           `ImportDB`
         """
-        # We're going to canonicalize target_filenames in a number of steps.
+        # We're going to canonicalize target_filename in a number of steps.
         # At each step, see if we've seen the input so far.  We do the cache
         # checking incrementally since the steps involve syscalls.  Since this
         # is going to potentially be executed inside the IPython interactive
@@ -250,22 +269,56 @@ class ImportDB(object):
         # TODO: Consider refreshing periodically.  Check if files have
         # been touched, and if so, return new data.  Check file timestamps at
         # most once every 60 seconds.
-        cache_keys = []
-        target_filename = Filename(target_filename or ".")
+        cache_keys:List[Tuple[Any,...]] = []
+        if target_filename is None:
+            target_filename = "."
+
+        if isinstance(target_filename, Filename):
+            target_filename = str(target_filename)
+
+        assert isinstance(target_filename, str), (
+            target_filename,
+            type(target_filename),
+        )
+
+        target_path = Path(target_filename).resolve()
+
+        parents: List[Path]
+        if not target_path.is_dir():
+            parents = [target_path]
+        else:
+            parents = []
+
+        # filter safe parents
+        safe_parent = None
+        for p in parents + list(target_path.parents):
+            try:
+                safe_parent = Filename(str(p))
+                break
+            except UnsafeFilenameError:
+                pass
+        if safe_parent is None:
+            raise ValueError("No know path are safe")
+
+        target_dirname = safe_parent
+
         if target_filename.startswith("/dev"):
-            target_filename = Filename(".")
-        target_dirname = target_filename
-        # TODO: with StatCache
-        while True:
-            cache_keys.append((1,
-                               target_dirname,
-                               os.getenv("PYFLYBY_PATH"),
-                               os.getenv("PYFLYBY_KNOWN_IMPORTS_PATH"),
-                               os.getenv("PYFLYBY_MANDATORY_IMPORTS_PATH")))
             try:
-                return cls._default_cache[cache_keys[-1]]
-            except KeyError:
+                target_dirname = Filename(".")
+            except UnsafeFilenameError:
                 pass
+        # TODO: with StatCache
+        while True:
+            key = (
+                1,
+                target_dirname,
+                os.getenv("PYFLYBY_PATH"),
+                os.getenv("PYFLYBY_KNOWN_IMPORTS_PATH"),
+                os.getenv("PYFLYBY_MANDATORY_IMPORTS_PATH"),
+            )
+            cache_keys.append(key)
+            if key in cls._default_cache:
+                return cls._default_cache[key]
             if target_dirname.isdir:
                 break
             target_dirname = target_dirname.dir
@@ -293,7 +346,7 @@ class ImportDB(object):
         filenames = _get_python_path("PYFLYBY_PATH", DEFAULT_PYFLYBY_PATH,
                                      target_dirname)
         mandatory_imports_filenames = ()
-        if "SUPPORT DEPRECATED BEHAVIOR":
+        if SUPPORT_DEPRECATED_BEHAVIOR:
             PYFLYBY_PATH = _get_env_var("PYFLYBY_PATH", DEFAULT_PYFLYBY_PATH)
             # If the old deprecated environment variables are set, then heed
             # them.
@@ -320,7 +373,15 @@ class ImportDB(object):
                 default_path = PYFLYBY_PATH
                 # Expand $PYFLYBY_KNOWN_IMPORTS_PATH.
                 filenames = _get_python_path(
-                    "PYFLYBY_KNOWN_IMPORTS_PATH", default_path, target_dirname)
+                    "PYFLYBY_KNOWN_IMPORTS_PATH", default_path, target_dirname
+                )
+                warnings.warn(
+                    "The environment variable PYFLYBY_KNOWN_IMPORTS_PATH was"
+                    " deprecated since 2014. But never emitted a warning,"
+                    " please use PYFLYBY_PATH or open an issue"
+                    " if you are still requiring PYFLYBY_KNOWN_IMPORTS_PATH",
+                    DeprecationWarning,
+                )
                 logger.debug(
                     "The environment variable PYFLYBY_KNOWN_IMPORTS_PATH is deprecated.  "
                     "Use PYFLYBY_PATH.")
@@ -333,8 +394,15 @@ class ImportDB(object):
                     os.path.join(d,"mandatory_imports") for d in PYFLYBY_PATH]
                 # Expand $PYFLYBY_MANDATORY_IMPORTS_PATH.
                 mandatory_imports_filenames = _get_python_path(
-                    "PYFLYBY_MANDATORY_IMPORTS_PATH",
-                    default_path, target_dirname)
+                    "PYFLYBY_MANDATORY_IMPORTS_PATH", default_path, target_dirname
+                )
+                warnings.warn(
+                    "The environment variable PYFLYBY_MANDATORY_IMPORTS_PATH was"
+                    " deprecated since 2014 but never emitted a warning."
+                    " Use PYFLYBY_PATH and write __mandatory_imports__=['...']"
+                    " in your files.",
+                    DeprecationWarning,
+                )
                 logger.debug(
                     "The environment variable PYFLYBY_MANDATORY_IMPORTS_PATH is deprecated.  "
                     "Use PYFLYBY_PATH and write __mandatory_imports__=['...'] in your files.")
@@ -366,6 +434,16 @@ class ImportDB(object):
         self.canonical_imports = ImportMap(canonical_imports).without_imports(forget_imports)
         return self
 
+    def __or__(self, other:'Self') -> 'Self':
+        assert isinstance(other, ImportDB)
+        return self._from_data(
+                known_imports = self.known_imports | other.known_imports,
+                mandatory_imports = self.mandatory_imports | other.mandatory_imports,
+                canonical_imports = self.canonical_imports | other.canonical_imports,
+                forget_imports = self.forget_imports | other.forget_imports
+                )
+
+
     @classmethod
     def _from_args(cls, args):
         # TODO: support merging input ImportDBs.  For now we support
@@ -469,13 +547,23 @@ class ImportDB(object):
         :rtype:
           `ImportDB`
         """
+        if _mandatory_filenames_deprecated:
+            warnings.warn(
+                "_mandatory_filenames_deprecated has been deprecated in Pyflyby"
+                " 1.9.4 and will removed in future versions",
+                DeprecationWarning,
+                stacklevel=1,
+            )
         if not isinstance(filenames, (tuple, list)):
+            # TODO DeprecationWarning July 2024,
+            # this is internal deprecate not passing a list;
             filenames = [filenames]
-        filenames = [Filename(f) for f in filenames]
+        for f in filenames:
+            assert isinstance(f, Filename)
         logger.debug("ImportDB: loading [%s], mandatory=[%s]",
                      ', '.join(map(str, filenames)),
                      ', '.join(map(str, _mandatory_filenames_deprecated)))
-        if "SUPPORT DEPRECATED BEHAVIOR":
+        if SUPPORT_DEPRECATED_BEHAVIOR:
             # Before 2014-10, pyflyby read the following:
             #   * known_imports from $PYFLYBY_PATH/known_imports/**/*.py or
             #     $PYFLYBY_KNOWN_IMPORTS_PATH/**/*.py,
@@ -531,7 +619,7 @@ class ImportDB(object):
         return ImportMap(arg)
 
     @cached_attribute
-    def by_fullname_or_import_as(self):
+    def by_fullname_or_import_as(self) -> Dict[str, Tuple[Import, ...]]:
         """
         Map from ``fullname`` and ``import_as`` to `Import` s.
 

pyflyby/_interactive.py

@@ -15,11 +15,14 @@ import re
 import subprocess
 import sys
 
+from typing import List, Any, Dict
+
 
 from   pyflyby._autoimp         import (LoadSymbolError, ScopeStack, auto_eval,
                                         auto_import,
                                         clear_failed_imports_cache,
                                         load_symbol)
+from   pyflyby._dynimp          import inject as inject_dynamic_import
 from   pyflyby._comms           import (initialize_comms, remove_comms,
                                         send_comm_message, MISSING_IMPORTS)
 from   pyflyby._file            import Filename, atomic_write_file, read_file
@@ -1368,20 +1371,30 @@ def UpdateIPythonStdioCtx():
 
 
 
-class _EnableState(object):
+class _EnableState:
     DISABLING = "DISABLING"
     DISABLED  = "DISABLED"
     ENABLING  = "ENABLING"
     ENABLED   = "ENABLED"
 
 
-class AutoImporter(object):
+class AutoImporter:
     """
     Auto importer enable state.
 
     The state is attached to an IPython "application".
     """
 
+    db: ImportDB
+    app: Any
+    _state: _EnableState
+    _disablers: List[Any]
+
+    _errored: bool
+    _ip: Any
+    _ast_transformer: Any
+    _autoimported_this_cell: Dict[Any, Any]
+
     def __new__(cls, arg=Ellipsis):
         """
         Get the AutoImporter for the given app, or create and assign one.
@@ -1418,7 +1431,7 @@ class AutoImporter(object):
             raise TypeError("AutoImporter(): unexpected %s" % (clsname,))
 
     @classmethod
-    def _from_app(cls, app):
+    def _from_app(cls, app) -> 'AutoImporter':
         subapp = getattr(app, "subapp", None)
         if subapp is not None:
             app = subapp
@@ -1432,6 +1445,7 @@ class AutoImporter(object):
         # Create a new instance and assign to the app.
         self = cls._construct(app)
         app.auto_importer = self
+        self.db = ImportDB("")
         return self
 
     @classmethod
@@ -1517,7 +1531,6 @@ class AutoImporter(object):
             self.app = app
         logger.debug("app = %r", app)
         ok = True
-        ok &= self._enable_ipython_bugfixes()
         ok &= self._enable_initializer_hooks(app)
         ok &= self._enable_kernel_manager_hook(app)
         ok &= self._enable_shell_hooks(app)
@@ -1681,67 +1694,6 @@ class AutoImporter(object):
                 finally:
                     format_kernel_cmd_with_autoimport.unadvise()
             return True
-        try:
-            # Tested with IPython 1.0, 1.2, 2.0, 2.1, 2.2, 2.3, 2.4, 3.0, 3.1,
-            # 3.2.
-            from IPython.kernel.manager import KernelManager as IPythonKernelManager
-        except ImportError:
-            pass
-        else:
-            @self._advise(kernel_manager.start_kernel)
-            def start_kernel_with_autoimport_ipython(*args, **kwargs):
-                logger.debug("start_kernel()")
-                # Advise format_kernel_cmd(), which is the function that
-                # computes the command line for a subprocess to run a new
-                # kernel.  Note that we advise the method on the class, rather
-                # than this instance of kernel_manager, because start_kernel()
-                # actually creates a *new* KernelInstance for this.
-                @advise(IPythonKernelManager.format_kernel_cmd)
-                def format_kernel_cmd_with_autoimport(*args, **kwargs):
-                    result = __original__(*args, **kwargs)
-                    logger.debug("intercepting format_kernel_cmd(): orig = %r", result)
-                    if result[1:3] in [
-                            # IPython 3.x
-                            ['-m', 'IPython.kernel'],
-                            # IPython 1.x, 2.x
-                            ['-c', 'from IPython.kernel.zmq.kernelapp import main; main()'],
-                    ]:
-                        result[1:3] = new_cmd
-                        logger.debug("intercepting format_kernel_cmd(): new = %r", result)
-                        return result
-                    else:
-                        logger.debug("intercepting format_kernel_cmd(): unexpected output; not modifying it")
-                        return result
-                try:
-                    return __original__(*args, **kwargs)
-                finally:
-                    format_kernel_cmd_with_autoimport.unadvise()
-            return True
-        # Tested with IPython 0.12, 0.13
-        try:
-            import IPython.zmq.ipkernel
-        except ImportError:
-            pass
-        else:
-            @self._advise(kernel_manager.start_kernel)
-            def start_kernel_with_autoimport013(*args, **kwargs):
-                logger.debug("start_kernel()")
-                @advise((IPython.zmq.ipkernel, 'base_launch_kernel'))
-                def base_launch_kernel_with_autoimport(cmd, *args, **kwargs):
-                    logger.debug("base_launch_kernel()")
-                    expected_cmd = 'from IPython.zmq.ipkernel import main; main()'
-                    if cmd != expected_cmd:
-                        logger.debug("unexpected command, not modifying it: %r", cmd)
-                    else:
-                        cmd = (
-                            'from pyflyby._interactive import start_ipython_kernel_with_autoimporter; '
-                            'start_ipython_kernel_with_autoimporter()')
-                    return __original__(cmd, *args, **kwargs)
-                try:
-                    return __original__(*args, **kwargs)
-                finally:
-                    base_launch_kernel_with_autoimport.unadvise()
-            return True
         logger.debug("Couldn't enable start_kernel hook")
         return False
 
@@ -1886,14 +1838,6 @@ class AutoImporter(object):
                 self.reset_state_new_cell()
                 return __original__()
             return True
-        elif hasattr(ip, "resetbuffer"):
-            # Tested with IPython 0.10.
-            @self._advise(ip.resetbuffer)
-            def resetbuffer_and_autoimporter_state():
-                logger.debug("resetbuffer_and_autoimporter_state")
-                self.reset_state_new_cell()
-                return __original__()
-            return True
         else:
             logger.debug("Couldn't enable reset hook")
             return False
@@ -2045,15 +1989,6 @@ class AutoImporter(object):
                     __original__, compile=self.compile_with_autoimport)
                 return wrapped(*args, **kwargs)
             return True
-        elif hasattr(ip, 'magic_time'):
-            # Tested with IPython 0.10, 0.11, 0.12
-            @self._advise(ip.magic_time)
-            def magic_time_with_autoimport(*args, **kwargs):
-                logger.debug("time_with_autoimport()")
-                wrapped = FunctionWithGlobals(
-                    __original__, compile=self.compile_with_autoimport)
-                return wrapped(*args, **kwargs)
-            return True
         else:
             logger.debug("Couldn't enable time hook")
             return False
@@ -2079,15 +2014,6 @@ class AutoImporter(object):
                     __original__, compile=self.compile_with_autoimport)
                 return wrapped(*args, **kwargs)
             return True
-        elif hasattr(ip, 'magic_timeit'):
-            # Tested with IPython 0.10, 0.11, 0.12
-            @self._advise(ip.magic_timeit)
-            def magic_timeit_with_autoimport(*args, **kwargs):
-                logger.debug("timeit_with_autoimport()")
-                wrapped = FunctionWithGlobals(
-                    __original__, compile=self.compile_with_autoimport)
-                return wrapped(*args, **kwargs)
-            return True
         else:
             logger.debug("Couldn't enable timeit hook")
             return False
@@ -2126,24 +2052,6 @@ class AutoImporter(object):
                         __original__, profile=ProfileFactory_with_autoimport())
                     return wrapped(*args, **kwargs)
                 return True
-        elif hasattr(ip, "magic_prun"):
-            # Tested with IPython 0.10, 0.11, 0.12.
-            class ProfileFactory_with_autoimport(object):
-                def Profile(self_, *args):
-                    import profile
-                    p = profile.Profile()
-                    @advise(p.runctx)
-                    def runctx_with_autoimport(cmd, globals, locals):
-                        self.auto_import(cmd, [globals, locals])
-                        return __original__(cmd, globals, locals)
-                    return p
-            @self._advise(ip.magic_prun)
-            def magic_prun_with_autoimport(*args, **kwargs):
-                logger.debug("magic_prun_with_autoimport()")
-                wrapped = FunctionWithGlobals(
-                    __original__, profile=ProfileFactory_with_autoimport())
-                return wrapped(*args, **kwargs)
-            return True
         else:
             logger.debug("Couldn't enable prun hook")
             return False
@@ -2335,41 +2243,6 @@ class AutoImporter(object):
         # python-2.x); we patch it here.
         return True
 
-    def _enable_ipython_bugfixes(self):
-        """
-        Enable some advice that's actually just fixing bugs in IPython.
-        """
-        ok = True
-        ok &= self._enable_ipython_bugfixes_LevelFormatter()
-        return ok
-
-    def _enable_ipython_bugfixes_LevelFormatter(self):
-        # New versions of IPython complain if you import 'IPython.config'.
-        # Old versions of IPython already have it imported.
-        if 'IPython.config' not in sys.modules:
-            return True
-        try:
-            from IPython.config.application import LevelFormatter
-        except ImportError:
-            return True
-        if (not issubclass(LevelFormatter, object) and
-            "super" in LevelFormatter.format.__func__.__code__.co_names and
-            "logging" not in LevelFormatter.format.__func__.__code__.co_names):
-            # In IPython 1.0, LevelFormatter uses super(), which assumes
-            # that logging.Formatter is a subclass of object.  However,
-            # this is only true in Python 2.7+, not in Python 2.6.  So
-            # Python 2.6 + IPython 1.0 causes problems.  IPython 1.2
-            # already includes this fix.
-            from logging import Formatter
-            @self._advise(LevelFormatter.format)
-            def format_patched(self, record):
-                if record.levelno >= self.highlevel_limit:
-                    record.highlevel = self.highlevel_format % record.__dict__
-                else:
-                    record.highlevel = ""
-                return Formatter.format(self, record)
-        return True
-
     def disable(self):
         """
         Turn off auto-importer in the current IPython session.
@@ -2464,7 +2337,8 @@ class AutoImporter(object):
             send_comm_message(MISSING_IMPORTS, {"missing_imports": str(imp)})
 
         return self._safe_call(
-            auto_import, arg, namespaces,
+            auto_import, arg=arg, namespaces=namespaces,
+            extra_db=self.db,
             autoimported=self._autoimported_this_cell,
             raise_on_error=raise_on_error, on_error=on_error,
             post_import_hook=post_import_hook)
@@ -2567,6 +2441,8 @@ def load_ipython_extension(arg=Ellipsis):
                  os.path.dirname(__file__))
     # Turn on the auto-importer.
     auto_importer = AutoImporter(arg)
+    if arg is not Ellipsis:
+        arg._auto_importer = auto_importer
     auto_importer.enable(even_if_previously_errored=True)
     # Clear ImportDB cache.
     ImportDB.clear_default_cache()
@@ -2584,6 +2460,7 @@ def load_ipython_extension(arg=Ellipsis):
     enable_signal_handler_debugger()
     enable_sigterm_handler(on_existing_handler='keep_existing')
     add_debug_functions_to_builtins()
+    inject_dynamic_import()
     initialize_comms()
 
 

pyflyby/_parse.py

@@ -23,10 +23,13 @@ import types
 from   typing                   import Any, List, Optional, Tuple, Union, cast
 import warnings
 
+
 _sentinel = object()
 
 if sys.version_info < (3, 10):
 
+    NoneType = type(None)
+
     class MatchAs:
         name: str
         pattern: ast.AST
@@ -36,6 +39,7 @@ if sys.version_info < (3, 10):
         patterns: List[MatchAs]
 
 else:
+    from types import NoneType
     from ast import MatchAs, MatchMapping
 
 
@@ -208,6 +212,7 @@ def _iter_child_nodes_in_order_internal_1(node):
         yield node.name,
     elif isinstance(node, MatchMapping):
         for k, p in zip(node.keys, node.patterns):
+            pass
             yield k, p
     else:
         # Default behavior.
@@ -962,6 +967,9 @@ class PythonBlock:
         :rtype:
           `PythonBlock`
         """
+        if isinstance(filename, str):
+            filename = Filename(filename)
+        assert isinstance(filename, (Filename, NoneType)), filename
         text = FileText(text, filename=filename, startpos=startpos)
         self = object.__new__(cls)
         self.text = text
@@ -973,7 +981,7 @@ class PythonBlock:
     def __construct_from_annotated_ast(cls, annotated_ast_nodes, text:FileText, flags):
         # Constructor for internal use by _split_by_statement() or
         # concatenate().
-        ast_node = AnnotatedModule(annotated_ast_nodes)
+        ast_node = AnnotatedModule(annotated_ast_nodes, type_ignores=[])
         ast_node.text = text
         ast_node.flags = flags
         if not hasattr(ast_node, "source_flags"):

pyflyby/_py.py

@@ -343,11 +343,11 @@ $ py                                       IPython shell
 # TODO: add --profile, --runsnake
 
 import ast
+import builtins
 from   contextlib               import contextmanager
 import inspect
 import os
 import re
-import builtins
 import sys
 import types
 from   types                    import FunctionType, MethodType
@@ -1303,7 +1303,7 @@ def _has_python_shebang(filename):
     Note that this test is only needed for scripts found via which(), since
     otherwise the shebang is not necessary.
     """
-    filename = Filename(filename)
+    assert isinstance(filename, Filename)
     with open(str(filename), 'rb') as f:
         line = f.readline(1024)
         return line.startswith(b"#!") and b"python" in line

pyflyby/_version.py

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