micropython-stubber 1.14.1__py3-none-any.whl → 1.15.1__py3-none-any.whl

stubber/board/createstubs_lvgl_min.py

@@ -1,20 +1,21 @@
-t='{}/{}'
-s='method'
-r='function'
-q='bool'
-p='str'
-o='float'
-n='int'
-m='micropython'
-l='port'
-k=Exception
-j=NameError
-i=sorted
-h=NotImplementedError
+u='{}/{}'
+t='method'
+s='function'
+r='bool'
+q='str'
+p='float'
+o='int'
+n='micropython'
+m='port'
+l=Exception
+k=NameError
+j=sorted
+i=NotImplementedError
 A=',\n'
-Z='dict'
-Y='list'
-X='tuple'
+a='dict'
+Z='list'
+Y='tuple'
+X='stubber'
 W=open
 V=repr
 T='_'
@@ -31,37 +32,37 @@ J=print
 I=AttributeError
 H=False
 G='/'
-E=None
-D='version'
+E='version'
+D=None
 F=OSError
 B=''
 import gc as C,os,sys
-from ujson import dumps as a
+from ujson import dumps as b
 try:from machine import reset
 except P:pass
-try:from collections import OrderedDict as b
-except P:from ucollections import OrderedDict as b
-__version__='v1.13.8'
-u=2
+try:from collections import OrderedDict as c
+except P:from ucollections import OrderedDict as c
+__version__='v1.15.0'
 v=2
-w=[L,'/lib','/sd/lib','/flash/lib','lib']
+w=2
+x=[L,'/lib','/sd/lib','/flash/lib','lib']
 from time import sleep
 class Stubber:
-	def __init__(A,path=E,firmware_id=E):
+	def __init__(A,path=D,firmware_id=D):
 		B=firmware_id
 		try:
-			if os.uname().release=='1.13.0'and os.uname().version<'v1.13-103':raise h('MicroPython 1.13.0 cannot be stubbed')
+			if os.uname().release=='1.13.0'and os.uname().version<'v1.13-103':raise i('MicroPython 1.13.0 cannot be stubbed')
 		except I:pass
-		A._report=[];A.info=_info();J('Port: {}'.format(A.info[l]));J('Board: {}'.format(A.info[K]));C.collect()
+		A.log=D;A.log=logging.getLogger(X);A._report=[];A.info=_info();J('Port: {}'.format(A.info[m]));J('Board: {}'.format(A.info[K]));C.collect()
 		if B:A._fwid=B.lower()
-		elif A.info[N]==m:A._fwid='{family}-{ver}-{port}-{board}'.format(**A.info)
+		elif A.info[N]==n:A._fwid='{family}-{ver}-{port}-{board}'.format(**A.info)
 		else:A._fwid='{family}-{ver}-{port}'.format(**A.info)
 		A._start_free=C.mem_free()
 		if path:
 			if path.endswith(G):path=path[:-1]
 		else:path=get_root()
 		A.path='{}/stubs/{}'.format(path,A.flat_fwid).replace('//',G)
-		try:c(path+G)
+		try:d(path+G)
 		except F:J('error creating stub folder {}'.format(path))
 		A.problematic=['upip','upysh','webrepl_setup','http_client','http_client_ssl','http_server','http_server_ssl'];A.excluded=['webrepl','_webrepl','port_diag','example_sub_led.py','example_pub_button.py'];A.modules=[]
 	def get_obj_attributes(L,item_instance):
@@ -72,15 +73,15 @@ class Stubber:
 				E=getattr(H,A)
 				try:F=V(type(E)).split("'")[1]
 				except R:F=B
-				if F in{n,o,p,q,X,Y,Z}:G=1
-				elif F in{r,s}:G=2
+				if F in{o,p,q,r,Y,Z,a}:G=1
+				elif F in{s,t}:G=2
 				elif F in'class':G=3
 				else:G=4
 				D.append((A,V(E),V(type(E)),E,G))
 			except I as K:J.append("Couldn't get attribute '{}' from object '{}', Err: {}".format(A,H,K))
 			except MemoryError as K:sleep(1);reset()
