Update LEARNING/IMPORT

Author: atomicoo

LEARNING/IMPORT/0_AbsoluteImport/main.py

@@ -0,0 +1 @@
+from pkg import run

LEARNING/IMPORT/0_AbsoluteImport/pkg/__init__.py

@@ -0,0 +1,4 @@
+print(__name__)
+print(__package__)
+
+a = 2

LEARNING/IMPORT/0_AbsoluteImport/pkg/foo.py

@@ -0,0 +1,8 @@
+print(__name__)
+print(__package__)
+
+from pkg.foo import a
+print(a)
+
+from pkg.sub.bar import b
+print(b)

LEARNING/IMPORT/0_AbsoluteImport/pkg/run.py

@@ -0,0 +1,4 @@
+print(__name__)
+print(__package__)
+
+b = 3

LEARNING/IMPORT/0_AbsoluteImport/pkg/sub/__init__.py

@@ -0,0 +1 @@
+from pkg import run

LEARNING/IMPORT/0_AbsoluteImport/pkg/sub/bar.py

@@ -0,0 +1,4 @@
+print(__name__)
+print(__package__)
+
+a = 2

LEARNING/IMPORT/0_RelativeImport/main.py

@@ -0,0 +1,8 @@
+print(__name__)
+print(__package__)
+
+from .foo import a
+print(a)
+
+from .sub.bar import b
+print(b)

LEARNING/IMPORT/0_RelativeImport/pkg/__init__.py

@@ -0,0 +1,4 @@
+print(__name__)
+print(__package__)
+
+b = 3

LEARNING/IMPORT/0_RelativeImport/pkg/foo.py

@@ -0,0 +1 @@
+print("pkg.sub.foo")

LEARNING/IMPORT/0_RelativeImport/pkg/run.py

@@ -0,0 +1,12 @@
+import sys
+
+class MyFinder(object):
+    @classmethod
+    def find_module(cls, name, path, target=None):
+        print("Importing", name, path, target)
+        return None
+
+sys.meta_path.insert(0, MyFinder)
+
+# import socket
+import pkg.sub.foo

LEARNING/IMPORT/0_RelativeImport/pkg/sub/__init__.py

@@ -0,0 +1 @@
+string = 'spec'

LEARNING/IMPORT/0_RelativeImport/pkg/sub/bar.py

@@ -0,0 +1,2 @@
+import foo
+print(foo.__spec__)

LEARNING/IMPORT/1_Finder/pkg/__init__.py

@@ -0,0 +1 @@
+print('reload')

LEARNING/IMPORT/1_Finder/pkg/sub/foo.py

@@ -0,0 +1,7 @@
+import importlib
+import foo
+import foo
+print('======')
+import pdb
+pdb.set_trace() # 设置断点
+importlib.reload(foo)

LEARNING/IMPORT/1_Finder/run.py

