pyflyby 1.9.4__tar.gz → 1.9.6__tar.gz

{pyflyby-1.9.4/lib/python/pyflyby.egg-info → pyflyby-1.9.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyflyby
-Version: 1.9.4
+Version: 1.9.6
 Summary: pyflyby - Python development productivity tools, in particular automatic import management
 Home-page: https://pypi.org/project/pyflyby/
 Author: Karl Chen
@@ -18,9 +18,6 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python
 Requires-Python: >3.8, <4
 License-File: LICENSE.txt
-Requires-Dist: six
-Requires-Dist: toml
-Requires-Dist: black
 
 #########
  Pyflyby
@@ -105,6 +102,36 @@ or
    [PYFLYBY] from base64 import b64decode
    Out[1]: 'hello'
 
+Auto importer lazy variables
+----------------------------
+
+It is possible to use the autoimporter to lazily define variables.
+
+To use, put the following in your IPython startup files
+(``~/.ipython/profile_default/startup/autoimp.py``), or in your IPython
+configuration file:
+
+.. code:: python
+
+   
+    from pyflyby import add_import
+
+    add_import("foo", "foo = 1")
+
+    add_import(
+        "df, data as dd",
+        '''
+        import pandas as pd
+        data = [1,2,3]
+        df =  pd.DataFrame(data)
+    ''')
+
+
+You can add the keyword ``strict=False`` to not fail if not in IPython or of the
+pyflyby extensions is not loaded.
+
+
+
 
 Quick start: ``py`` command-line multi-tool
 ===========================================

{pyflyby-1.9.4 → pyflyby-1.9.6}/README.rst

@@ -81,6 +81,36 @@ or
    [PYFLYBY] from base64 import b64decode
    Out[1]: 'hello'
 
+Auto importer lazy variables
+----------------------------
+
+It is possible to use the autoimporter to lazily define variables.
+
+To use, put the following in your IPython startup files
+(``~/.ipython/profile_default/startup/autoimp.py``), or in your IPython
+configuration file:
+
+.. code:: python
+
+   
+    from pyflyby import add_import
+
+    add_import("foo", "foo = 1")
+
+    add_import(
+        "df, data as dd",
+        '''
+        import pandas as pd
+        data = [1,2,3]
+        df =  pd.DataFrame(data)
+    ''')
+
+
+You can add the keyword ``strict=False`` to not fail if not in IPython or of the
+pyflyby extensions is not loaded.
+
+
+
 
 Quick start: ``py`` command-line multi-tool
 ===========================================

{pyflyby-1.9.4 → pyflyby-1.9.6}/bin/pyflyby/__init__.py

@@ -6,6 +6,7 @@
 
 from   pyflyby._autoimp         import (auto_eval, auto_import,
                                         find_missing_imports)
+from   pyflyby._dynimp          import add_import
 from   pyflyby._dbg             import (add_debug_functions_to_builtins,
                                         attach_debugger, debug_on_exception,
                                         debug_statement, debugger,

{pyflyby-1.9.4 → pyflyby-1.9.6}/bin/pyflyby/_autoimp.py

@@ -19,7 +19,7 @@ from   pyflyby._importstmt      import Import
 from   pyflyby._log             import logger
 from   pyflyby._modules         import ModuleHandle
 from   pyflyby._parse           import (PythonBlock, _is_ast_str,
-                                        infer_compile_mode)
+                                        infer_compile_mode, MatchAs)
 
 from   six                      import reraise
 import sys
@@ -491,8 +491,11 @@ class _MissingImportFinder(object):
                 logger.debug(
                     "_MissingImportFinder has no method %r, using generic_visit", method
                 )
-
-            visitor = getattr(self, method, self.generic_visit)
+            if hasattr(self, method):
+                visitor = getattr(self, method)
+            else:
+                logger.debug("No method `%s`, using `generic_visit`", method)
+                visitor = self.generic_visit
             return visitor(node)
         else:
             raise TypeError("unexpected %s" % (type(node).__name__,))
@@ -827,6 +830,47 @@ class _MissingImportFinder(object):
         self._visit_StoreImport(node, modulename)
         self.generic_visit(node)
 
+    if sys.version_info >= (3,10):
+        def visit_match_case(self, node:ast.match_case):
+            logger.debug("visit_match_case(%r)", node)
+            return self.generic_visit(node)
+
+        def visit_Match(self, node:ast.Match):
+            logger.debug("visit_Match(%r)", node)
+            return self.generic_visit(node)
+
+        def visit_MatchMapping(self, node:ast.MatchMapping):
+            logger.debug("visit_MatchMapping(%r)", node)
+            return self.generic_visit(node)
+
+        def visit_MatchAs(self, node:MatchAs):
+            logger.debug("visit_MatchAs(%r)", node)
+            if node.name is None:
+                return
+            isinstance(node.name, str), node.name
+            return self._visit_Store(node.name)
+
+    def visit_Call(self, node:ast.Call):
+        logger.debug("visit_Call(%r)", node)
+        return self.generic_visit(node)
+
+    def visit_Pass(self, node:ast.Pass):
+        logger.debug("visit_Pass(%r)", node)
+        return self.generic_visit(node)
+
+    def visit_Constant(self, node:ast.Constant):
+        logger.debug("visit_Constant(%r)", node)
+        return self.generic_visit(node)
+
+    def visit_Module(self, node:ast.Module):
+        logger.debug("visit_Module(%r)", node)
+        return self.generic_visit(node)
+
+    def visit_Expr(self, node:ast.Expr):
+        logger.debug("visit_Expr(%r)", node)
+        return self.generic_visit(node)
+
+
     def visit_Name(self, node):
         logger.debug("visit_Name(%r)", node.id)
         self._visit_fullname(node.id, node.ctx)
@@ -884,7 +928,7 @@ class _MissingImportFinder(object):
             value = _UseChecker(name, imp, self._lineno)
         self._visit_Store(name, value)
 
-    def _visit_Store(self, fullname, value=None):
+    def _visit_Store(self, fullname:str, value=None):
         logger.debug("_visit_Store(%r)", fullname)
         if fullname is None:
             return
@@ -1860,7 +1904,7 @@ def auto_import_symbol(fullname, namespaces, db=None, autoimported=None, post_im
     return True
 
 
-def auto_import(arg, namespaces, db=None, autoimported=None, post_import_hook=None):
+def auto_import(arg, namespaces, db=None, autoimported=None, post_import_hook=None, *, extra_db=None):
     """
     Parse ``arg`` for symbols that need to be imported and automatically import
     them.
@@ -1914,6 +1958,8 @@ def auto_import(arg, namespaces, db=None, autoimported=None, post_import_hook=No
     if autoimported is None:
         autoimported = {}
     db = ImportDB.interpret_arg(db, target_filename=filename)
+    if extra_db:
+        db = db|extra_db
     ok = True
     for fullname in fullnames:
         ok &= auto_import_symbol(fullname, namespaces, db, autoimported, post_import_hook=post_import_hook)

{pyflyby-1.9.4/lib/python → pyflyby-1.9.6/bin}/pyflyby/_cmdline.py

@@ -4,10 +4,10 @@
 
 
 
+from   builtins                 import input
 import optparse
 import os
 import signal
-from   builtins                 import input
 import sys
 from   textwrap                 import dedent
 import traceback
@@ -285,7 +285,8 @@ def parse_args(
 def _default_on_error(filename):
     raise SystemExit("bad filename %s" % (filename,))
 
-def filename_args(args, on_error=_default_on_error):
+
+def filename_args(args: List[str], on_error=_default_on_error):
     """
     Return list of filenames given command-line arguments.
 
@@ -293,7 +294,9 @@ def filename_args(args, on_error=_default_on_error):
       ``list`` of `Filename`
     """
     if args:
-        return expand_py_files_from_args(args, on_error)
+        for a in args:
+            assert isinstance(a, str)
+        return expand_py_files_from_args([Filename(f) for f in args], on_error)
     elif not os.isatty(0):
         return [Filename.STDIN]
     else:

{pyflyby-1.9.4 → pyflyby-1.9.6}/bin/pyflyby/_dbg.py

@@ -909,23 +909,24 @@ def enable_faulthandler():
         faulthandler.enable()
 
 
-def add_debug_functions_to_builtins():
-    '''
+def add_debug_functions_to_builtins(*, add_deprecated: bool):
+    """
     Install debugger(), etc. in the builtin global namespace.
-    '''
+    """
     functions_to_add = [
         'debugger',
         'debug_on_exception',
         'print_traceback',
     ]
-    # DEPRECATED: In the future, the following will not be added to builtins.
-    # Use debugger() instead.
-    functions_to_add += [
-        'breakpoint',
-        'debug_exception',
-        'debug_statement',
-        'waitpoint',
-    ]
+    if add_deprecated:
+        # DEPRECATED: In the future, the following will not be added to builtins.
+        # Use debugger() instead.
+        functions_to_add += [
+            "breakpoint",
+            "debug_exception",
+            "debug_statement",
+            "waitpoint",
+        ]
     for name in functions_to_add:
         setattr(builtins, name, globals()[name])
 

pyflyby-1.9.6/bin/pyflyby/_dynimp.py

@@ -0,0 +1,152 @@
+"""
+Virtual module to create dynamic import at runtime.
+
+It is sometime desirable to have auto import which are define only during
+a session and never exist on a on-disk file.
+
+This is injects a Dict module loader as well as a dictionary registry of in
+memory module.
+
+This is mostly use in IPython for lazy variable initialisation without having
+to use proxy objects.
+
+To use, put the following in your IPython startup files
+(``~/.ipython/profile_default/startup/autoimp.py`), or in your IPython
+configuration file:
+
+
+.. code:: python
+
+    from pyflyby._dynimp import add_import
+
+    add_import("foo", "foo = 1")
+
+    add_import(
+        "df, data",
+        '''
+        import pandas as pd
+        data = [1,2,3]
+        df =  pd.DataFrame(data)
+    ''',
+    )
+
+Now at the IPython prompt, if the pyflyby extension is loaded (either because
+you started  using the ``py`` cli, or some configuration options like  ``ipython
+--TerminalIPythonApp.extra_extensions=pyflyby``. When trying to use an undefined
+variable like ``foo``, ``df`` or ``data``, the corresponding module will be
+executed and the relevant variable imported.
+
+
+"""
+import importlib.abc
+import importlib.util
+import sys
+
+from textwrap import dedent
+from typing import FrozenSet
+
+from pyflyby._importclns import ImportSet, Import
+
+module_dict = {}
+
+
+def add_import(names: str, code: str, *, strict: bool = True):
+    """
+    Add a runtime generated import module
+
+    Parameters
+    ----------
+    names: str
+        name, or comma separated list variable names that should be created by
+        executing and importing `code`.
+    code: str
+        potentially multiline string that will be turned into a module,
+        executed and from which variables listed in names can be imported.
+    strict: bool
+        Raise in case of problem loading IPython of if pyflyby extension not installed.
+        otherwise just ignore error
+
+
+
+    Examples
+    --------
+
+    >>> add_import('pd, df', '''
+    ...     import pandas a pd
+    ...
+    ...     df = pd.DataFrame([[1,2], [3,4]])
+    ... ''', strict=False)  # don't fail doctest
+
+    """
+    try:
+        ip = _raise_if_problem()
+    except Exception:
+        if strict:
+            raise
+        else:
+            return
+    return _add_import(ip, names, code)
+
+
+def _raise_if_problem():
+    try:
+        import IPython
+    except ModuleNotFoundError as e:
+        raise ImportError("Dynamic autoimport requires IPython to be installed") from e
+
+    ip = IPython.get_ipython()
+    if ip is None:
+        raise ImportError("Dynamic autoimport only work from within IPython")
+
+    if not hasattr(ip, "_auto_importer"):
+        raise ValueError(
+            "IPython needs to be loaded with pyflyby extension for lazy variable to work"
+        )
+    return ip
+
+
+def _add_import(ip, names: str, code: str) -> None:
+    """
+    private version of add_import
+    """
+    assert ip is not None
+    mang = "pyflyby_autoimport_" + names.replace(",", "_").replace(" ", "_")
+    a: FrozenSet[Import] = ImportSet(f"from {mang} import {names}")._importset
+    b: FrozenSet[Import] = ip._auto_importer.db.known_imports._importset
+    s_import: FrozenSet[Import] = a | b
+
+    ip._auto_importer.db.known_imports = ImportSet._from_imports(list(s_import))
+    module_dict[mang] = dedent(code)
+
+class DictLoader(importlib.abc.Loader):
+    """
+    A dict based loader for in-memory module definition.
+    """
+    def __init__(self, module_name, module_code):
+        self.module_name = module_name
+        self.module_code = module_code
+
+    def create_module(self, spec):
+        return None  # Use default module creation semantics
+
+    def exec_module(self, module):
+        """
+        we exec module code directly in memory
+        """
+        exec(self.module_code, module.__dict__)
+
+
+class DictFinder(importlib.abc.MetaPathFinder):
+    """
+    A meta path finder for abode DictLoader
+    """
+    def find_spec(self, fullname, path, target=None):
+        if fullname in module_dict:
+            module_code = module_dict[fullname]
+            loader = DictLoader(fullname, module_code)
+            return importlib.util.spec_from_loader(fullname, loader)
+        return None
+
+
+def inject():
+    sys.meta_path.insert(0, DictFinder())

{pyflyby-1.9.4/lib/python → pyflyby-1.9.6/bin}/pyflyby/_file.py

@@ -3,15 +3,20 @@
 # License: MIT http://opensource.org/licenses/MIT
 from __future__ import annotations
 
-from   functools                import total_ordering, cached_property
+from   functools                import cached_property, total_ordering
 import io
 import os
 import re
 import sys
-from   typing                   import Optional, Tuple, ClassVar
+from   typing                   import ClassVar, List, Optional, Tuple, Union
 
 from   pyflyby._util            import cmp, memoize
 
+if sys.version_info < (3,10):
+    NoneType = type(None)
+else:
+    from types import NoneType
+
 
 class UnsafeFilenameError(ValueError):
     pass
@@ -33,24 +38,27 @@ class Filename(object):
 
     def __new__(cls, arg):
         if isinstance(arg, cls):
-            return arg
+            # TODO make this assert False
+            return cls._from_filename(arg._filename)
         if isinstance(arg, str):
             return cls._from_filename(arg)
         raise TypeError
 
     @classmethod
-    def _from_filename(cls, filename):
+    def _from_filename(cls, filename: str):
         if not isinstance(filename, str):
             raise TypeError
-        filename = str(filename)
+        filename = os.path.abspath(filename)
         if not filename:
             raise UnsafeFilenameError("(empty string)")
-        if re.search("[^a-zA-Z0-9_=+{}/.,~@-]", filename):
-            raise UnsafeFilenameError(filename)
+        # we only allow filename with given character set
+        match = re.search("[^a-zA-Z0-9_=+{}/.,~@-]", filename)
+        if match:
+            raise UnsafeFilenameError((filename, match))
         if re.search("(^|/)~", filename):
             raise UnsafeFilenameError(filename)
         self = object.__new__(cls)
-        self._filename = os.path.abspath(filename)
+        self._filename =  filename
         return self
 
     def __str__(self):
@@ -373,6 +381,8 @@ class FileText:
         :rtype:
           ``FileText``
         """
+        if isinstance(filename, str):
+            filename = Filename(filename)
         if isinstance(arg, cls):
             if filename is startpos is None:
                 return arg
@@ -387,8 +397,8 @@ class FileText:
         else:
             raise TypeError("%s: unexpected %s"
                             % (cls.__name__, type(arg).__name__))
-        if filename is not None:
-            filename = Filename(filename)
+
+        assert isinstance(filename, (Filename, NoneType))
         startpos = FilePos(startpos)
         self.filename = filename
         self.startpos = startpos
@@ -439,9 +449,9 @@ class FileText:
     def from_filename(cls, filename):
         return cls.from_lines(Filename(filename))
 
-    def alter(self, filename=None, startpos=None):
+    def alter(self, filename: Optional[Filename] = None, startpos=None):
         if filename is not None:
-            filename = Filename(filename)
+            assert isinstance(filename, Filename)
         else:
             filename = self.filename
         if startpos is not None:
@@ -652,8 +662,8 @@ class FileText:
         return h
 
 
-def read_file(filename):
-    filename = Filename(filename)
+def read_file(filename: Filename) -> FileText:
+    assert isinstance(filename, Filename)
     if filename == Filename.STDIN:
         data = sys.stdin.read()
     else:
@@ -661,14 +671,15 @@ def read_file(filename):
             data = f.read()
     return FileText(data, filename=filename)
 
-def write_file(filename, data):
-    filename = Filename(filename)
+
+def write_file(filename: Filename, data):
+    assert isinstance(filename, Filename)
     data = FileText(data)
     with open(str(filename), 'w') as f:
         f.write(data.joined)
 
-def atomic_write_file(filename, data):
-    filename = Filename(filename)
+def atomic_write_file(filename: Filename, data):
+    assert isinstance(filename, Filename)
     data = FileText(data)
     temp_filename = Filename("%s.tmp.%s" % (filename, os.getpid(),))
     write_file(temp_filename, data)
@@ -680,7 +691,10 @@ def atomic_write_file(filename, data):
         pass
     os.rename(str(temp_filename), str(filename))
 
-def expand_py_files_from_args(pathnames, on_error=lambda filename: None):
+
+def expand_py_files_from_args(
+    pathnames: Union[List[Filename], Filename], on_error=lambda filename: None
+):
     """
     Enumerate ``*.py`` files, recursively.
 
@@ -698,8 +712,11 @@ def expand_py_files_from_args(pathnames, on_error=lambda filename: None):
       ``list`` of `Filename` s
     """
     if not isinstance(pathnames, (tuple, list)):
+        # July 2024 DeprecationWarning
+        # this seem to be used only internally, maybe deprecate not passing a list.
         pathnames = [pathnames]
-    pathnames = [Filename(f) for f in pathnames]
+    for f in pathnames:
+        assert isinstance(f, Filename)
     result = []
     # Check for problematic arguments.  Note that we intentionally only do
     # this for directly specified arguments, not for recursively traversed

{pyflyby-1.9.4/lib/python → pyflyby-1.9.6/bin}/pyflyby/_importclns.py

@@ -4,7 +4,7 @@
 
 from __future__ import annotations
 
-
+import sys
 
 from   collections              import defaultdict
 from   functools                import total_ordering
@@ -18,8 +18,18 @@ from   pyflyby._parse           import PythonBlock
 from   pyflyby._util            import (cached_attribute, cmp, partition,
                                         stable_unique)
 
-from   typing                   import (ClassVar, Dict, FrozenSet, List,
-                                        Sequence, Union)
+from typing import (
+    ClassVar,
+    Dict,
+    FrozenSet,
+    Sequence,
+    Union,
+)
+
+if sys.version_info < (3, 12):
+    from typing_extensions          import Self
+else:
+    from typing import Self
 
 
 class NoSuchImportError(ValueError):
@@ -30,7 +40,7 @@ class ConflictingImportsError(ValueError):
     pass
 
 @total_ordering
-class ImportSet(object):
+class ImportSet:
     r"""
     Representation of a set of imports organized into import statements.
 
@@ -49,8 +59,8 @@ class ImportSet(object):
     An ``ImportSet`` is an immutable data structure.
     """
 
-    _EMPTY : ClassVar[ImportSet]
-    _importset : FrozenSet[Import]
+    _EMPTY: ClassVar[ImportSet]
+    _importset: FrozenSet[Import]
 
     def __new__(cls, arg, ignore_nonimports=False, ignore_shadowed=False):
         """
@@ -80,8 +90,11 @@ class ImportSet(object):
             ignore_nonimports=ignore_nonimports,
             ignore_shadowed=ignore_shadowed)
 
+    def __or__(self: Self, other: Self) -> Self:
+        return type(self)._from_imports(list(self._importset | other._importset))
+
     @classmethod
-    def _from_imports(cls, imports:List[Import], ignore_shadowed:bool=False):
+    def _from_imports(cls, imports: Sequence[Import], ignore_shadowed: bool = False):
         """
         :type imports:
           Sequence of `Import` s
@@ -114,7 +127,7 @@ class ImportSet(object):
         return self
 
     @classmethod
-    def _from_args(cls, args, ignore_nonimports:bool=False, ignore_shadowed=False):
+    def _from_args(cls, args, ignore_nonimports:bool=False, ignore_shadowed=False) -> Self:
         """
         :type args:
           ``tuple`` or ``list`` of `ImportStatement` s, `PythonStatement` s,
@@ -133,7 +146,7 @@ class ImportSet(object):
         # more often.
         args = [a for a in args if a]
         if not args:
-            return cls._EMPTY
+            return cls._EMPTY  # type: ignore[return-value]
         # If we only got one ``ImportSet``, just return it.
         if len(args) == 1 and type(args[0]) is cls and not ignore_shadowed:
             return args[0]
@@ -543,9 +556,12 @@ class ImportMap(object):
             if not len(arg):
                 return cls._EMPTY
             return cls._from_map(arg)
-        else:
-            raise TypeError("ImportMap: expected a dict, not a %s"
-                            % (type(arg).__name__,))
+        raise TypeError("ImportMap: expected a dict, not a %s" % (type(arg).__name__,))
+
+    def __or__(self, other):
+        assert isinstance(other, ImportMap)
+        assert set(self._data.keys()).intersection(other._data.keys()) == set(), set(self._data.keys()).intersection(other._data.keys())
+        return self._merge([self, other])
 
     @classmethod
     def _from_map(cls, arg):
@@ -562,8 +578,8 @@ class ImportMap(object):
         if not maps:
             return cls._EMPTY
         data = {}
-        for map in maps:
-            data.update(map._data)
+        for map_ in maps:
+            data.update(map_._data)
         return cls(data)
 
     def __getitem__(self, k):