-		D=i([A for A in D if not A[0].startswith('__')],key=lambda x:x[4]);C.collect();return D,J
-	def add_modules(A,modules):A.modules=i(set(A.modules)|set(modules))
+		D=j([A for A in D if not A[0].startswith('__')],key=lambda x:x[4]);C.collect();return D,J
+	def add_modules(A,modules):A.modules=j(set(A.modules)|set(modules))
 	def create_all_stubs(A):
 		C.collect()
 		for B in A.modules:A.create_one_stub(B)
@@ -92,17 +93,17 @@ class Stubber:
 		try:D=A.create_module_stub(B,E)
 		except F:return H
 		C.collect();return D
-	def create_module_stub(I,module_name,file_name=E):
-		D=file_name;A=module_name
-		if D is E:K=A.replace(L,T)+'.py';D=I.path+G+K
-		else:K=D.split(G)[-1]
+	def create_module_stub(I,module_name,file_name=D):
+		E=file_name;A=module_name
+		if E is D:K=A.replace(L,T)+'.py';E=I.path+G+K
+		else:K=E.split(G)[-1]
 		if G in A:A=A.replace(G,L)
-		M=E
-		try:M=__import__(A,E,E,'*');Q=C.mem_free();J('Stub module: {:<25} to file: {:<70} mem:{:>5}'.format(A,K,Q))
+		M=D
+		try:M=__import__(A,D,D,'*');Q=C.mem_free();J('Stub module: {:<25} to file: {:<70} mem:{:>5}'.format(A,K,Q))
 		except P:return H
-		c(D)
-		with W(D,'w')as N:R=str(I.info).replace('OrderedDict(',B).replace('})','}');U='"""\nModule: \'{0}\' on {1}\n"""\n# MCU: {2}\n# Stubber: {3}\n'.format(A,I._fwid,R,__version__);N.write(U);N.write('from typing import Any\nfrom _typeshed import Incomplete\n\n');I.write_object_stub(N,M,A,B)
-		I._report.append('{{"module": "{}", "file": "{}"}}'.format(A,D.replace('\\',G)))
+		d(E)
+		with W(E,'w')as N:R=str(I.info).replace('OrderedDict(',B).replace('})','}');U='"""\nModule: \'{0}\' on {1}\n"""\n# MCU: {2}\n# Stubber: {3}\n'.format(A,I._fwid,R,__version__);N.write(U);N.write('from typing import Any\nfrom _typeshed import Incomplete\n\n');I.write_object_stub(N,M,A,B)
+		I._report.append('{{"module": "{}", "file": "{}"}}'.format(A,E.replace('\\',G)))
 		if A not in{'os','sys','logging','gc'}:
 			try:del M
 			except (F,S):pass
@@ -117,23 +118,23 @@ class Stubber:
 		for (E,K,G,T,f) in R:
 			if E in['classmethod','staticmethod','BaseException',O]:continue
 			if E[0].isdigit():continue
-			if G=="<class 'type'>"and M(D)<=v*4:
+			if G=="<class 'type'>"and M(D)<=w*4:
 				U=B;V=E.endswith(O)or E.endswith('Error')or E in['KeyboardInterrupt','StopIteration','SystemExit']
 				if V:U=O
 				A='\n{}class {}({}):\n'.format(D,E,U)
 				if V:A+=D+'    ...\n';H.write(A);return
 				H.write(A);L.write_object_stub(H,T,'{0}.{1}'.format(obj_name,E),D+'    ',Q+1);A=D+'    def __init__(self, *argv, **kwargs) -> None:\n';A+=D+'        ...\n\n';H.write(A)
-			elif any((A in G for A in[s,r,'closure'])):
-				W=b;a=B
-				if Q>0:a='self, '
+			elif any((A in G for A in[t,s,'closure'])):
+				W=b;X=B
+				if Q>0:X='self, '
 				if c in G or c in K:A='{}@classmethod\n'.format(D)+'{}def {}(cls, *args, **kwargs) -> {}:\n'.format(D,E,W)
-				else:A='{}def {}({}*args, **kwargs) -> {}:\n'.format(D,E,a,W)
+				else:A='{}def {}({}*args, **kwargs) -> {}:\n'.format(D,E,X,W)
 				A+=D+'    ...\n\n';H.write(A)
 			elif G=="<class 'module'>":0
 			elif G.startswith("<class '"):
 				I=G[8:-2];A=B