@@ -0,0 +1,29 @@
+import sys
+import subprocess
+from importlib import import_module
+
+# Debugging
+import logging
+logging.basicConfig(format='%(asctime)s - %(pathname)s[line:%(lineno)d] - %(levelname)s: %(message)s',
+                    level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+
+class AutoInstall(object):
+    _loaded = set()
+
+    @classmethod
+    def find_module(cls, name, path=None, target=None):
+        logger.debug("Find module: name=%s, path=%s", name, path)
+        if path is None and name not in cls._loaded:
+            cls._loaded.add(name)
+            logger.debug("Find module: installing %s", name)
+            try:
+                out = subprocess.check_output([sys.executable, '-m', 'pip', 'install', name])
+                logger.debug("Find module: out=%r", out.decode('utf-8'))
+            except Exception as e:
+                logger.debug("Find module: install failed. %s", e)
+        return None
+
+logger.debug("Meta path: add finder `AutoInstall`")
+sys.meta_path.append(AutoInstall)

LEARNING/IMPORT/1_ModuleSpec/foo.py

@@ -0,0 +1,20 @@
+import logging
+import sys
+
+import core
+
+logger = logging.getLogger()
+logger.setLevel("DEBUG")
+
+
+logger.info("Import module tornado")
+try:
+    import tornado
+except:
+    import tornado
+logger.info("Install module tornado")
+
+logger.info(tornado.__name__)
+logger.info(tornado.__doc__)
+
+logger.info("Done")

LEARNING/IMPORT/1_ModuleSpec/run.py

@@ -0,0 +1,61 @@
+import sys
+
+from importlib import import_module
+from importlib.abc import Finder, Loader
+from importlib.machinery import ModuleSpec
+
+
+# Debugging
+import logging
+logging.basicConfig(format='%(asctime)s - %(pathname)s[line:%(lineno)d] - %(levelname)s: %(message)s',
+                    level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+class LazyFinder(Finder):
+    _lazy_modules = { }
+
+    @classmethod
+    def find_spec(cls, fullname, path=None, target=None):
+        spec = cls._lazy_modules.get(fullname, None)
+        if spec and spec.import_please:
+            logger.debug(f"Attribute in module '{fullname}' requested, actually importing")
+            # Returning None means we skip this finder.
+            return None
+        spec = ModuleSpec(fullname, LazyLoader())
+        cls._lazy_modules[fullname] = spec
+        return spec
+
+
+class LazyLoader(Loader):
+    def create_module(self, spec):
+        return LazyModule(spec)
+
+    def exec_module(self, module):
+        return module
+
+
+class LazyModule:
+    def __init__(self, spec):
+        self.spec = spec
+        self.imported = False
+
+    def _import(self):
+        self.spec.import_please = True
+        del sys.modules[self.spec.name]
+        self.module = import_module(self.spec.name)
+        sys.modules[self.spec.name] = self.module
+        # TODO After this, the LazyModule is still bound.
+        # Since I set it here, the import machinery must do it after.
+        self.imported = True
+
+    def __getattr__(self, attr):
+        if self.imported:
+            pass
+        # It'd be great to avoid it trying to import this in the first place.
+        elif attr in ["__name__", "__loader__", "__package__", "__path__"]:
+            return None
+        elif not self.imported:
+            self._import()
+        return self.module.__getattribute__(attr)
+
+sys.meta_path = sys.meta_path[:-1] + [LazyFinder] + sys.meta_path[-1:]

LEARNING/IMPORT/1_Reload/foo.py

@@ -0,0 +1,16 @@
+import logging
+import sys
+
+import core
+
+logger = logging.getLogger()
+logger.setLevel("DEBUG")
+
+logger.info("Importing module small")
+import small
+logger.info("Module small 'imported'")
+
+logger.info(small.x)
+logger.info(small.__name__)
+
+logger.info("Done")

LEARNING/IMPORT/1_Reload/run.py

@@ -0,0 +1,11 @@
+import logging
+import time
+
+logger = logging.getLogger()
+logger.setLevel("DEBUG")
+
+logger.info("Sleeping!")
+time.sleep(1)
+logger.info("Done sleeping!")
+
+x = "Hello from small!"

LEARNING/IMPORT/3_AutoInstall/core.py

@@ -0,0 +1,67 @@
+import logging
+import sys
+
+from importlib import import_module
+from importlib.abc import Finder, Loader
+from importlib.machinery import ModuleSpec
+
+
+logger = logging.getLogger()
+logger.setLevel(logging.DEBUG)
+formatter = logging.Formatter("%(asctime)s - %(levelname)s - %(message)s")
+handler = logging.StreamHandler()
+handler.setFormatter(formatter)
+logger.addHandler(handler)
+
+class LazyFinder(Finder):
+    _lazy_modules = { }
+
+    @classmethod
+    def find_spec(cls, fullname, path=None, target=None):
+        spec = cls._lazy_modules.get(fullname, None)
+        if spec:
+            logger.debug(f"Attribute in module '{fullname}' requested, actually importing")
+            return None
+        spec = ModuleSpec(fullname, LazyLoader())
+        cls._lazy_modules[fullname] = spec
+        return spec
+
+
+class LazyLoader(Loader):
+    def create_module(self, spec):
+        return LazyModule(spec)
+
+    def exec_module(self, module):
+        return module
+
+
+class LazyModule:
+    def __init__(self, spec):
+        self.spec = spec
+        self.imported = False
+
+    def _import(self):
+        del sys.modules[self.spec.name]
+        self.module = import_module(self.spec.name)
+        sys.modules[self.spec.name] = self.module
+        self.imported = True
+
+    def __getattr__(self, attr):
+        if attr in ["__name__", "__loader__", "__package__", "__path__"]:
+            return None
+        elif not self.imported:
+            self._import()
+        return self.module.__getattribute__(attr)
+
+sys.meta_path = sys.meta_path[:-1] + [LazyFinder] + sys.meta_path[-1:]
+
+
+if __name__ == '__main__':
+    logger.info("Do Lazy Import")
+
+    logger.info("Importing module small")
+    import small
+    logger.info("Module small 'imported'")
+    logger.info(small.x)
+    logger.info(small.__name__)
+    logger.info("Done")

LEARNING/IMPORT/3_AutoInstall/main.py

@@ -0,0 +1,95 @@
+import sys
+from importlib import abc
+from importlib.machinery import ModuleSpec
+import imp
+from urllib.request import urlopen
+
+# Debugging
+import logging
+logging.basicConfig(format='%(asctime)s - %(pathname)s[line:%(lineno)d] - %(levelname)s: %(message)s',
+                    level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+
+def load_module(url):
+    logger.debug("Load module: get source from %s", url)
+    u = urlopen(url)
+    s = u.read().decode('utf-8')
+    logger.debug("Load module: create module %s", url)
+    m = sys.modules.setdefault(url, imp.new_module(url))
+    c = compile(s, url, 'exec')
+    m.__file__ = url
+    m.__package__ = ''
+    logger.debug("Load module: exec code object %s", c)
+    exec(c, m.__dict__)
+    return m
+
+class UrlMetaFinder(abc.MetaPathFinder):
+    def __init__(self, baseurl):
+        self._baseurl = baseurl
+    
+    def find_module(self, fullname, path=None):
+        logger.debug("Find module: fullname=%s, path=%s", fullname, path)
+        if path is None:
+            baseurl = self._baseurl
+        else:
+            if not path.startswith(self._baseurl):
+                return None
+            baseurl = path
+        try:
+            logger.debug("Find module: module %s found", fullname)
+            loader = UrlMetaLoader(baseurl)
+            return loader
+        except Exception:
+            logger.debug("Find module: module %s not found", fullname)
+            return None
+
+    # def find_spec(self, fullname, path=None, target=None):
+    #     if path is None:
+    #         baseurl = self._baseurl
+    #     else:
+    #         if not path.startswith(self._baseurl):
+    #             return None
+    #         baseurl = path
+    #     try:
+    #         loader = UrlMetaLoader(baseurl)
+    #         return ModuleSpec(fullname, loader, is_package=loader.is_package(fullname))
+    #     except Exception:
+    #         return None
+        
+
+class UrlMetaLoader(abc.SourceLoader):
+    def __init__(self, baseurl):
+        self._baseurl = baseurl
+    
+    # def load_module(self, fullname):
+    #     c = self.get_code(fullname)
+    #     m = sys.modules.setdefault(fullname, imp.new_module(fullname))
+    #     m.__file__ = self.get_filename(fullname)
+    #     m.__loader__ = self
+    #     m.__package__ = fullname
+    #     exec(c, m.__dict__)
+    #     return None
+    
+    def get_code(self, fullname):
+        u = urlopen(self.get_filename(fullname))
+        return u.read()
+
+    # def execute_module(self, module):
+    #     pass
+
+    def get_data(self):
+        pass
+
+    def get_filename(self, fullname):
+        return self._baseurl + fullname + '.py'
+
+def install_meta(address):
+    finder = UrlMetaFinder(address)
+    sys.meta_path.append(finder)
+    logger.debug('%s installed on sys.meta_path', finder)
+
+
+if __name__ == '__main__':
+    print("Base Url Import.")
+