auto commit

wsps/tasks_loop.py

 from asgiref.sync import async_to_sync,sync_to_async
 
 
-'''
-	umod
-# '''
-
-
 
 p=print
 
 	return redis.Redis(host='localhost', port=6379, db=1,charset="utf-8", decode_responses=True, encoding_errors="backslashreplace")
 def connect_redis():
 	return redis.Redis(host='localhost', port=6379, db=0,charset="utf-8", decode_responses=True, encoding_errors="backslashreplace")
-	# return redis.Redis(host='localhost', port=6379,charset="utf-8", decode_responses=True, encoding_errors="backslashreplace")
-	r'''
-
-	return {
-	 "rconn0":redis.Redis(host='localhost', port=6379, db=0,charset="utf-8", decode_responses=True, encoding_errors="backslashreplace"),
-	 "rconn1":redis.Redis(host='localhost', port=6379, db=1,charset="utf-8", decode_responses=True, encoding_errors="backslashreplace"),
-	}
-	# '''
-
 
 
 def eclass_factory(n):
 	return ret
 
 
-'''
-# '''
-
 
 
 
 
 
 
-
-
-
-
-
-
-verbose = print
+# verbose = print
 verbose=nop
+
 class DbgMixin:
 	async def ws_rec(self,text_data,*a,**kw):
 		# if "dbg" in 
 class AconMixin(DbgMixin):
 # class AconMixin:
 	async def connect(self):
-		# print("-----------CONNECTING async def connect")
-		# p("ACON!!!!!!!!!!!!!!!!!!!!!!!!!!!")
-		p(flush=True)
+		p(end="",flush=True)
 		await self.accept()
 		verbose("<MRO")
 
 		await self.call_all_mro("ws_conn")
 		await self.call_all_mro("ws_conn2")
 		verbose("/MRO>")
-		# await self.ws_conn_once(event)		
 		await self.ws_conn_once()	   
 	async def ws_conn_once(self, *a,**kw):pass
 	async def ws_disconn_once(self, *a,**kw):pass
 	async def ws_rec_once(self, *a,**kw):pass
 	async def receive(self, *a,**kw):
-		# print("REC")
-		# print("-----------REC")
 		await self.call_all_mro("ws_rec",*a,**kw)
 		await self.ws_rec_once(*a,**kw)
 		print("",end="",flush=True)
 		called = set([None])
 		for cls_obj in self.__class__.__mro__:
 			mthd = getattr(cls_obj,mthd_name,None)
-			# print("~",cls_obj,mthd)
 			if not mthd in called:
-				# print(cls_obj,mthd)
 				called.add(mthd)
 				await mthd(self,*args,**kwargs) 
 	async def disconnect(self, close_code):
 		await self.call_all_mro("ws_disconn",close_code)
 		await self.ws_disconn_once(close_code)	  
-	async def websocket_connect_x(self, event):
-		await super().websocket_connect(event)
-		print("<MRO")
-		print(type(self))
-		await self.call_all_mro("ws_conn",event)
-		await self.call_all_mro("ws_conn2",event)
-		print("/MRO>")
-		await self.ws_conn_once(event)
 
 class AclTaskMixin:
 	async def ws_disconn(self,*a,**kw):
-		# for group in self.groups_set:
 		pass
 
 	async def ws_conn0(self):
 		if glob_cl.has_cl:
 			return
 		glob_cl.has_cl = True
-		print("AclTaskMixin:ws_conn0")
 		glob_cl.run_persistent_loop(self)
 		glob_cl.acl = self.channel_layer
-		# print("++++++++++++++++++++++++++")
-	async def ws_conn_once(self,*a,**kw):
-		pass
-		# print("\t\tws_conn_once:","AclTaskMixin")
+
 
 
 
 Mixins.AclTaskMixin = AclTaskMixin
 
 
-# GCLMixin
 class globCL(GCLMixin):
 
 	def __init__(self,*a,**kw):
 		# for now we are not going to do any weird class stuff
 		self.acl = None
-		self.has_cl = False
-		# rconns = connect_redis()
-		self.rconn1 = connect_redis1()
+		self.has_cl = False		self.rconn1 = connect_redis1()
 		self.rconn = connect_redis()
 		self.rman = RldMan()
 		self.cbs_once = []
 								await v({k,self})
 							else:
 								v({k,self})
-
 						else:
 							pass
-						# p(k,v)
-
-						pass
 					except Exception as e:
 						p("persistent_fast_cb_loop Exception cbs_once:",e)
 						p(flush=True)
-						# raise
 					else:
 						pass
 					finally:
 			await asyncio.sleep(self.fast_timeout)
 	async def persistent_loop(self,*a,**kw):
 		while 1:
-			# p("PL:",time.time(),flush=1)
-			# await asyncio.sleep(5)
-			# for k,v in cls.cbs.items():
 			for k,v in [*self.cbs.items()]:
 				try:
 					call_info = callable_helper(v)
 					if (call_info["is_callable"]):
 						if call_info["is_coroutine"]:
-							pass
 							await v({k,self})
 						else:
 							v({k,self})
-
 					else:
 						pass
-					# p(k,v)
-
 					pass
 				except Exception as e:
 					p("persistent_loop Exception",e)
 					p(flush=True)
-					# raise
 				else:
 					pass
 				finally:
 					pass
-			# cbs_once
 			cbs_once = [*self.cbs_once,*self.cbs_once_set]
 			self.cbs_once = []
 			self.cbs_once_set = set()
 
 					else:
 						pass
-					# p(k,v)
-
-					pass
 				except Exception as e:
 					p("persistent_loop Exception cbs_once:",e)
 					p(flush=True)
-					# raise
 				else:
 					pass
 				finally:
 		# "dflt_scope":{"globals":globals(),"locals":{}}
 		}
 		self.scopes['current_scope'] = self.scopes['dflt_scope_zloc']
-		# self.scope_opt = "locals"
+		# self.scope_opt = ""locals
 		self.scope_opt = "globals"
 		self.print_tb = 0
 
 						traceback.print_tb(e.__traceback__,file=sys.stdout)
 				else:
 					pass
-					# print("ELSE")
 				finally:
-					# print("FINALLY")
 					pass
 				print(end="",flush=True)
 		return ret
 
 
 	def rld_files(self):
-		# p()
-
 		ret = {
 		"errs":{},
 		"all":{},
 		"alle":{},
 		}
-		
-
-
-		# for k in self.files:
 		for k in [*self.files]:
 			self.rld_file(k,ret)
-		# p("rld_files!")
 		p("",end="",flush=True)
 		return ret
 
 def fn1(*a,**kw):
-	# rld_files
 	glob_cl.rman.rld_files()
 glob_cl =  globCL()
 
 glob_cl.rman.rld_files()
 
 
-
-
-# print("..",end="\n",flush=True)
-
-
-r"""
-
-def atexit_fn():
-	pass
-	# rconn.flushall()
-	print("ATEXIT FN")
-	rinfo_len()
-	keys = rconn.keys()
-	print(keys)
-	print(len(keys))
-	print("t 000")
-	# time.sleep(10)
-	print("t 010")
-	# time.sleep(20)
-	print("t 020")
-	print("ATEXIT FN...")
-	rconn.flushall()
-atexit.register(atexit_fn)
-
-
-
-# """
-
-
 def atexit_fn():
 	print("atexit_fn!\n\n")
 	rconn = glob_cl.rconn