-				if I in[p,n,o,q,'bytearray','bytes']:A=d.format(D,E,K,I)
-				elif I in[Z,Y,X]:e={Z:'{}',Y:'[]',X:'()'};A=d.format(D,E,e[I],I)
+				if I in[q,o,p,r,'bytearray','bytes']:A=d.format(D,E,K,I)
+				elif I in[a,Z,Y]:e={a:'{}',Z:'[]',Y:'()'};A=d.format(D,E,e[I],I)
 				else:
 					if I not in['object','set','frozenset']:I=b
 					A='{0}{1} : {2} ## {3} = {4}\n'.format(D,E,I,G,K)
@@ -141,25 +142,25 @@ class Stubber:
 			else:H.write("# all other, type = '{0}'\n".format(G));H.write(D+E+' # type: Incomplete\n')
 		del R;del N
 		try:del E,K,G,T
-		except (F,S,j):pass
+		except (F,S,k):pass
 	@property
 	def flat_fwid(self):
 		A=self._fwid;B=' .()/\\:$'
 		for C in B:A=A.replace(C,T)
 		return A
-	def clean(B,path=E):
-		if path is E:path=B.path
+	def clean(B,path=D):
+		if path is D:path=B.path
 		J('Clean/remove files in folder: {}'.format(path))
 		try:os.stat(path);C=os.listdir(path)
 		except (F,I):return
-		for D in C:
-			A=t.format(path,D)
+		for E in C:
+			A=u.format(path,E)
 			try:os.remove(A)
 			except F:
 				try:B.clean(A);os.rmdir(A)
 				except F:pass
 	def report(A,filename='modules.json'):
-		J('Created stubs for {} modules on board {}\nPath: {}'.format(M(A._report),A._fwid,A.path));E=t.format(A.path,filename);C.collect()
+		J('Created stubs for {} modules on board {}\nPath: {}'.format(M(A._report),A._fwid,A.path));E=u.format(A.path,filename);C.collect()
 		try:
 			with W(E,'w')as B:
 				A.write_json_header(B);D=O
@@ -167,12 +168,12 @@ class Stubber:
 				A.write_json_end(B)
 			I=A._start_free-C.mem_free()
 		except F:J('Failed to create the report.')
-	def write_json_header(C,f):B='firmware';f.write('{');f.write(a({B:C.info})[1:-1]);f.write(A);f.write(a({'stubber':{D:__version__},'stubtype':B})[1:-1]);f.write(A);f.write('"modules" :[\n')
+	def write_json_header(C,f):B='firmware';f.write('{');f.write(b({B:C.info})[1:-1]);f.write(A);f.write(b({X:{E:__version__},'stubtype':B})[1:-1]);f.write(A);f.write('"modules" :[\n')
 	def write_json_node(B,f,n,first):
 		if not first:f.write(A)
 		f.write(n)
 	def write_json_end(A,f):f.write('\n]}')
-def c(path):
+def d(path):
 	A=C=0
 	while A!=-1:
 		A=path.find(G,C)
@@ -180,7 +181,7 @@ def c(path):
 			B=path[0]if A==0 else path[:A]
 			try:H=os.stat(B)
 			except F as D:
-				if D.args[0]==u:
+				if D.args[0]==v:
 					try:os.mkdir(B)
 					except F as E:J('failed to create folder {}'.format(B));raise E
 		C=A+1
@@ -190,20 +191,20 @@ def U(s):
 	if A in s:s=s.split(A,1)[0]
 	return s.split('-')[1]if'-'in s else B
 def _info():
-	h='ev3-pybricks';g='pycom';f='pycopy';c='GENERIC';a='arch';Z='cpu';Y='ver';V='with';G='mpy';F='build';A=b({N:sys.implementation.name,D:B,F:B,Y:B,l:'stm32'if sys.platform.startswith('pyb')else sys.platform,K:c,Z:B,G:B,a:B})
-	try:A[D]=L.join([str(A)for A in sys.implementation.version])
+	h='ev3-pybricks';g='pycom';d='pycopy';b='GENERIC';a='arch';Z='cpu';Y='ver';V='with';G='mpy';F='build';A=c({N:sys.implementation.name,E:B,F:B,Y:B,m:'stm32'if sys.platform.startswith('pyb')else sys.platform,K:b,Z:B,G:B,a:B})
+	try:A[E]=L.join([str(A)for A in sys.implementation.version])
 	except I:pass
 	try:W=sys.implementation._machine if'_machine'in Q(sys.implementation)else os.uname().machine;A[K]=W.strip();A[Z]=W.split(V)[1].strip();A[G]=sys.implementation._mpy if'_mpy'in Q(sys.implementation)else sys.implementation.mpy if G in Q(sys.implementation)else B
 	except (I,R):pass
 	C.collect()
