initial commit jsyncdb monorepo

.gitignore

@@ -0,0 +1 @@
+*.pyc

README.md

@@ -0,0 +1,9 @@
+# <p align="center">jsyncdb</p>
+
+Jsyncdb synchronizes json compatable javascript objects
+This will be a mono repo for jsyncdb clients and servers
+
+**Author:** 
+[Joseph Innace](https://github.com/JInnace)
+
+> Written with [StackEdit](https://stackedit.io/).

flask_server/app.py

@@ -0,0 +1,106 @@
+from flask import Flask, render_template
+from flask_sock import Sock
+import flask
+import hot_reload_mod_i2
+import gmod
+
+# app = Flask(__name__)
+app = Flask(__name__,template_folder = r"../js_client")
+
+
+sock = Sock(app)
+
+
+
+
+gmod.glob["sock"] = sock
+gmod.glob["app"] = app
+
+class Eobj():
+	pass
+
+eobj = Eobj()
+gmod.gx =eobj
+
+import rld_m0
+import rld_m1
+import rld_m2
+import rld_m3
+# import rld_m4
+# import rld_m5
+
+p=print
+
+
+@app.route('/')
+def index():
+	print("::::::::::::::;")
+	# return render_template('jsyncdb_index_v5.html')
+	return render_template('index.html')
+
+# r'''
+@app.route('/shared_libs/<path:path>')
+def send_report2(path):
+	return flask.send_file('templates/jquery-3.5.1.min.js')
+
+@app.route('/<path:path>')
+def send_report(path):
+	return flask.send_from_directory('templates', path)
+	# return flask.send_from_directory('./', path)
+# '''
+
+
+@sock.route('/echo')
+def echo(sock):
+	while True:
+		data = sock.receive()
+		sock.send(data)
+
+
+
+# @sock.route('/echo_c1')
+# def echo_coll(sock):
+# 	p("echo_coll app")
+# 	while True:
+# 		data = sock.receive()
+# 		sock.send(data)
+
+
+
+
+
+# @sock.route('/<path:path>')
+# def echo23(sock,*a,**kw):
+#	 p("E2",a,kw)
+#	 while True:
+#		 data = sock.receive()
+#		 sock.send(data)
+#		 for en in dir(sock):
+#			 p(en)
+# p("echo23",echo23)
+
+
+# p("~83293298383838383")
+r'''
+for en in dir(sock):
+	print(".",en)
+
+for en in dir(app):
+	print("~",en)
+'''
+
+
+
+import inspect
+print("APP_ORIG",sock.route)
+print("APP_ORIG",app.route)
+print("APP_ORIG",inspect.getfile(app.route))
+print("APP_ORIG",app.url_map)
+if __name__ == '__main__':
+	pass
+	# socketio.run(app, debug=True)
+	app.run(debug=True,host='0.0.0.0')
+	# sock.run(app,host='0.0.0.0', debug=True,allow_unsafe_werkzeug=True)
+
+
+

flask_server/gmod.py

@@ -0,0 +1,78 @@
+# import gmod2
+
+
+print("===========================================================================================================================================")
+
+
+OKBLUE = '\033[94m'
+ENDC = '\033[0m'
+
+# print("GLOBA_REINIT" ,OKBLUE,"###################################################################",ENDC)
+
+glob = {}
+dbg_glob = {}
+
+
+
+
+
+glob["WSGI_RLD_HANDLERS"] = []
+def before_mod_rld(mod,*a,**kw):
+	h = getattr(mod,"MOD_RLD_HANDLERS",None)
+	print("before_mod_rld:",mod,h)
+	cnt=0
+	while h:
+		fn=h.pop()
+		print(cnt)
+		cnt+=1
+
+		fn()
+
+def reg_mod_rld_handler(mod,fn,*a,**kw):
+	h = getattr(mod,"MOD_RLD_HANDLERS",None)
+	if h is None:
+		mod.MOD_RLD_HANDLERS = []
+		h= mod.MOD_RLD_HANDLERS
+	h.append(fn)
+	print("reg_mod_rld_handler:",h,mod)
+
+
+
+def unreg_rld_handler(fn,*a,**kw):
+	if fn in glob["WSGI_RLD_HANDLERS"]:
+		print("unreg_rld_handler",fn)
+		glob["WSGI_RLD_HANDLERS"].remove(fn)
+	else:
+		print("unreg_rld_handler~~~",fn)
+		# print()
+
+
+def reg_rld_handler(fn,*a,**kw):
+	glob["WSGI_RLD_HANDLERS"].append(fn)
+def before_wsgi_rld(s=""):
+	print("before_wsgi_rld:",s)
+	cnt=0
+	while glob["WSGI_RLD_HANDLERS"]:
+		fn=glob["WSGI_RLD_HANDLERS"].pop()
+		print(cnt)
+		cnt+=1
+
+		fn()
+
+
+
+
+
+
+# or should we do import
+# is this better or the worst way we shall find out
+def W():
+	return glob
+
+
+
+
+
+
+
+

flask_server/hot_reload_mod_i2.py

@@ -0,0 +1,170 @@
+
+
+from werkzeug import _reloader
+p=print
+
+import typing as t
+import threading
+
+import sys
+import os
+import importlib
+import traceback
+
+
+custom_rld_substr = "rld"
+custom_rld_list = []
+mscope={
+	"ReloaderLoop_trigger_reload": _reloader.ReloaderLoop.trigger_reload,
+	"WatchdogReloaderLoop_trigger_reload": _reloader.WatchdogReloaderLoop.trigger_reload,
+}
+
+def reset_mtime(reloader,file_path):
+		old_time = reloader.mtimes.get(file_path)
+		mtime = os.stat(file_path).st_mtime
+		reloader.mtimes[file_path]=mtime
+
+		return {
+			"old_time":old_time,
+			"new_time":mtime,
+		}
+
+
+def search_for_mod_by_path(file_path):
+	# for module in list(sys.modules.values()):
+	for mod_name,module in list(sys.modules.items()):
+		mod_path = getattr(module, "__file__", None) 
+		if file_path == mod_path:
+			return module
+		# if not module:
+			# p("iojdwoqjdqoidjqwoidj")
+		# if not name:
+			# p(mod_name,module,type(module))
+		# p("~",name)
+
+
+
+
+def path_match_rld_mod(file_path):
+	if file_path is None:
+		return file_path
+	return file_path in custom_rld_list or custom_rld_substr in file_path
+def maybe_custom_reload(reloader,file_path):
+
+	# if file_path in custom_rld_list or custom_rld_substr in file_path:
+	if path_match_rld_mod(file_path):
+
+		# p(dir(reloader))
+		st= reset_mtime(reloader,file_path)
+		mod = search_for_mod_by_path(file_path)
+
+		#TODO: this is the important part refactor out later
+		if mod:
+			# gmod.before_mod_rld(mod)
+			# reimp = importlib.reload(mod)
+			try:
+				pass
+				reimp = importlib.reload(mod)
+			except Exception as E:
+				p("EXC@@@@@@@@@@@@")
+				print(traceback.format_exc())
+
+		else:
+			reimp="~~"
+			p("module not found with path:",file_path)
+		# importlib.reload(None)
+		# module==type(sys.modules["rld_m1"])
+		# p(type(sys.modules["rld_m1"]),)
+
+		# p("maybe_custom_reload!!!",st,reimp)
+		return 1
+		
+
+	r'''
+	try:
+		cnt=0
+		while gmod.glob["on_before_app_reload"]:
+			gmod.glob["on_before_app_reload"].pop()()
+			print("BEFORE RELOAD,,",cnt,OKBLUE3,"###################################################################",ENDC)
+		pass
+	except Exception as E:
+		print("I WOULD PANIC BUT PANIC HAS NOT BEEN IMPLIMENTED",E)
+
+	pass
+	# '''
+
+
+
+def t_rld1(self,file_path,*args,**kwargs):
+	# p("extra_files",args[0].extra_files)
+
+	p("t_rld1",self,file_path,args,kwargs)
+	p("```````````````````````````````````````")
+	p()
+	# if (file_path == r"C:\ws\repos\flask_apps\flask_example\rld_m2.py"):
+		# p("~~~%%%%%%%%%%%%%%%%%%%%%%5")
+		# return
+
+
+	if maybe_custom_reload(self,file_path):
+		pass
+	else:
+		# gmod.before_wsgi_rld("will rld")
+		p("...................")
+		mscope["ReloaderLoop_trigger_reload"](self,file_path,*args,**kwargs)
+		p("...................>")
+	# p("exclude_patterns",args[0].exclude_patterns)
+
+
+	
+def t_rld2(*args,**kwargs):
+	p("t_rld2",args,kwargs)
+	mscope["WatchdogReloaderLoop_trigger_reload"](*args,**kwargs)
+
+_reloader.ReloaderLoop.trigger_reload = t_rld1
+_reloader.WatchdogReloaderLoop.trigger_reload = t_rld2
+
+
+def run_with_reloader2(
+	main_func: t.Callable[[], None],
+	extra_files: t.Iterable[str] | None = None,
+	exclude_patterns: t.Iterable[str] | None = None,
+	interval: int | float = 1,
+	reloader_type: str = "auto",
+) -> None:
+	"""Run the given function in an independent Python interpreter."""
+	import signal
+	import os
+	print("")
+	print("")
+	print("")
+	print("")
+	print("run_with_reloader2!")
+	print("RLDI",main_func,extra_files,exclude_patterns,interval,reloader_type)
+
+	signal.signal(signal.SIGTERM, lambda *args: sys.exit(0))
+	reloader = _reloader.reloader_loops[reloader_type](
+		extra_files=extra_files, exclude_patterns=exclude_patterns, interval=interval
+	)
+	mscope["reloader"]=reloader
+
+	try:
+		if os.environ.get("WERKZEUG_RUN_MAIN") == "true":
+			_reloader.ensure_echo_on()
+			t = threading.Thread(target=main_func, args=())
+			t.daemon = True
+
+			# Enter the reloader to set up initial state, then start
+			# the app thread and reloader update loop.
+			with reloader:
+				t.start()
+				reloader.run()
+		else:
+			# gmod.before_wsgi_rld("restart_with_reloader")
+			sys.exit(reloader.restart_with_reloader())
+	except KeyboardInterrupt:
+		# gmod.before_wsgi_rld("um actually exiting")
+		pass
+
+
+_reloader.run_with_reloader = run_with_reloader2

flask_server/rld_m0.py

@@ -0,0 +1,19 @@
+
+from simple_websocket import Server
+from simple_websocket.ws import Base
+
+
+p=print
+
+
+
+def _srv_rec(self,msg,*a,**kw):
+	# print("QQQQQQQQQQQQQQQQQQQQQQQQQKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK")
+	# p("_srv_rec","FROM_GROUPFROM_GROUPFROM_GROUPFROM_GROUP",self.connected,a,kw)
+	# p("_srv_rec","FROM_GROUPFROM_GROUPFROM_GROUPFROM_GROUP",self.connected,msg)
+	# self.send("FROM_GROUP")
+	self.send(msg[1])
+
+
+
+Server._srv_rec =_srv_rec

flask_server/rld_m1.py

@@ -0,0 +1,229 @@
+
+
+import gmod
+
+import inspect
+import flask.sansio.scaffold
+
+print(",,,")
+
+p=print
+
+sock = gmod.glob["sock"] 
+app = gmod.glob["app"] 
+
+# if not "" in gmod.glob
+
+OKBLUE = '\033[94m'
+ENDC = '\033[0m'
+
+gx = gmod.gx
+
+def um_info(o):
+	p()
+	# return
+	for en in dir(o):
+		# if "url" not in en:continue
+		attr = getattr(o,en,"NO ATTR")
+		p(OKBLUE,en,ENDC)
+		p(attr)
+	p()
+	# for r in app.url_map.iter_rules:
+		# p(:)
+	# for en in o:
+		# p(en)
+
+def what(*a,**kw):
+	p("WHAT",a,kw)
+
+def what2(*a,**kw):
+	p("WHAT2",a,kw)
+
+def route_or_replace_v0(*a,**kw):
+	o ={
+	"rld":0
+	}
+	p("QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ.")
+	def dec(fn):
+		p("QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ")
+		p(fn.__name__,fn)
+		p(inspect.getsource(fn))
+		# if app._got_first_request or fn.__name__ in app.view_functions:
+		if fn.__name__ in app.view_functions:
+			o["rld"]=1
+			# if started and not app.view_functions no real change??
+			p("...fr 0",fn,a,kw)
+
+			# app.view_functions[fn.__name__] = fn
+			app.view_functions[fn.__name__] = flask.sansio.scaffold.setupmethod(what2)
+			return fn
+		else:
+			return sock.route(*a,**kw)(fn)
+			pass
+	if o["rld"]:
+		return what
+	else:
+		return dec
+
+# def 
+
+
+
+
+
+def route_or_replace(path,*a,**kw):
+	o = {"rld":0}
+	def dec(fn):
+		if fn.__name__ in app.view_functions:
+			o["rld"]=1
+			p("RLD!!!")
+		else:
+			return sock.route(path,*a,**kw)(fn)
+	p("route_or_replace",o,path,a,kw)
+	if o["rld"]:
+		return what
+	else:
+		return dec
+
+
+
+
+def sinfo(o):
+	for en in dir(o):
+		attr = getattr(o,en,"NO ATTR")
+		p(OKBLUE,en,ENDC)
+		# p("\033[48;5;57m",en,ENDC)
+		# p("\033[36m",en,ENDC)
+		p(attr)		
+		# p(en)
+
+def oinfo(o,n="!"):
+	for en in dir(o):
+		attr = getattr(o,en,"NO ATTR")
+		p('\033[33m',en,ENDC,sep='')
+		p(attr)		
+		# p(en)
+# @sock.route('/echo_c1')
+
+
+def gmod_once():
+	if not app._got_first_request:
+		gmod.glob["all_ws_conn"] = set()
+		gmod.glob["groups"] = {}
+
+gmod_once()
+
+p()
+
+
+p("app._got_first_request",app._got_first_request)
+
+
+# um_info(app)
+
+# p(app.view_functions)
+
+
+
+def echo_coll(sock,*a,**kw):
+	p("echo_coll m7",sock,sock.connected,a,kw)
+	gmod.gx.ws_conn(sock,*a,**kw)
+	# sinfo(sock.sock)
+	# gmod.glob["all_ws_conn"].add(sock)
+	# gx.add_to_channel(sock,"N1")
+	# gx.add_to_channel(sock,"N4")
+	# gmod.glob["all_ws_conn"].add(sock)
+	# p(type(sock))
+
+	# p(inspect.getsource(sock.accept))
+	# p(inspect.getsource(sock.sock.send))
+	# p(inspect.getsource(sock.sock.__class__))
+	# p(inspect.getfile(sock.sock.__class__))
+	# p(sock.sock.send)
+	# oinfo(sock.sock)
+	while True:
+		data = sock.receive()
+		gx.handle_msg(sock,data,z=[a,kw])
+		# p(inspect.getfile(sock.__class__),data)
+		# p(":",inspect.getfile(sock.receive),data)
+		if data == "throw_err":
+			p("throwing_err")
+			raise data
+		elif data == "s2":
+			p("::::s2...")
+			# cls_abc.abc123()
+		sock.send(data)
+	p("ENDIIII")
+
+
+app.config['SOCK_SERVER_OPTIONS'] = {'ping_interval': 10}
+# r'''
+@route_or_replace('/echo_c1')
+def _echo_coll(*a,**kw):
+	# p("_echo_coll")
+	return echo_coll(*a,**kw)
+	# p("echo_coll m1")
+	# while True:
+	# 	data = sock.receive()
+	# 	sock.send(data)
+
+# '''
+for en,fn in app.view_functions.items():
+	p(en,"\n\t.",fn)
+
+
+
+r'''
+
+# def echo234(*a,**kw):
+# @route_or_replace('/<path:path>')
+
+
+
+@sock.route('/<path:path>')
+def echo234(sock,*a,**kw):
+	p("E2.2sa2............................",a,kw)
+	# return
+	while True:
+		data = sock.receive()
+		sock.send(data)
+		for en in dir(sock):
+			p(en)
+
+gmod.glob["echo234"]  = app.view_functions["echo234"]
+# '''
+
+
+
+
+r'''
+def echo2345(*a,**kw):
+	try:
+		p("zzz",__class__)
+	except Exception as E:
+		p(":",E)
+	p("E2.2sa2...........................?",sock,a,kw)
+	# return
+	while True:
+		data = sock.receive()
+		sock.send(data)
+		for en in dir(sock):
+			p(en)
+
+
+# p(gmod.glob["echo234"])
+p("***********************************************************")
+p(inspect.getsource(app.view_functions["echo234"]))
+p("***********************************************************..............")
+
+# app.view_functions["echo234"] = gmod.glob["echo234"]
+app.view_functions["echo234"] = echo2345
+# '''
+
+# p(inspect.getsource(echo234))
+# p(echo234)
+
+
+# um_info(app.url_map)
+# p(app.url_map)
+# p(app.url_map.iter_rules)

flask_server/rld_m2.py

@@ -0,0 +1,158 @@
+
+
+import gmod
+
+import inspect
+import flask.sansio.scaffold
+
+import threading
+import base64
+
+print(",,,")
+
+p=print
+
+sock = gmod.glob["sock"] 
+app = gmod.glob["app"] 
+
+
+def um_info(o):
+	p()
+	# return
+	for en in dir(o):
+		# if "url" not in en:continue
+		p(en)
+	p()
+	# for en in o:
+		# p(en)
+
+r'''
+@sock.route('/<path:path>')
+def echo2345(sock,*a,**kw):
+	p("E2..",a,kw)
+	while True:
+		data = sock.receive()
+		sock.send(data)
+		for en in dir(sock):
+			p(en)
+# '''
+import json
+def group_jsend(group,o,sender):
+	# if type(sender=="")
+		# sock.slf["channel_id"]
+	slf = getattr(sender,"slf",None)
+	_from = "IDK"
+	if slf:
+		_from= slf["channel_name"]
+	# _from = "IDK"
+	# slf["group"]
+	o["from"]=_from
+	p("SLF:",slf,sender)
+	msg = json.dumps(o)
+	send_to_channel(group,msg,sender)
+
+def send_to_channel(name,message,sender):
+	group = gmod.glob["groups"].get(name,set())
+
+	for en in group:
+		pass
+		p("....",en._srv_rec)
+		# en._group_send(name,message)
+		# en._srv_rec(name,message)
+		en._srv_rec([name,message,sender])
+		# en.(name,message)
+
+
+
+
+
+def add_to_channel(sock,name):
+	pass
+	gmod.glob["groups"].setdefault(name,set())
+	group = gmod.glob["groups"].get(name)
+	old_group_size = len(group)
+	group.add(sock)
+	return old_group_size
+
+	# gmod.glob["groups"].setdefault
+
+def dicard_on_close(sock):
+	gmod.glob["all_ws_conn"].discard(sock)
+	for name,group in gmod.glob["groups"].items():
+		group.discard(sock)
+def discard_closed():
+	cnt = 0
+	doomed = []
+	p("~~~~~~~~~~~~~~~~~~~~~~~~~~")
+	p(gmod.glob["all_ws_conn"])
+	for en in gmod.glob["all_ws_conn"]:
+		cnt +=1
+		if not en.connected:
+			# doomed.append(en)
+			doomed += (en,)
+		p(en,cnt,en.connected)
+		# gmod.glob["all_ws_conn"].discard(en)
+	gmod.glob["all_ws_conn"].difference_update(doomed)
+	doomed_groups = []
+	groups = gmod.glob["groups"]
+	for name,group in groups.items():
+		group.difference_update(doomed)
+		if not len(group):
+			doomed_groups.append(name)
+	for name in doomed_groups:
+		print("EMPTY:",name)
+		del groups[name]
+
+	p(doomed)
+def runinfo():
+	# gmod.glob["groups"]={}
+	
+	# p("..",gmod.glob["groups"])
+
+	# return
+	# p("Q",gmod.glob["groups"])
+	for name,group in gmod.glob["groups"].items():
+		p(name,":::",len(group))
+	if app._got_first_request:
+		p(len(gmod.glob["all_ws_conn"]))
+		for en in gmod.glob["all_ws_conn"]:
+			p(en,en.connected)
+			p(hash(1),hash(2),hash(en))
+		# for e2 in dir(en):
+			# p(e2)
+		discard_closed()
+
+# empty str if no =
+# overwrites for multiple vals
+def parse_qs(s):
+	o={}
+	for param in s.split("&"):
+		kv = (*param.split("=",1),"")
+		o[kv[0]]=kv[1]
+	return o
+
+try:
+	runinfo()
+except Exception as E:
+	p("ERR:",E)
+
+class cls_abc:
+	def abc123(*a,**kw):
+		p("abc123",a,kw)
+
+gmod.gx.group_jsend = group_jsend
+gmod.gx.send_to_channel = send_to_channel
+gmod.gx.add_to_channel = add_to_channel
+gmod.gx.dicard_on_close = dicard_on_close
+gmod.gx.discard_closed = discard_closed
+gmod.gx.parse_qs = parse_qs
+
+
+
+# class flask_channels
+
+
+cnt=0
+for thread in threading.enumerate(): 
+	print(cnt,thread.name)
+	cnt+=1

flask_server/rld_m3.py

@@ -0,0 +1,232 @@
+import gmod
+p=print
+
+
+# should this really be a class
+# class Eobj:pass
+
+
+gx = gmod.gx
+import json
+
+from simple_websocket import Server
+from simple_websocket.ws import Base
+
+import base64
+
+OKBLUE = '\033[94m'
+ENDC = '\033[0m'
+
+import inspect
+
+def ws_disconn(sock,*a,**kw):
+	gx.dicard_on_close(sock)
+	ending = json.dumps({
+			"type":"jm_tmp_dev_sto_rec","from":"self.channel_name",
+			"CLIENT_KEY":"ws_sto",
+			"sto_event_type": "user_disconnected",
+			"group_name":sock.slf["channel_name"],
+			"from????":sock.slf["channel_name"],
+			# "group_name":"self.group_name",
+			"channel_name":sock.slf["channel_name"],
+
+			})
+
+	p("ending:::::::::::::::::::::::::")
+	p(ending)
+
+
+	# gx.send_to_channel("all_groups",ending,"SENED")
+	gx.send_to_channel(sock.slf["group_name"],ending,"SENED")
+
+		# await self.channel_layer.group_send(self.group_name,)
+
+	# sock.send(json.dumps({"type":"jm_tmp_dev_sto_rec","from":"self.channel_name",
+	# gx.send_to_channel("all_groups",json.dumps({"type":"jm_tmp_dev_sto_rec","from":"self.channel_name",
+	# 		"CLIENT_KEY":"ws_sto",
+	# 		"sto_event_type": "user_disconnected",
+	# 		"group_name":"self.group_name",
+	# 		"channel_name":"self.channel_name",
+
+	# 		}),"sender")
+
+	# p("DISCONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN",a,kw)
+	
+
+	pass
+
+
+
+
+def ws_conn(sock,*a,**kw):
+
+	# return
+
+	sock.slf = {}
+	sock.slf["channel_id"] = hash(sock)
+	sock.slf["channel_name"] = str(sock.slf["channel_id"])
+	sock.slf["group_name"] =  gx.parse_qs(sock.environ["QUERY_STRING"]).get("room","NO_ROOM")
+
+	gmod.glob["all_ws_conn"].add(sock)
+	
+	# gx.parse_qs
+
+	gx.add_to_channel(sock,"all_groups")
+	old_group_size = gx.add_to_channel(sock,sock.slf["group_name"])
+
+	p(OKBLUE,"ws_conn",a,kw,ENDC)
+	# return
+	sock_info(sock)
+	# my_int = sock.slf["channel_id"]
+
+
+	# p(struct.pack("<i",my_int))
+	# p(base64.b64encode(bytes(str(sock.slf["channel_id"]),"ascii")))
+	# p(sock.slf["channel_id"].to_bytes(8,"big"))
+	# p(base64.b64encode(bytes(sock.slf["channel_id"])))
+	# p(base64.b64encode((sock.slf["channel_id"]).to_bytes(1)))
+	p(sock.slf)
+	p()
+	p()
+
+
+
+	sock.send(json.dumps({
+		"CLIENT_KEY":"ws_sto",
+		"sto_event_type": "connection_info",
+		"channel_name":sock.slf["channel_name"],
+		"group_name":"group_name",
+		"z":"z",
+	}))
+
+
+	# r'''
+	sock.send(json.dumps(
+		{
+		"CLIENT_KEY": "ws_sto",
+		"group_count": old_group_size+1,
+		"sto_event_type": "group_count",
+		# "ws_conn":"???",
+
+
+		}))
+	# '''
+	# r'''
+
+	# '''
+# _check_sendfile_params
+# OKBLUE = '\033[94m'
+# ENDC = '\033[0m'
+c2 =  '\033[34m'
+c1 =  '\033[32m'
+def oinfo(o):
+	p(o)
+
+	for en in dir(o):
+		if en[:2]=="__":continue
+		attr=getattr(o,en,"NO ATTR")
+		p((en + "\t").expandtabs(21),c1,type(attr),"'\033[0m'")
+		# p(en)
+	p()
+def sock_info(sock):
+	p('\033[31m',"sock_info",ENDC)
+	p("[[")
+	oinfo(sock)
+	oinfo(sock.sock)
+	p("]]")
+	p(sock.environ)
+	for k,v in sock.environ.items():
+		p(k)
+		# p(c2,k,ENDC)
+		p(c2,v,ENDC)
+		# p(v)
+	p(sock.environ["QUERY_STRING"])
+	p(gx.parse_qs(sock.environ["QUERY_STRING"]).get("room","NO_ROOM"))
+	p(type(sock),"....")
+
+	for en in dir(sock):
+
+		# p(en)
+		# p("\033[36m",type(attr),ENDC,sep="")
+		attr=getattr(sock,en,"NO ATTR")
+		sock.sock.__class__
+
+		# p()
+
+	# p("WS.",inspect.getfile(sock.ws.__class__))
+	# p("SOCK.",inspect.getfile(sock.sock.__class__))
+	# p("SOCK.",inspect.getfile(sock.sock.send))
+
+def handle_msg(sock,txt_msg,*a,**kw):
+	# [a,kw]
+	# p(":::::",sock.environ)
+	# p("handle_msg!!!!!!!!!!!!!!!!!!",sock,txt_msg)
+	# sock_info(sock)
+	# gx.send_to_channel("all_groups",txt_msg,"sender")
+	try:
+		data = json.loads(txt_msg)
+		# gx.send_to_channel("all_groups",txt_msg,"sender")
+		# gx.group_jsend("",data,sock)
+
+
+		gx.group_jsend(sock.slf["group_name"],data,sock)
+		# gx.send_to_channel(sock.slf["group_name"],txt_msg,"sender")
+		
+
+
+		# p("J",type(data),data)
+	except Exception as Err:
+		p("handle_msg ERR:",Err)
+
+
+
+
+
+# def _custom_close(*a,**kw):
+def _custom_close(self,reason=None, message=None):
+	p("_custom_close",reason,message)
+	if True:
+		gx.ws_disconn(self,reason=reason, message=message)
+		Base.close(self,reason=reason, message=message)
+	# try:
+	# except Exception as E:
+		# p("_custom_close EXCEPTION!",E)
+
+	# p(Base.close)
+	# p(super().close(*a,**kw))
+# Base.close("self",reason="reason?", message="..message")
+Server.close =_custom_close
+
+
+
+
+def msgtest():
+	p("msgtest")
+	p(len(gmod.glob["all_ws_conn"]))
+	for en in gmod.glob["all_ws_conn"]:
+		p(en)
+		# en.close()
+		p(en.sock)
+		for en2 in dir(en.sock):pass
+			# p(en2)
+			# en.send("::CLOSE::")
+		en.send("::CLOSE::")
+
+		# p(inspect.getsource(en.sock.close))
+		# p(inspect.getfile(en.sock.close))
+
+		# en.sock.close()
+		# en.connected =0
+
+
+
+msgtest()
+
+gmod.gx.ws_disconn = ws_disconn
+gmod.gx.ws_conn = ws_conn
+gmod.gx.handle_msg = handle_msg
+
+
+# _group_msg("ZZZ",1,2,3,4,5,6)
+
+# msg="q"

js_client/index.html

@@ -0,0 +1 @@
+jsyncdb client demo will go here