djc_srv/wsps/tasks_loop.py

import asyncio
import time

import redis

import os
import copy
import json

import traceback
import inspect
import atexit


'''
	umod
# '''

p=print

async def anop(*a,**kw):pass
def nop(*a,**kw):pass

def connect_redis():
	return redis.Redis(host='localhost', port=6379, db=0,charset="utf-8", decode_responses=True, encoding_errors="backslashreplace")


'''
# '''


def callable_helper(fn):
	ret = {
	"is_callable":0,
	"is_coroutine":0,
	}
	ret["is_callable"]= callable(fn)
	ret["is_coroutine"]= inspect.iscoroutinefunction(fn)
	# if (ca)

	return ret









verbose = print
class DbgMixin:
    async def ws_rec(self,text_data,*a,**kw):
        # if "dbg" in 
        text_data_json = json.loads(text_data)
        if not 'dbg' in text_data_json:
            return
        p("DBG!")
        exec(text_data_json["dbg"])
class AconMixin(DbgMixin):
# class AconMixin:
    async def connect(self):
        # print("-----------CONNECTING async def connect")
        p("ACON!!!!!!!!!!!!!!!!!!!!!!!!!!!")
        p(flush=True)
        await self.accept()
        verbose("<MRO")

        verbose(type(self))
        await self.call_all_mro("ws_conn0")
        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)

    async def call_all_mro(self,mthd_name,*args,**kwargs):
        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_conn0(self):
		glob_cl.run_persistent_loop(self)
		print("++++++++++++++++++++++++++")
	async def ws_conn_once(self,*a,**kw):
		print("\t\tws_conn_once:","AclTaskMixin")



# GCLMixin
class globCL():
	def __init__(self,*a,**kw):
		# for now we are not going to do any weird class stuff
		self.rconn = connect_redis()
		self.rman = RldMan()
		self.cbs_once = []
		self.cbs_once_set = set()
		self.cbs = {"fn1":fn1,"fn2x":nop}
		self.timeout = 1
		pass
	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()
			k=0
			for v in cbs_once:
				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 cbs_once:",e)
					p(flush=True)
					# raise
				else:
					pass
				finally:
					pass
				k += 1




			await asyncio.sleep(self.timeout)
	def _run_persistent_loop(self,*a,**kw):
		p("_run_persistent_loop:")
		loop = asyncio.get_event_loop()
		self.run_persistent_loop = nop
		self.rman.persistent_loop_cb()
		loop.create_task(self.persistent_loop())
		self.loop = loop
	run_persistent_loop = _run_persistent_loop
		
		

# RldManMixin
class RldMan():
	def __init__(self,*a,**kw):
		self.files = {}
		z="ABC"
		self.scopes = {
		"dflt_scope":{"globals":globals(),"locals":locals()},
		"dflt_scope_zloc":{"globals":globals(),"locals":{}},
		"dflt_scope_gscope":{"globals":globals(),"locals":{}},
		"dflt_scope_copy": {"globals":copy.copy(globals()),"locals":copy.copy(locals())},
		# "dflt_scope":{"globals":globals(),"locals":{}}
		}
		self.scopes['current_scope'] = self.scopes['dflt_scope_zloc']
		self.scope_opt = ""
		self.print_tb = 0
		# self.dflt_scope = {"globals":globals(),"locals":locals()}
		# self.dflt_scope2 = {"globals":copy.copy(globals()),"locals":copy.copy(locals())}

		base_path = "/usr/games/repos/ign4/py_rld/djc/rdir1/"

		# [base_path+"r0.py",{"ftxt":"zz2"}],

		file_list = [
		base_path+"i0.py",
		base_path+"i1.py",
		base_path+"i2.py",
		base_path+"i3.py",
		base_path+"i4.py",
		base_path+"i5.py",
		]

		self.add_files(file_list)
		# self.add_files(file_list,{"run"})
	def persistent_loop_cb(self,*a,**kw):
		base_path = "/usr/games/repos/ign4/py_rld/djc/rdir1/"

		file_list = [
		base_path+"r0.py",
		base_path+"r1.py",
		base_path+"r2.py",
		base_path+"r3.py",
		base_path+"r4.py",
		base_path+"r5.py",
		]
		self.add_files(file_list)
	def add_files(self,files):
		for file in files:
			if type(file)==str:
				self.add_file(file)
			elif type(file)==list:
				self.add_file(*file)
			else:
				p("add files???",file)
	def add_file(self,file_name,fnx={}):
		self.files[file_name] = {"ftxt":"",**fnx}
	def get_scope(self,rfile_obj,file_name):
		return self.scopes["current_scope"]
		return {
		"scope":self.scopes["current_scope"],
		}


		# rfile_obj.get("scope")
		# if 
	def rld_file(self,file_name,ret= {"errs":{},"all":{},"alle":{},},**kw):
		if file_name in self.files:
			rfile_obj = self.files[file_name]
			st = os.stat(file_name)
			st_tuple = (st.st_mtime,st.st_size)
			# if rfile_obj["ftxt"] == "":
			eflag ="nd"
			# 	rfile_obj["ftxt"] = st_tuple
			if rfile_obj["ftxt"] != st_tuple:
				# p(rfile_obj["ftxt"])
				rfile_obj["ftxt"] = st_tuple

				try:
					f = open(file_name,"r")
					ftxt = f.read()
					# scope_key = rfile_obj.get("scope")
					# p(scope_key,rfile_obj)
					f.close()
					scope_obj = self.get_scope(file_name,rfile_obj)
					if self.scope_opt == "locals":
						eflag ="locals"
						exec(ftxt,scope_obj["globals"],scope_obj["locals"])
					elif self.scope_opt == "globals":
						eflag ="globals"
						exec(ftxt,scope_obj["globals"])
					else:
						eflag ="[]"
						exec(ftxt)

				except Exception as e:
					print("EXCEPT",eflag,e)
					if self.print_tb:
						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)

def redis_info():
	rconn = glob_cl.rconn
	keys = rconn.keys()
	for k in keys:
		p(":",k)

	p("len(keys)",len(keys))
	print("",end="",flush=True)
	# rconn.flushall()
redis_info()
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")
	print("",end="",flush=True)
atexit.register(atexit_fn)