-	for J in [A+'/board_info.csv'for A in w]:
-		if e(J):
+	for J in [A+'/board_info.csv'for A in x]:
+		if f(J):
 			H=A[K].strip()
-			if d(A,H,J):break
+			if e(A,H,J):break
 			if V in H:
 				H=H.split(V)[0].strip()
-				if d(A,H,J):break
-			A[K]=c
+				if e(A,H,J):break
+			A[K]=b
 	A[K]=A[K].replace(' ',T);C.collect()
 	try:
 		A[F]=U(os.uname()[3])
@@ -211,21 +212,21 @@ def _info():
 		if not A[F]and';'in sys.version:A[F]=U(sys.version.split(';')[1])
 	except (I,R):pass
 	if A[F]and M(A[F])>5:A[F]=B
-	if A[D]==B and sys.platform not in('unix','win32'):
-		try:i=os.uname();A[D]=i.release
+	if A[E]==B and sys.platform not in('unix','win32'):
+		try:i=os.uname();A[E]=i.release
 		except (R,I,TypeError):pass
-	for (j,k,n) in [(f,f,'const'),(g,g,'FAT'),(h,'pybricks.hubs','EV3Brick')]:
-		try:o=__import__(k,E,E,n);A[N]=j;del o;break
+	for (j,k,l) in [(d,d,'const'),(g,g,'FAT'),(h,'pybricks.hubs','EV3Brick')]:
+		try:o=__import__(k,D,D,l);A[N]=j;del o;break
 		except (P,S):pass
 	if A[N]==h:A['release']='2.0.0'
-	if A[N]==m:
-		if A[D]and A[D].endswith('.0')and A[D]>='1.10.0'and A[D]<='1.19.9':A[D]=A[D][:-2]
+	if A[N]==n:
+		if A[E]and A[E].endswith('.0')and A[E]>='1.10.0'and A[E]<='1.19.9':A[E]=A[E][:-2]
 	if G in A and A[G]:
-		O=int(A[G]);X=[E,'x86','x64','armv6','armv6m','armv7m','armv7em','armv7emsp','armv7emdp','xtensa','xtensawin'][O>>10]
+		O=int(A[G]);X=[D,'x86','x64','armv6','armv6m','armv7m','armv7em','armv7emsp','armv7emdp','xtensa','xtensawin'][O>>10]
 		if X:A[a]=X
 		A[G]='v{}.{}'.format(O&255,O>>8&3)
-	A[Y]=f"v{A[D]}-{A[F]}"if A[F]else f"v{A[D]}";return A
-def d(info,board_descr,filename):
+	A[Y]=f"v{A[E]}-{A[F]}"if A[F]else f"v{A[E]}";return A
+def e(info,board_descr,filename):
 	with W(filename,'r')as B:
 		while 1:
 			A=B.readline()
@@ -241,36 +242,36 @@ def get_root():
 		try:C=os.stat(B);break
 		except F:continue
 	return B
-def e(filename):
+def f(filename):
 	try:
 		if os.stat(filename)[0]>>14:return O
 		return H
 	except F:return H
-def f():sys.exit(1)
+def g():sys.exit(1)
 def read_path():
 	path=B
 	if M(sys.argv)==3:
 		A=sys.argv[1].lower()
 		if A in('--path','-p'):path=sys.argv[2]
-		else:f()
-	elif M(sys.argv)==2:f()
+		else:g()
+	elif M(sys.argv)==2:g()
 	return path
-def g():
-	try:A=bytes('abc',encoding='utf8');B=g.__module__;return H
-	except (h,I):return O
+def h():
+	try:A=bytes('abc',encoding='utf8');B=h.__module__;return H
+	except (i,I):return O
 def main():
 	D='lvgl'
 	try:import lvgl as A
-	except k:return
+	except l:return
 	B=D
 	try:B='lvgl-{0}_{1}_{2}-{3}-{4}'.format(A.version_major(),A.version_minor(),A.version_patch(),A.version_info(),sys.platform)
-	except k:B='lvgl-{0}_{1}_{2}_{3}-{4}'.format(8,1,0,'dev',sys.platform)
+	except l:B='lvgl-{0}_{1}_{2}_{3}-{4}'.format(8,1,0,'dev',sys.platform)
 	finally:stubber=Stubber(firmware_id=B)
 	stubber.clean();stubber.modules=['io','lodepng','rtch',D];C.collect();stubber.create_all_stubs();stubber.report()
-if __name__=='__main__'or g():
-	try:logging.basicConfig(level=logging.INFO)
-	except j:pass
-	if not e('no_auto_stubber.txt'):
+if __name__=='__main__'or h():
+	try:y=logging.getLogger(X);logging.basicConfig(level=logging.INFO)
+	except k:pass
+	if not f('no_auto_stubber.txt'):
 		try:C.threshold(4*1024);C.enable()
 		except BaseException:pass
 		main()

stubber/board/createstubs_mem.py

@@ -9,7 +9,7 @@
     - cross compilation, using mpy-cross, 
       to avoid the compilation step on the micropython device 
 
-This variant was generated from createstubs.py by micropython-stubber v1.14.1
+This variant was generated from createstubs.py by micropython-stubber v1.15.1
 """
 # Copyright (c) 2019-2023 Jos Verlinde
 # pylint: disable= invalid-name, missing-function-docstring, import-outside-toplevel, logging-not-lazy
@@ -30,7 +30,7 @@ try:
 except ImportError:
     from ucollections import OrderedDict  # type: ignore
 
-__version__ = "v1.14.1"
+__version__ = "v1.15.1"
 ENOENT = 2
 _MAX_CLASS_LEVEL = 2  # Max class nesting
 LIBS = [".", "/lib", "/sd/lib", "/flash/lib", "lib"]
@@ -46,12 +46,12 @@ class Stubber:
                 raise NotImplementedError("MicroPython 1.13.0 cannot be stubbed")
         except AttributeError:
             pass
-
-        self._log = logging.getLogger("stubber")
+        self.log = None
+        self.log = logging.getLogger("stubber")
         self._report = []  # type: list[str]
         self.info = _info()
-        self._log.info("Port: {}".format(self.info["port"]))
-        self._log.info("Board: {}".format(self.info["board"]))
+        self.log.info("Port: {}".format(self.info["port"]))
+        self.log.info("Board: {}".format(self.info["board"]))
         gc.collect()
         if firmware_id:
             self._fwid = firmware_id.lower()
@@ -69,11 +69,11 @@ class Stubber:
             path = get_root()
 
         self.path = "{}/stubs/{}".format(path, self.flat_fwid).replace("//", "/")
-        self._log.debug(self.path)
+        self.log.debug(self.path)
         try:
             ensure_folder(path + "/")
         except OSError:
-            self._log.error("error creating stub folder {}".format(path))
+            self.log.error("error creating stub folder {}".format(path))
         self.problematic = [
             "upip",
             "upysh",
@@ -98,11 +98,11 @@ class Stubber:
         # name_, repr_(value), type as text, item_instance
         _result = []
         _errors = []
-        self._log.debug("get attributes {} {}".format(repr(item_instance), item_instance))
+        self.log.debug("get attributes {} {}".format(repr(item_instance), item_instance))
         for name in dir(item_instance):
             if name.startswith("_") and not name in self.modules:
                 continue
-            self._log.debug("get attribute {}".format(name))
+            self.log.debug("get attribute {}".format(name))
             try:
                 val = getattr(item_instance, name)
                 # name , item_repr(value) , type as text, item_instance, order
@@ -138,18 +138,18 @@ class Stubber:
 
     def create_all_stubs(self):
         "Create stubs for all configured modules"
-        self._log.info("Start micropython-stubber v{} on {}".format(__version__, self._fwid))
+        self.log.info("Start micropython-stubber v{} on {}".format(__version__, self._fwid))
         gc.collect()
         for module_name in self.modules:
             self.create_one_stub(module_name)
-        self._log.info("Finally done")
+        self.log.info("Finally done")
 
     def create_one_stub(self, module_name: str):
         if module_name in self.problematic:
-            self._log.warning("Skip module: {:<25}        : Known problematic".format(module_name))
+            self.log.warning("Skip module: {:<25}        : Known problematic".format(module_name))
             return False
         if module_name in self.excluded:
-            self._log.warning("Skip module: {:<25}        : Excluded".format(module_name))
+            self.log.warning("Skip module: {:<25}        : Excluded".format(module_name))
             return False
 
         file_name = "{}/{}.py".format(self.path, module_name.replace(".", "/"))
@@ -184,10 +184,10 @@ class Stubber:
         try:
             new_module = __import__(module_name, None, None, ("*"))
             m1 = gc.mem_free()  # type: ignore
-            self._log.info("Stub module: {:<25} to file: {:<70} mem:{:>5}".format(module_name, fname, m1))
+            self.log.info("Stub module: {:<25} to file: {:<70} mem:{:>5}".format(module_name, fname, m1))
 
         except ImportError:
-            self._log.warning("Skip module: {:<25} {:<79}".format(module_name, "Module not found."))
+            self.log.warning("Skip module: {:<25} {:<79}".format(module_name, "Module not found."))
             return False
 
         # Start a new file
@@ -207,11 +207,11 @@ class Stubber:
             try:
                 del new_module
             except (OSError, KeyError):  # lgtm [py/unreachable-statement]
-                self._log.warning("could not del new_module")
+                self.log.warning("could not del new_module")
             try:
                 del sys.modules[module_name]
             except KeyError:
-                self._log.debug("could not del sys.modules[{}]".format(module_name))
+                self.log.debug("could not del sys.modules[{}]".format(module_name))
         gc.collect()
         return True
 
@@ -219,14 +219,14 @@ class Stubber:
         "Write a module/object stub to an open file. Can be called recursive."
         gc.collect()
         if object_expr in self.problematic:
-            self._log.warning("SKIPPING problematic module:{}".format(object_expr))
+            self.log.warning("SKIPPING problematic module:{}".format(object_expr))
             return
 
-        # self._log.debug("DUMP    : {}".format(object_expr))
+        # self.log.debug("DUMP    : {}".format(object_expr))
         items, errors = self.get_obj_attributes(object_expr)
 
         if errors:
-            self._log.error(errors)
+            self.log.error(errors)
 
         for item_name, item_repr, item_type_txt, item_instance, _ in items:
             # name_, repr_(value), type as text, item_instance, order
@@ -234,11 +234,11 @@ class Stubber:
                 # do not create stubs for these primitives
                 continue
             if item_name[0].isdigit():
-                self._log.warning("NameError: invalid name {}".format(item_name))
+                self.log.warning("NameError: invalid name {}".format(item_name))
                 continue
             # Class expansion only on first 3 levels (bit of a hack)
             if item_type_txt == "<class 'type'>" and len(indent) <= _MAX_CLASS_LEVEL * 4:
-                self._log.debug("{0}class {1}:".format(indent, item_name))
+                self.log.debug("{0}class {1}:".format(indent, item_name))
                 superclass = ""
                 is_exception = (
                     item_name.endswith("Exception")
@@ -261,7 +261,7 @@ class Stubber:
                 # write classdef
                 fp.write(s)
                 # first write the class literals and methods
-                self._log.debug("# recursion over class {0}".format(item_name))
+                self.log.debug("# recursion over class {0}".format(item_name))
                 self.write_object_stub(
                     fp,
                     item_instance,
@@ -275,7 +275,7 @@ class Stubber:
                 s += indent + "        ...\n\n"
                 fp.write(s)
             elif any(word in item_type_txt for word in ["method", "function", "closure"]):
-                self._log.debug("# def {1} function/method/closure, type = '{0}'".format(item_type_txt, item_name))
+                self.log.debug("# def {1} function/method/closure, type = '{0}'".format(item_type_txt, item_name))
                 # module Function or class method
                 # will accept any number of params
                 # return type Any/Incomplete
@@ -291,7 +291,7 @@ class Stubber:
                     s = "{}def {}({}*args, **kwargs) -> {}:\n".format(indent, item_name, first, ret)
                 s += indent + "    ...\n\n"
                 fp.write(s)
-                self._log.debug("\n" + s)
+                self.log.debug("\n" + s)
             elif item_type_txt == "<class 'module'>":
                 # Skip imported modules
                 # fp.write("# import {}\n".format(item_name))
@@ -317,10 +317,10 @@ class Stubber:
                     # Requires Python 3.6 syntax, which is OK for the stubs/pyi
                     s = "{0}{1} : {2} ## {3} = {4}\n".format(indent, item_name, t, item_type_txt, item_repr)
                 fp.write(s)
-                self._log.debug("\n" + s)
+                self.log.debug("\n" + s)
             else:
                 # keep only the name
-                self._log.debug("# all other, type = '{0}'".format(item_type_txt))
+                self.log.debug("# all other, type = '{0}'".format(item_type_txt))
                 fp.write("# all other, type = '{0}'\n".format(item_type_txt))
 
                 fp.write(indent + item_name + " # type: Incomplete\n")
@@ -346,7 +346,7 @@ class Stubber:
         "Remove all files from the stub folder"
         if path is None:
             path = self.path
-        self._log.info("Clean/remove files in folder: {}".format(path))
+        self.log.info("Clean/remove files in folder: {}".format(path))
         try:
             os.stat(path)  # TEMP workaround mpremote listdir bug -
             items = os.listdir(path)
@@ -366,9 +366,9 @@ class Stubber:
 
     def report(self, filename: str = "modules.json"):
         "create json with list of exported modules"
-        self._log.info("Created stubs for {} modules on board {}\nPath: {}".format(len(self._report), self._fwid, self.path))
+        self.log.info("Created stubs for {} modules on board {}\nPath: {}".format(len(self._report), self._fwid, self.path))
         f_name = "{}/{}".format(self.path, filename)
-        self._log.info("Report file: {}".format(f_name))
+        self.log.info("Report file: {}".format(f_name))
         gc.collect()
         try:
             # write json by node to reduce memory requirements
@@ -380,9 +380,9 @@ class Stubber:
                     first = False
                 self.write_json_end(f)
             used = self._start_free - gc.mem_free()  # type: ignore
-            self._log.info("Memory used: {0} Kb".format(used // 1024))
+            self.log.info("Memory used: {0} Kb".format(used // 1024))
         except OSError:
-            self._log.error("Failed to create the report.")
+            self.log.error("Failed to create the report.")
 
     def write_json_header(self, f):
         f.write("{")
@@ -417,7 +417,7 @@ def ensure_folder(path: str):
                     try:
                         os.mkdir(p)
                     except OSError as e2:
-                        _log.error("failed to create folder {}".format(p))
+                        log.error("failed to create folder {}".format(p))
                         raise e2
         # next level deep
         start = i + 1
@@ -647,19 +647,23 @@ def main():
     stubber.modules = []  # avoid duplicates
     for p in LIBS:
         try:
+            _1 = gc.mem_free()  # type: ignore
             with open(p + "/modulelist.txt") as f:
-                print("DEBUG: list of modules: " + p + "/modulelist.txt")
-                for line in f.read().split("\n"):
+                print("Debug: List of modules: " + p + "/modulelist.txt")
+                line = f.readline()
+                while line:
                     line = line.strip()
                     if len(line) > 0 and line[0] != "#":
                         stubber.modules.append(line)
-                gc.collect()
+                    line = f.readline()
+                gc.collect()  # type: ignore
+                print("Debug: Used memory to load modulelist.txt: " + str(_1 - gc.mem_free()) + " bytes")  # type: ignore
                 break
-        except OSError:
+        except Exception:
             pass
     if not stubber.modules:
         stubber.modules = ["micropython"]
-        _log.warn("Could not find modulelist.txt, using default modules")
+        print("Could not find modulelist.txt, using default modules")
 
     gc.collect()
 
@@ -669,7 +673,7 @@ def main():
 
 if __name__ == "__main__" or is_micropython():
     try:
-        _log = logging.getLogger("stubber")
+        log = logging.getLogger("stubber")
         logging.basicConfig(level=logging.INFO)
         # logging.basicConfig(level=logging.DEBUG)
     except NameError: