Search is not available for this dataset
repo_name
string | branch_name
string | path
string | content
string | context
string | import_relationships
dict |
|---|---|---|---|---|---|
0-0Yang/canteen
|
refs/heads/master
|
/app.py
|
#!/usr/bin/env python
#coding=utf-8
import web
import sys, os
from config.urls import urls
default_encoding = 'utf-8'
if sys.getdefaultencoding() != default_encoding:
reload(sys)
sys.setdefaultencoding(default_encoding)
app = web.application(urls, globals())
if __name__ == "__main__":
if 'SERVER_SOFTWARE' in os.environ:
import sae
sae.create_wsgi_app(app.wsgifunc())
else:
app.run()
|
#!/usr/bin/env python
#coding=utf-8
prefix = 'models.'
urls = (
r"/", prefix + "home.index",
r"/(.*)/", prefix + "home.redirect",
r"/index", prefix + "home.index",
r"/about", prefix + "home.about",
r"/contact", prefix + "home.contact",
r"/help", prefix + "home.help",
r"/canteen", prefix + "home.canteen",
r"/feedback", prefix + "home.feedback",
r"/order", prefix + "order.index",
r"/order/signup", prefix + "order.signup",
r"/order/signin", prefix + "order.signin",
r"/order/add", prefix + "order.add_order",
r"/order/info", prefix + "order.get_info",
r"/we/webchat/port", prefix + "webchat.verify.WeixinInterface",
r"/test", prefix + "home.test",
r"/(.*)", prefix + "home.err404",
)
|
{
"imports": [
"/config/urls.py"
]
}
|
0-1CxH/Graphware-Based-Network-Monitoring
|
refs/heads/master
|
/GraphGenerator.py
|
import networkx
import json
from networkx.readwrite import json_graph
import matplotlib.pyplot as plt
from Common import quintupleConnection
# EFP is UNdirected, UNIgraph, wEFP is weighted version of EFP
class wEFPConverterIncr(object): # Increamenting version of wEFP converter
def __init__(self, TCPSYNtrack=True):
self.NxObj = networkx.Graph()
self.TCPSYNtrack = TCPSYNtrack
self.globalData = {'nodeCount':0, 'edgeCount':0, 'starttime':0, 'endtime':0}
def update(self, pac): # pac is dpktOctet
# UPDATE NODE
self._host1 = str(pac.sip)
self._host2 = str(pac.dip)
if self._host1 not in self.NxObj.nodes:
if self.TCPSYNtrack:
self.NxObj.add_node(self._host1, data={'SYNRequest':0, 'SYNAccept':0, 'flow':0})
else:
self.NxObj.add_node(self._host1, data={'flow':0})
self.globalData['nodeCount'] += 1
if self._host2 not in self.NxObj.nodes:
if self.TCPSYNtrack:
self.NxObj.add_node(self._host2, data={'SYNRequest':0, 'SYNAccept':0, 'flow':0})
else:
self.NxObj.add_node(self._host2, data={'flow':0})
self.globalData['nodeCount'] += 1
self.NxObj.nodes[str(pac.sip)]['data']['flow'] += pac.length
self.NxObj.nodes[str(pac.dip)]['data']['flow'] += pac.length
# UPDATE EDGE
if ((self._host1,self._host2) not in self.NxObj.edges) or ((self._host2,self._host1) not in self.NxObj.edges):
self.NxObj.add_edge(self._host1,self._host2, data={
'starttime':pac.timestamp,
'endtime':pac.timestamp,
'duration':0,
'count': 1,
'flow': pac.length})
self.globalData['edgeCount'] += 1
else:
self.NxObj.edges[self._host1,self._host2]['data']['endtime'] = pac.timestamp
self.NxObj.edges[self._host1, self._host2]['data']['duration'] = pac.timestamp - self.NxObj.edges[self._host1,self._host2]['data']['starttime']
self.NxObj.edges[self._host1, self._host2]['data']['count'] += 1
self.NxObj.edges[self._host1, self._host2]['data']['flow'] += pac.length
# UPDATE GLOBAL
if pac.timestamp > self.globalData['endtime']:
self.globalData['endtime'] = pac.timestamp
# SYN Track
if self.TCPSYNtrack == True:
if pac.proto == 6:
if pac.xInfo[2]!=0 and pac.xInfo[0]==0 : #SYN
self.NxObj.nodes[str(pac.sip)]['data']['SYNRequest'] += 1
self.NxObj.nodes[str(pac.dip)]['data']['SYNAccept'] += 1
#debug
#print(self.globalData)
def exportNetworkxObj(self):
return self.NxObj
def exportJSON(self, outputfilename=None):
jsondata = json_graph.node_link_data(self.NxObj)
if outputfilename:
with open(outputfilename,"w") as f:
f.write(json.dumps(jsondata))
return jsondata
# TODO: conntrackConverter
class conntrackConverter(object):
def __init__(self):
self.NxObj = networkx.MultiDiGraph()
def update(self, pac):
pass
|
import ipaddress
class ipv4address(object):
def __init__(self,s): # s = string of IP address
try:
self.addr = ipaddress.IPv4Address(s)
except:
self.addr = None
def isValid(self):
if self.addr == None:
return False
else :
return True
def getStringIP(self):
if self.isValid():
return str(self.addr)
else:
return None
def __str__(self):
return self.getStringIP()
def getDecimalIP(self):
if self.isValid():
return int(self.addr)
else:
return None
class ipv4range(object):
def __init__(self,ls): # ls = list of STRING containing both ipaddress and ipnetwork
self.rangeList = { 'host':[], 'network':[]} # host: contains strings, network: contains network objects
self._cache = [] # cache the usually used ip with high possibility of repeating, format=STRING
for s in ls:
saddr = ipv4address(s)
if saddr.isValid():
self.rangeList['host'].append(saddr.getStringIP())
try:
snetwk = ipaddress.IPv4Network(s)
self.rangeList['network'].append(snetwk)
except:
continue
def has(self,s): # s = string of IP address
try:
s = ipv4address(s)
except:
return False
if s.getStringIP() in self._cache: # mess a lot with the type converting
return True
else:
if s.getStringIP() in self.rangeList['host']:
self._cache.append(s.getStringIP())
return True
for ns in self.rangeList['network']:
for nsh in ns.hosts(): # ATTENTION: objects with different location are not equal unless __eq__ defined
if s.getStringIP() == str(nsh):
self._cache.append(s.getStringIP())
return True
return False
class port(object):
def __init__(self,portnum): # portnum is integer or string
if not isinstance(portnum, int):
try:
portnum = int(portnum)
except:
raise TypeError("Invalid Type of Port")
if portnum<0 or portnum>65535:
raise ValueError("Invalid Value of Port")
else:
self.value = portnum
def __int__(self):
return self.value
class portrange(object):
def __init__(self, lp): # list of ports/ranges in STRING format (comma-separated)
self.rangeList = {'single':set(), 'range':set()}
self._cache = []
self._omittedBcException = [] # list of omitted parts due to exception
for p in lp:
try:
pp = port(p)
self.rangeList['single'].add(pp.value)
except TypeError:
try:
plb, pub = p.split('-')
except ValueError:
self._omittedBcException.append(p)
continue
try:
pplb,ppub = port(plb), port(pub)
self.rangeList['range'].add(range(min(pplb.value,ppub.value),1+max(pplb.value,ppub.value)))
except:
self._omittedBcException.append(p)
continue
except ValueError:
self._omittedBcException.append(p)
continue
def has(self,p):
try:
p = port(p)
except:
return False
if p.value in self._cache:
return True
if p.value in self.rangeList['single']:
self._cache.append(p.value)
return True
for pri in self.rangeList['range']:
if p.value in pri:
self._cache.append(p.value)
return True
return False
class numberRangeFilter(object):
def __init__(self,ls): # list of strings
self.rangeList = []
self._allowall = False
if len(ls) == 0:
self._allowall = True
for s in ls:
if '-' not in s:
continue
else:
try:
self.slb, self.sub = s.split('-')
self.slb, self.sub = int(self.slb), int(self.sub)
self.rangeList.append(range( min(self.slb,self.sub) , max(self.slb,self.sub)))
except:
continue
def has(self,number):
if self._allowall:
return True
for r in self.rangeList:
if number in r:
return True
return False
class dpktOctet(object): # Octet, not quintuple.
# (TimeStamp, IPSrc, IPDst, PortSrc, PortDst, Protocol, Length) + (xInfo)
def __init__(self, timestamp, ip_datagram):
self.timestamp = timestamp
self.sip = ipv4address(ip_datagram.src) # sip and dip is saved in OBJECT format
self.dip = ipv4address(ip_datagram.dst)
self.proto = ip_datagram.p
self._protoName = ip_datagram.get_proto(ip_datagram.p).__name__
self.length = ip_datagram.len
self.sport = 0
self.dport = 0
if hasattr(ip_datagram.data, 'sport'):
self.sport = ip_datagram.data.sport
if hasattr(ip_datagram.data, 'dport'):
self.dport = ip_datagram.data.dport
if self.proto == 1: # (Type,Code)
self.xInfo = (ip_datagram.data.type, ip_datagram.data.code)
elif self.proto == 6: # (ACK,RST,SYN,FIN)
self.xInfo = ((ip_datagram.data.flags >> 4) & 1, (ip_datagram.data.flags >> 2) & 1,
(ip_datagram.data.flags >> 1) & 1, (ip_datagram.data.flags >> 0) & 1)
else:
self.xInfo = None
class protocolFilter(object):
def __init__(self, lprtls):
if len(lprtls) == 0:
self._allowAll = True
else:
self._allowAll = False
self.lprtls = lprtls
def isallowed(self, protoName):
return self._allowAll or (protoName in self.lprtls)
class dpktFilter(object):
def __init__(self, filterconfig):
lips, lps, lts, lls, lprtls = filterconfig
# ARGS: list of ip string, list of port string, list of time string, list of length string, list of protocol string
# E.G. ["192.168.80.0/24"],["1024-8000"],["0-1"],["0-1024"],["TCP","UDP"]
self.allIP = False
self.allPort = False
if len(lips) == 0 :
self.allIP = True
if len(lps) == 0:
self.allPort = True
self.ipFilter = ipv4range(lips)
self.portFilter = portrange(lps)
self.timeFilter = numberRangeFilter(lts)
self.lengthFilter = numberRangeFilter(lls)
self.protoFilter = protocolFilter(lprtls)
def isSelected(self, dpktoct): # dpktOctet # test sequence: proto (O(1)) > number range (O(n)) > port (O(mn)) > IP (O(n^2))
if not self.protoFilter.isallowed(dpktoct._protoName):
return False
if not self.timeFilter.has(dpktoct.timestamp):
return False
if not self.lengthFilter.has(dpktoct.length):
return False
if not self.allPort:
if not self.portFilter.has(dpktoct.sport):
return False
if not self.portFilter.has(dpktoct.dport):
return False
if not self.allIP:
if not self.ipFilter.has(dpktoct.sip.getStringIP()):
return False
if not self.ipFilter.has(dpktoct.dip.getStringIP()):
return False
return True
class quintupleConnection(object):
def __init__(self, pac):
self.ip = set(str(pac.sip), str(pac.dip))
self.port = set(int(pac.sport), int(pac.dport))
self.prtl = pac.proto
self.status = None
def __eq__(self, other):
if self.ip == other.ip and self.port == other.port and self.prtl == other.prtl:
return True
def test():
s1 = ipv4range(["192.168.0.1","192.168.0.0/24","200.0.0.0/24"])
s2 = portrange(["80", "8090-8082"])
print(s1.rangeList)
print(s1.has("192.168.0.100"))
print(s1._cache)
print(s1.has("192.168.0.100"))
print(s2.rangeList)
print(s2.has(8085))
print(s2.has(8090))
print(s2._cache)
|
{
"imports": [
"/Common.py"
]
}
|
0-1CxH/Graphware-Based-Network-Monitoring
|
refs/heads/master
|
/TrafficSelector.py
|
import dpkt
from Common import dpktOctet, dpktFilter
from GraphGenerator import wEFPConverterIncr
class dpktTrafficSelector(object):
def __init__(self, trafficfilename, filterConfig=([],[],[],[],[]), converterName="wEFP"):
self.f = open(trafficfilename, 'rb')
self.pcapIter = dpkt.pcap.Reader(self.f)
self._totalCount = 0
self._ipCount = 0
self._filteredCount = 0
self.initTimestamp = -1
if converterName == "EFP" or "wEFP": # Now EFP and wEFP is combined, implemented as wEFPConverterIncr
self.graphConverter = wEFPConverterIncr()
for timestamp, buf in self.pcapIter:
if self.initTimestamp == -1:
self.initTimestamp = timestamp
self._totalCount += 1
eth = dpkt.ethernet.Ethernet(buf) # Unpack the Ethernet frame (mac src/dst, ethertype)
# Make sure the Ethernet frame contains an IP packet
if not isinstance(eth.data, dpkt.ip.IP):
continue
ip = eth.data # Now unpack the data within the Ethernet frame (the IP packet)
# Pulling out src, dst, length, fragment info, TTL, and Protocol
self.c_packet = dpktOctet(timestamp-self.initTimestamp, ip)
self._ipCount += 1
self.filterObj = dpktFilter(filterConfig)
if self.filterObj.isSelected(self.c_packet):
#print(self.c_packet.timestamp,self.c_packet.proto,self.c_packet.length)
self.graphConverter.update(self.c_packet) # No longer use Iteration, use Increment instead. Less memory space
self._filteredCount += 1
self.f.close()
#self.graphConverter.drawdemo()
#self.graphConverter.exportJSON("1.json")
def getCount(self):
return {"Total":self._totalCount, "Valid IP":self._ipCount, "Selected":self._filteredCount}
# TODO: Implement pysharkTrafficSelector
print("Program Started")
a = dpktTrafficSelector(trafficfilename="MAWI100K.pcap", filterConfig=([],[],[],[],["TCP","UDP"]))
print(a.getCount())
print(a.graphConverter.globalData)
def testXmeans():
from Algorithm import XmeansAlgorithm
b = XmeansAlgorithm(a.graphConverter.exportNetworkxObj())
b.process()
print(b.clusters)
print(len(b.clusters))
b.getVisualization()
# delete dpktTrafficSelector from here only keep nxobj
anxobj = a.graphConverter.exportNetworkxObj()
del a
def testmec(nxobj=anxobj):
from Application import modifiedEdgeCentricAnalyzer
c = modifiedEdgeCentricAnalyzer(nxobj)
c.process()
print(c.exportAnomalyScore("anoscr.json"))
_ ,cr = c.getClusteringResults()
print(len(cr), " Clusters, Center at:",cr)
print("GlobalStat: ", c.getGlobalStat())
c.exportGEXF("mcetest.gexf")
testmec()
|
import ipaddress
class ipv4address(object):
def __init__(self,s): # s = string of IP address
try:
self.addr = ipaddress.IPv4Address(s)
except:
self.addr = None
def isValid(self):
if self.addr == None:
return False
else :
return True
def getStringIP(self):
if self.isValid():
return str(self.addr)
else:
return None
def __str__(self):
return self.getStringIP()
def getDecimalIP(self):
if self.isValid():
return int(self.addr)
else:
return None
class ipv4range(object):
def __init__(self,ls): # ls = list of STRING containing both ipaddress and ipnetwork
self.rangeList = { 'host':[], 'network':[]} # host: contains strings, network: contains network objects
self._cache = [] # cache the usually used ip with high possibility of repeating, format=STRING
for s in ls:
saddr = ipv4address(s)
if saddr.isValid():
self.rangeList['host'].append(saddr.getStringIP())
try:
snetwk = ipaddress.IPv4Network(s)
self.rangeList['network'].append(snetwk)
except:
continue
def has(self,s): # s = string of IP address
try:
s = ipv4address(s)
except:
return False
if s.getStringIP() in self._cache: # mess a lot with the type converting
return True
else:
if s.getStringIP() in self.rangeList['host']:
self._cache.append(s.getStringIP())
return True
for ns in self.rangeList['network']:
for nsh in ns.hosts(): # ATTENTION: objects with different location are not equal unless __eq__ defined
if s.getStringIP() == str(nsh):
self._cache.append(s.getStringIP())
return True
return False
class port(object):
def __init__(self,portnum): # portnum is integer or string
if not isinstance(portnum, int):
try:
portnum = int(portnum)
except:
raise TypeError("Invalid Type of Port")
if portnum<0 or portnum>65535:
raise ValueError("Invalid Value of Port")
else:
self.value = portnum
def __int__(self):
return self.value
class portrange(object):
def __init__(self, lp): # list of ports/ranges in STRING format (comma-separated)
self.rangeList = {'single':set(), 'range':set()}
self._cache = []
self._omittedBcException = [] # list of omitted parts due to exception
for p in lp:
try:
pp = port(p)
self.rangeList['single'].add(pp.value)
except TypeError:
try:
plb, pub = p.split('-')
except ValueError:
self._omittedBcException.append(p)
continue
try:
pplb,ppub = port(plb), port(pub)
self.rangeList['range'].add(range(min(pplb.value,ppub.value),1+max(pplb.value,ppub.value)))
except:
self._omittedBcException.append(p)
continue
except ValueError:
self._omittedBcException.append(p)
continue
def has(self,p):
try:
p = port(p)
except:
return False
if p.value in self._cache:
return True
if p.value in self.rangeList['single']:
self._cache.append(p.value)
return True
for pri in self.rangeList['range']:
if p.value in pri:
self._cache.append(p.value)
return True
return False
class numberRangeFilter(object):
def __init__(self,ls): # list of strings
self.rangeList = []
self._allowall = False
if len(ls) == 0:
self._allowall = True
for s in ls:
if '-' not in s:
continue
else:
try:
self.slb, self.sub = s.split('-')
self.slb, self.sub = int(self.slb), int(self.sub)
self.rangeList.append(range( min(self.slb,self.sub) , max(self.slb,self.sub)))
except:
continue
def has(self,number):
if self._allowall:
return True
for r in self.rangeList:
if number in r:
return True
return False
class dpktOctet(object): # Octet, not quintuple.
# (TimeStamp, IPSrc, IPDst, PortSrc, PortDst, Protocol, Length) + (xInfo)
def __init__(self, timestamp, ip_datagram):
self.timestamp = timestamp
self.sip = ipv4address(ip_datagram.src) # sip and dip is saved in OBJECT format
self.dip = ipv4address(ip_datagram.dst)
self.proto = ip_datagram.p
self._protoName = ip_datagram.get_proto(ip_datagram.p).__name__
self.length = ip_datagram.len
self.sport = 0
self.dport = 0
if hasattr(ip_datagram.data, 'sport'):
self.sport = ip_datagram.data.sport
if hasattr(ip_datagram.data, 'dport'):
self.dport = ip_datagram.data.dport
if self.proto == 1: # (Type,Code)
self.xInfo = (ip_datagram.data.type, ip_datagram.data.code)
elif self.proto == 6: # (ACK,RST,SYN,FIN)
self.xInfo = ((ip_datagram.data.flags >> 4) & 1, (ip_datagram.data.flags >> 2) & 1,
(ip_datagram.data.flags >> 1) & 1, (ip_datagram.data.flags >> 0) & 1)
else:
self.xInfo = None
class protocolFilter(object):
def __init__(self, lprtls):
if len(lprtls) == 0:
self._allowAll = True
else:
self._allowAll = False
self.lprtls = lprtls
def isallowed(self, protoName):
return self._allowAll or (protoName in self.lprtls)
class dpktFilter(object):
def __init__(self, filterconfig):
lips, lps, lts, lls, lprtls = filterconfig
# ARGS: list of ip string, list of port string, list of time string, list of length string, list of protocol string
# E.G. ["192.168.80.0/24"],["1024-8000"],["0-1"],["0-1024"],["TCP","UDP"]
self.allIP = False
self.allPort = False
if len(lips) == 0 :
self.allIP = True
if len(lps) == 0:
self.allPort = True
self.ipFilter = ipv4range(lips)
self.portFilter = portrange(lps)
self.timeFilter = numberRangeFilter(lts)
self.lengthFilter = numberRangeFilter(lls)
self.protoFilter = protocolFilter(lprtls)
def isSelected(self, dpktoct): # dpktOctet # test sequence: proto (O(1)) > number range (O(n)) > port (O(mn)) > IP (O(n^2))
if not self.protoFilter.isallowed(dpktoct._protoName):
return False
if not self.timeFilter.has(dpktoct.timestamp):
return False
if not self.lengthFilter.has(dpktoct.length):
return False
if not self.allPort:
if not self.portFilter.has(dpktoct.sport):
return False
if not self.portFilter.has(dpktoct.dport):
return False
if not self.allIP:
if not self.ipFilter.has(dpktoct.sip.getStringIP()):
return False
if not self.ipFilter.has(dpktoct.dip.getStringIP()):
return False
return True
class quintupleConnection(object):
def __init__(self, pac):
self.ip = set(str(pac.sip), str(pac.dip))
self.port = set(int(pac.sport), int(pac.dport))
self.prtl = pac.proto
self.status = None
def __eq__(self, other):
if self.ip == other.ip and self.port == other.port and self.prtl == other.prtl:
return True
def test():
s1 = ipv4range(["192.168.0.1","192.168.0.0/24","200.0.0.0/24"])
s2 = portrange(["80", "8090-8082"])
print(s1.rangeList)
print(s1.has("192.168.0.100"))
print(s1._cache)
print(s1.has("192.168.0.100"))
print(s2.rangeList)
print(s2.has(8085))
print(s2.has(8090))
print(s2._cache)
--- FILE SEPARATOR ---
import networkx
import json
from networkx.readwrite import json_graph
import matplotlib.pyplot as plt
from Common import quintupleConnection
# EFP is UNdirected, UNIgraph, wEFP is weighted version of EFP
class wEFPConverterIncr(object): # Increamenting version of wEFP converter
def __init__(self, TCPSYNtrack=True):
self.NxObj = networkx.Graph()
self.TCPSYNtrack = TCPSYNtrack
self.globalData = {'nodeCount':0, 'edgeCount':0, 'starttime':0, 'endtime':0}
def update(self, pac): # pac is dpktOctet
# UPDATE NODE
self._host1 = str(pac.sip)
self._host2 = str(pac.dip)
if self._host1 not in self.NxObj.nodes:
if self.TCPSYNtrack:
self.NxObj.add_node(self._host1, data={'SYNRequest':0, 'SYNAccept':0, 'flow':0})
else:
self.NxObj.add_node(self._host1, data={'flow':0})
self.globalData['nodeCount'] += 1
if self._host2 not in self.NxObj.nodes:
if self.TCPSYNtrack:
self.NxObj.add_node(self._host2, data={'SYNRequest':0, 'SYNAccept':0, 'flow':0})
else:
self.NxObj.add_node(self._host2, data={'flow':0})
self.globalData['nodeCount'] += 1
self.NxObj.nodes[str(pac.sip)]['data']['flow'] += pac.length
self.NxObj.nodes[str(pac.dip)]['data']['flow'] += pac.length
# UPDATE EDGE
if ((self._host1,self._host2) not in self.NxObj.edges) or ((self._host2,self._host1) not in self.NxObj.edges):
self.NxObj.add_edge(self._host1,self._host2, data={
'starttime':pac.timestamp,
'endtime':pac.timestamp,
'duration':0,
'count': 1,
'flow': pac.length})
self.globalData['edgeCount'] += 1
else:
self.NxObj.edges[self._host1,self._host2]['data']['endtime'] = pac.timestamp
self.NxObj.edges[self._host1, self._host2]['data']['duration'] = pac.timestamp - self.NxObj.edges[self._host1,self._host2]['data']['starttime']
self.NxObj.edges[self._host1, self._host2]['data']['count'] += 1
self.NxObj.edges[self._host1, self._host2]['data']['flow'] += pac.length
# UPDATE GLOBAL
if pac.timestamp > self.globalData['endtime']:
self.globalData['endtime'] = pac.timestamp
# SYN Track
if self.TCPSYNtrack == True:
if pac.proto == 6:
if pac.xInfo[2]!=0 and pac.xInfo[0]==0 : #SYN
self.NxObj.nodes[str(pac.sip)]['data']['SYNRequest'] += 1
self.NxObj.nodes[str(pac.dip)]['data']['SYNAccept'] += 1
#debug
#print(self.globalData)
def exportNetworkxObj(self):
return self.NxObj
def exportJSON(self, outputfilename=None):
jsondata = json_graph.node_link_data(self.NxObj)
if outputfilename:
with open(outputfilename,"w") as f:
f.write(json.dumps(jsondata))
return jsondata
# TODO: conntrackConverter
class conntrackConverter(object):
def __init__(self):
self.NxObj = networkx.MultiDiGraph()
def update(self, pac):
pass
--- FILE SEPARATOR ---
from pyclustering.cluster import cluster_visualizer
from pyclustering.cluster.xmeans import xmeans
from pyclustering.cluster.center_initializer import kmeans_plusplus_initializer
from sklearn.preprocessing import normalize
class XmeansAlgorithm(object):
def __init__(self, NxObj, amount_initial_centers=2, amount_max_centers=16):
self.dataset = dict(NxObj.nodes.data())
self.namelist = []
self.datalist = []
self.resultDict = {}
self.amount_initial_centers = amount_initial_centers
self.amount_max_centers = amount_max_centers
def importData(self):
for dp in self.dataset:
self.namelist.append(dp)
self.datalist.append([self.dataset[dp]['data']['SYNRequest'],
self.dataset[dp]['data']['SYNAccept'] ,
self.dataset[dp]['data']['flow']])
self.datalist = normalize(self.datalist) # Normalize Data
#del self.dataset
def xmeansRoutine(self):
self.initial_centers = kmeans_plusplus_initializer(self.datalist, self.amount_initial_centers).initialize()
self.xmeans_instance = xmeans(self.datalist, self.initial_centers, self.amount_max_centers)
self.xmeans_instance.process()
self.clusters = self.xmeans_instance.get_clusters()
self.centers = self.xmeans_instance.get_centers()
def exportData(self):
for clu, arr in enumerate(self.clusters):
for n in arr:
self.resultDict[self.namelist[n]] = clu
def process(self):
self.importData()
self.xmeansRoutine()
self.exportData()
def getResult(self):
return self.resultDict
def getCenters(self):
return self.centers
def getVisualization(self):
self.visualizer = cluster_visualizer()
self.visualizer.append_clusters(self.clusters, self.datalist)
self.visualizer.append_cluster(self.centers, None, marker='*', markersize=10)
self.visualizer.show()
--- FILE SEPARATOR ---
import numpy as np
import matplotlib.pyplot as plt
import json
from Algorithm import XmeansAlgorithm
import networkx
'''
modifiedEdgeCentricAnalyzer is based on the paper "EdgeCentric: Anomaly Detection in Edge-Attributed Networks"
by Neil Shah1 et al. I modified some parts to make it suitable for TDG.
Class object init by a Networkx object that generated by dpktTrafficSelector + wEFPConverterIncr
The methods are :
1) Get instance
mecObj = modifiedEdgeCentricAnalyzer(nxobj)
2) Process the whole MEC algorithm
mecObj.process()
3) Export results
mecObj.exportAnomalyScore("anormalyScoreOutput.json")) # Write anomaly score of hosts to json file
mecObj.getNetworkxObj # Get NxObj that contains all related information
mecObj.generateVisNxObj # Simplify the NxObj as VisNxObj including only essential info for visualization
mecObj.exportGEXF("mceVis.gexf") # Export VisNxObj to GEXF format file
4) Obtain intermediate results
cluster_points, cluster_centers = mecObj.getClusteringResults() # clustering results of X-means
mecObj.getGlobalStat() # Get the size/rate/freq stat of the whole graph (all clusters)
mecObj.getDistributionDict() # Get the stat of each nodes and each clusters
5) Private function
mecObj.process() Depends On mecObj.{calculatenodestat(), calculateclusterstat(), anomalyscore()}
Routine:
mecObj = modifiedEdgeCentricAnalyzer(nxobj)
mecObj.process()
mecObj.exportAnomalyScore("anormalyScoreOutput.json"))
mecObj.exportGEXF("mceVis.gexf")
'''
class modifiedEdgeCentricAnalyzer(object):
def __init__(self, NxObj):
self.NxObj = NxObj
self.globalStat = {}
self.distribution = {}
self.anormlyscoredict = {}
# structure: {
# [clusternumber]:{
# attachednodes: {
# [nodename]:
# { [attrname]:{distribution} }
# }
# clusterstat:{[attrname]:{distribution}}
# }
# }
self._NxObjUpdated = False
self._VisNxObjUpdated = False
def calculatenodestat(self):
self._durarray, self._countarray, self._flowarray = np.split(self._dataarray, 3, axis=1)
self._durarray[self._durarray == 0] = -1 # make 0 duration negative to identify
# calculate each indicator
self._avesizearr = self._flowarray / self._countarray
self._avesizearr[self._avesizearr < 0] = 10 ** -6
self._avedataratearr = self._flowarray / self._durarray
self._avedataratearr[self._avedataratearr < 0] = 10 ** -6 # make negative time a small value and bin to 0
self._avefreqarr = self._countarray / self._durarray
self._avefreqarr[self._avefreqarr < 0] = 10 ** -6 # make negative time a small value and bin to 0
# log2 binning + counting
# Can use np.digitize(arr, np.logspace(arr.min,arr.max,d)) instead but this min/max is not global
def onehotencode(arr): # use one hot encoding to represent the vectors
arr = np.floor(np.log2(arr)/np.log2(1.2)).reshape(1,-1) # TODO: change the binning function
arr[ arr < 1] = 0
arr = arr.astype(np.int)
arrstat = np.zeros((arr.size, arr.max() + 1))
arrstat[np.arange(arr.size),arr] = 1
arrstat = arrstat.sum(axis=0)
return arrstat
return onehotencode(self._avesizearr), onehotencode(self._avedataratearr), onehotencode(self._avefreqarr)
def calculateclusterstat(self):
def addVecs(v1,v2):
s_diff = np.size(v1) - np.size(v2)
if s_diff > 0:
v2 = np.append(v2, [0]*s_diff)
else :
v1 = np.append(v1, [0]*(-s_diff))
return v1+v2
self.globalStat['globalsizestat'] = np.array([])
self.globalStat['globalratestat'] = np.array([])
self.globalStat['globalfreqstat'] = np.array([])
for clu in self.distribution:
cur_clu = self.distribution[clu]
cur_clu['clusterstat'] = {}
self._clusizestat = np.array([])
self._cluratestat = np.array([])
self._clufreqstat = np.array([])
for atnd in cur_clu['attachednodes']: # update cluster stat by nodes
cur_atnd = cur_clu['attachednodes'][atnd]
self._clusizestat = addVecs(cur_atnd['sizestat'], self._clusizestat)
self._cluratestat = addVecs(cur_atnd['ratestat'], self._cluratestat)
self._clufreqstat = addVecs(cur_atnd['freqstat'], self._clufreqstat)
# export cluster stat
cur_clu['clusterstat']['clustersizestat'] = self._clusizestat
cur_clu['clusterstat']['clusterratestat'] = self._cluratestat
cur_clu['clusterstat']['clusterfreqstat'] = self._clufreqstat
# update global stat (FOR Jelinek-Mercer Smoothing)
self.globalStat['globalsizestat'] = addVecs(self.globalStat['globalsizestat'], self._clusizestat)
self.globalStat['globalratestat'] = addVecs(self.globalStat['globalratestat'], self._cluratestat)
self.globalStat['globalfreqstat'] = addVecs(self.globalStat['globalfreqstat'], self._clufreqstat)
def anomalyscore(self):
def addVecs(v1,v2):
s_diff = np.size(v1) - np.size(v2)
if s_diff > 0:
v2 = np.append(v2, [0]*s_diff)
else :
v1 = np.append(v1, [0]*(-s_diff))
return v1+v2
def kldivergence(v1, v2, vg, miu=len(self.NxObj.nodes)): # vg and miu are J-K smoothing arguments
v1 = v1/v1.sum()
v2 = addVecs(v2, (1/miu)*vg)
v2 = v2/v2.sum()
s_diff = np.size(v1) - np.size(v2)
if s_diff > 0:
v2 = np.append(v2, [0]*s_diff)
else :
v1 = np.append(v1, [0]*(-s_diff))
return np.sum(np.where(v1 != 0, v1 * np.log(v1 / v2), 0)) # KL(P||Q)
# Problem: v1!=0 but v2==0 ?
# [Fix: Jelinek-Mercer Smoothing] use global stat to do J-K SMOOTHING
for clu in self.distribution:
cur_clu = self.distribution[clu]
for atnd in cur_clu['attachednodes']:
cur_atnd = cur_clu['attachednodes'][atnd]
cur_atnd_kl = 0
for compare_clu in self.distribution:
cur_atnd_cur_compare_clu_kl = 0
cur_compare_clu = self.distribution[compare_clu]
cur_compare_clu_proportion = len(cur_compare_clu['attachednodes']) / len(self.NxObj.nodes)
cur_atnd_cur_compare_clu_kl += kldivergence(cur_atnd['sizestat'], cur_compare_clu['clusterstat']['clustersizestat'], self.globalStat['globalsizestat'] )
cur_atnd_cur_compare_clu_kl += kldivergence(cur_atnd['ratestat'], cur_compare_clu['clusterstat']['clusterratestat'], self.globalStat['globalratestat'])
cur_atnd_cur_compare_clu_kl += kldivergence(cur_atnd['freqstat'], cur_compare_clu['clusterstat']['clusterfreqstat'], self.globalStat['globalfreqstat'])
cur_atnd_cur_compare_clu_kl = cur_atnd_cur_compare_clu_kl * cur_compare_clu_proportion
cur_atnd_kl += cur_atnd_cur_compare_clu_kl
cur_atnd['kldivergence'] = cur_atnd_kl
def updateNxObj(self):
if self._NxObjUpdated == True:
return
for clu in self.distribution:
cur_clu = self.distribution[clu]
for atnd in cur_clu['attachednodes']:
self.NxObj.nodes[atnd]['data']['kldivergence'] = cur_clu['attachednodes'][atnd]['kldivergence']
self.NxObj.nodes[atnd]['data']['clusternumber'] = clu
self._NxObjUpdated = True
return
def process(self):
# create xmeans object
self.xmalgoObj = XmeansAlgorithm(self.NxObj)
self.xmalgoObj.process()
self.xmalgoResult = self.xmalgoObj.getResult()
self.xmalgoCenter = self.xmalgoObj.getCenters()
# import xmeans result
for nd in self.xmalgoResult:
self.NxObj.nodes[nd]['data']['cluster'] = self.xmalgoResult[nd]
# delete xmeans object
del self.xmalgoObj
#del xmalgoResult
# get distributions
for nd in self.NxObj.nodes: # each node
cur_nd = self.NxObj.nodes[nd]
if cur_nd['data']['cluster'] not in self.distribution:
self.distribution[cur_nd['data']['cluster']] = { 'attachednodes':{}, 'clusterstat':{} }
if nd not in self.distribution[cur_nd['data']['cluster']]['attachednodes']:
self.distribution[cur_nd['data']['cluster']]['attachednodes'][nd] = {}
self._dataarray = np.array([])
for adjnd in self.NxObj.adj[nd]: # each adj edge of node
cur_eg = self.NxObj.edges[nd,adjnd] # update data array with each edge
if len(self._dataarray)==0 :
self._dataarray = np.array([cur_eg['data']['duration'], cur_eg['data']['count'], cur_eg['data']['flow']])
else:
self._dataarray = np.append(self._dataarray, [cur_eg['data']['duration'], cur_eg['data']['count'], cur_eg['data']['flow']])
self._dataarray = self._dataarray.reshape(-1,3) # prepare data array for node stat
self._sizestat, self._ratestat, self._freqstat = self.calculatenodestat()
# export result to distribution dict
self.distribution[cur_nd['data']['cluster']]['attachednodes'][nd]['sizestat'] = self._sizestat
self.distribution[cur_nd['data']['cluster']]['attachednodes'][nd]['ratestat'] = self._ratestat
self.distribution[cur_nd['data']['cluster']]['attachednodes'][nd]['freqstat'] = self._freqstat
self.calculateclusterstat()
self.anomalyscore()
self.updateNxObj() # export distribution to NxObj
def generateVisNxObj(self):
def reLU(x):
if x > 0:
return x
else:
return 0
if self._VisNxObjUpdated == True:
return self.VisNxObj
self.VisNxObj = networkx.Graph()
for nd in self.NxObj.nodes:
self.VisNxObj.add_node(nd,
cluster=self.NxObj.nodes[nd]['data']['clusternumber'],
kldfloor=np.floor(self.NxObj.nodes[nd]['data']['kldivergence']/5),
flowlog=np.floor(np.log2(self.NxObj.nodes[nd]['data']['flow']))
)
for eg in self.NxObj.edges:
self.VisNxObj.add_edge(eg[0],eg[1],
flowlog=np.floor(np.log2(self.NxObj.edges[eg]['data']['flow'])),
avesize=reLU(np.log2(self.NxObj.edges[eg]['data']['flow']/self.NxObj.edges[eg]['data']['count']))
)
self._VisNxObjUpdated = True
return self.VisNxObj
def exportGEXF(self, outputfilename):
self.generateVisNxObj()
return networkx.write_gexf(self.VisNxObj, outputfilename)
def exportAnomalyScore(self, outputfilename=None):
if len(self.anormlyscoredict) == 0:
for clu in self.distribution:
cur_clu = self.distribution[clu]
for atnd in cur_clu['attachednodes']:
self.anormlyscoredict[atnd] = {}
self.anormlyscoredict[atnd]['kldivergence'] = cur_clu['attachednodes'][atnd]['kldivergence']
self.anormlyscoredict[atnd]['clusternumber'] = clu
if outputfilename:
with open(outputfilename,"w") as f:
f.write(json.dumps(self.anormlyscoredict))
return self.anormlyscoredict
def getNetworkxObj(self):
self.updateNxObj()
return self.NxObj
def getDistributionDict(self):
return self.distribution
def getClusteringResults(self):
return self.xmalgoResult, self.xmalgoCenter
def getGlobalStat(self):
return self.globalStat
|
{
"imports": [
"/Common.py",
"/GraphGenerator.py",
"/Algorithm.py",
"/Application.py"
]
}
|
0-1CxH/Graphware-Based-Network-Monitoring
|
refs/heads/master
|
/Application.py
|
import numpy as np
import matplotlib.pyplot as plt
import json
from Algorithm import XmeansAlgorithm
import networkx
'''
modifiedEdgeCentricAnalyzer is based on the paper "EdgeCentric: Anomaly Detection in Edge-Attributed Networks"
by Neil Shah1 et al. I modified some parts to make it suitable for TDG.
Class object init by a Networkx object that generated by dpktTrafficSelector + wEFPConverterIncr
The methods are :
1) Get instance
mecObj = modifiedEdgeCentricAnalyzer(nxobj)
2) Process the whole MEC algorithm
mecObj.process()
3) Export results
mecObj.exportAnomalyScore("anormalyScoreOutput.json")) # Write anomaly score of hosts to json file
mecObj.getNetworkxObj # Get NxObj that contains all related information
mecObj.generateVisNxObj # Simplify the NxObj as VisNxObj including only essential info for visualization
mecObj.exportGEXF("mceVis.gexf") # Export VisNxObj to GEXF format file
4) Obtain intermediate results
cluster_points, cluster_centers = mecObj.getClusteringResults() # clustering results of X-means
mecObj.getGlobalStat() # Get the size/rate/freq stat of the whole graph (all clusters)
mecObj.getDistributionDict() # Get the stat of each nodes and each clusters
5) Private function
mecObj.process() Depends On mecObj.{calculatenodestat(), calculateclusterstat(), anomalyscore()}
Routine:
mecObj = modifiedEdgeCentricAnalyzer(nxobj)
mecObj.process()
mecObj.exportAnomalyScore("anormalyScoreOutput.json"))
mecObj.exportGEXF("mceVis.gexf")
'''
class modifiedEdgeCentricAnalyzer(object):
def __init__(self, NxObj):
self.NxObj = NxObj
self.globalStat = {}
self.distribution = {}
self.anormlyscoredict = {}
# structure: {
# [clusternumber]:{
# attachednodes: {
# [nodename]:
# { [attrname]:{distribution} }
# }
# clusterstat:{[attrname]:{distribution}}
# }
# }
self._NxObjUpdated = False
self._VisNxObjUpdated = False
def calculatenodestat(self):
self._durarray, self._countarray, self._flowarray = np.split(self._dataarray, 3, axis=1)
self._durarray[self._durarray == 0] = -1 # make 0 duration negative to identify
# calculate each indicator
self._avesizearr = self._flowarray / self._countarray
self._avesizearr[self._avesizearr < 0] = 10 ** -6
self._avedataratearr = self._flowarray / self._durarray
self._avedataratearr[self._avedataratearr < 0] = 10 ** -6 # make negative time a small value and bin to 0
self._avefreqarr = self._countarray / self._durarray
self._avefreqarr[self._avefreqarr < 0] = 10 ** -6 # make negative time a small value and bin to 0
# log2 binning + counting
# Can use np.digitize(arr, np.logspace(arr.min,arr.max,d)) instead but this min/max is not global
def onehotencode(arr): # use one hot encoding to represent the vectors
arr = np.floor(np.log2(arr)/np.log2(1.2)).reshape(1,-1) # TODO: change the binning function
arr[ arr < 1] = 0
arr = arr.astype(np.int)
arrstat = np.zeros((arr.size, arr.max() + 1))
arrstat[np.arange(arr.size),arr] = 1
arrstat = arrstat.sum(axis=0)
return arrstat
return onehotencode(self._avesizearr), onehotencode(self._avedataratearr), onehotencode(self._avefreqarr)
def calculateclusterstat(self):
def addVecs(v1,v2):
s_diff = np.size(v1) - np.size(v2)
if s_diff > 0:
v2 = np.append(v2, [0]*s_diff)
else :
v1 = np.append(v1, [0]*(-s_diff))
return v1+v2
self.globalStat['globalsizestat'] = np.array([])
self.globalStat['globalratestat'] = np.array([])
self.globalStat['globalfreqstat'] = np.array([])
for clu in self.distribution:
cur_clu = self.distribution[clu]
cur_clu['clusterstat'] = {}
self._clusizestat = np.array([])
self._cluratestat = np.array([])
self._clufreqstat = np.array([])
for atnd in cur_clu['attachednodes']: # update cluster stat by nodes
cur_atnd = cur_clu['attachednodes'][atnd]
self._clusizestat = addVecs(cur_atnd['sizestat'], self._clusizestat)
self._cluratestat = addVecs(cur_atnd['ratestat'], self._cluratestat)
self._clufreqstat = addVecs(cur_atnd['freqstat'], self._clufreqstat)
# export cluster stat
cur_clu['clusterstat']['clustersizestat'] = self._clusizestat
cur_clu['clusterstat']['clusterratestat'] = self._cluratestat
cur_clu['clusterstat']['clusterfreqstat'] = self._clufreqstat
# update global stat (FOR Jelinek-Mercer Smoothing)
self.globalStat['globalsizestat'] = addVecs(self.globalStat['globalsizestat'], self._clusizestat)
self.globalStat['globalratestat'] = addVecs(self.globalStat['globalratestat'], self._cluratestat)
self.globalStat['globalfreqstat'] = addVecs(self.globalStat['globalfreqstat'], self._clufreqstat)
def anomalyscore(self):
def addVecs(v1,v2):
s_diff = np.size(v1) - np.size(v2)
if s_diff > 0:
v2 = np.append(v2, [0]*s_diff)
else :
v1 = np.append(v1, [0]*(-s_diff))
return v1+v2
def kldivergence(v1, v2, vg, miu=len(self.NxObj.nodes)): # vg and miu are J-K smoothing arguments
v1 = v1/v1.sum()
v2 = addVecs(v2, (1/miu)*vg)
v2 = v2/v2.sum()
s_diff = np.size(v1) - np.size(v2)
if s_diff > 0:
v2 = np.append(v2, [0]*s_diff)
else :
v1 = np.append(v1, [0]*(-s_diff))
return np.sum(np.where(v1 != 0, v1 * np.log(v1 / v2), 0)) # KL(P||Q)
# Problem: v1!=0 but v2==0 ?
# [Fix: Jelinek-Mercer Smoothing] use global stat to do J-K SMOOTHING
for clu in self.distribution:
cur_clu = self.distribution[clu]
for atnd in cur_clu['attachednodes']:
cur_atnd = cur_clu['attachednodes'][atnd]
cur_atnd_kl = 0
for compare_clu in self.distribution:
cur_atnd_cur_compare_clu_kl = 0
cur_compare_clu = self.distribution[compare_clu]
cur_compare_clu_proportion = len(cur_compare_clu['attachednodes']) / len(self.NxObj.nodes)
cur_atnd_cur_compare_clu_kl += kldivergence(cur_atnd['sizestat'], cur_compare_clu['clusterstat']['clustersizestat'], self.globalStat['globalsizestat'] )
cur_atnd_cur_compare_clu_kl += kldivergence(cur_atnd['ratestat'], cur_compare_clu['clusterstat']['clusterratestat'], self.globalStat['globalratestat'])
cur_atnd_cur_compare_clu_kl += kldivergence(cur_atnd['freqstat'], cur_compare_clu['clusterstat']['clusterfreqstat'], self.globalStat['globalfreqstat'])
cur_atnd_cur_compare_clu_kl = cur_atnd_cur_compare_clu_kl * cur_compare_clu_proportion
cur_atnd_kl += cur_atnd_cur_compare_clu_kl
cur_atnd['kldivergence'] = cur_atnd_kl
def updateNxObj(self):
if self._NxObjUpdated == True:
return
for clu in self.distribution:
cur_clu = self.distribution[clu]
for atnd in cur_clu['attachednodes']:
self.NxObj.nodes[atnd]['data']['kldivergence'] = cur_clu['attachednodes'][atnd]['kldivergence']
self.NxObj.nodes[atnd]['data']['clusternumber'] = clu
self._NxObjUpdated = True
return
def process(self):
# create xmeans object
self.xmalgoObj = XmeansAlgorithm(self.NxObj)
self.xmalgoObj.process()
self.xmalgoResult = self.xmalgoObj.getResult()
self.xmalgoCenter = self.xmalgoObj.getCenters()
# import xmeans result
for nd in self.xmalgoResult:
self.NxObj.nodes[nd]['data']['cluster'] = self.xmalgoResult[nd]
# delete xmeans object
del self.xmalgoObj
#del xmalgoResult
# get distributions
for nd in self.NxObj.nodes: # each node
cur_nd = self.NxObj.nodes[nd]
if cur_nd['data']['cluster'] not in self.distribution:
self.distribution[cur_nd['data']['cluster']] = { 'attachednodes':{}, 'clusterstat':{} }
if nd not in self.distribution[cur_nd['data']['cluster']]['attachednodes']:
self.distribution[cur_nd['data']['cluster']]['attachednodes'][nd] = {}
self._dataarray = np.array([])
for adjnd in self.NxObj.adj[nd]: # each adj edge of node
cur_eg = self.NxObj.edges[nd,adjnd] # update data array with each edge
if len(self._dataarray)==0 :
self._dataarray = np.array([cur_eg['data']['duration'], cur_eg['data']['count'], cur_eg['data']['flow']])
else:
self._dataarray = np.append(self._dataarray, [cur_eg['data']['duration'], cur_eg['data']['count'], cur_eg['data']['flow']])
self._dataarray = self._dataarray.reshape(-1,3) # prepare data array for node stat
self._sizestat, self._ratestat, self._freqstat = self.calculatenodestat()
# export result to distribution dict
self.distribution[cur_nd['data']['cluster']]['attachednodes'][nd]['sizestat'] = self._sizestat
self.distribution[cur_nd['data']['cluster']]['attachednodes'][nd]['ratestat'] = self._ratestat
self.distribution[cur_nd['data']['cluster']]['attachednodes'][nd]['freqstat'] = self._freqstat
self.calculateclusterstat()
self.anomalyscore()
self.updateNxObj() # export distribution to NxObj
def generateVisNxObj(self):
def reLU(x):
if x > 0:
return x
else:
return 0
if self._VisNxObjUpdated == True:
return self.VisNxObj
self.VisNxObj = networkx.Graph()
for nd in self.NxObj.nodes:
self.VisNxObj.add_node(nd,
cluster=self.NxObj.nodes[nd]['data']['clusternumber'],
kldfloor=np.floor(self.NxObj.nodes[nd]['data']['kldivergence']/5),
flowlog=np.floor(np.log2(self.NxObj.nodes[nd]['data']['flow']))
)
for eg in self.NxObj.edges:
self.VisNxObj.add_edge(eg[0],eg[1],
flowlog=np.floor(np.log2(self.NxObj.edges[eg]['data']['flow'])),
avesize=reLU(np.log2(self.NxObj.edges[eg]['data']['flow']/self.NxObj.edges[eg]['data']['count']))
)
self._VisNxObjUpdated = True
return self.VisNxObj
def exportGEXF(self, outputfilename):
self.generateVisNxObj()
return networkx.write_gexf(self.VisNxObj, outputfilename)
def exportAnomalyScore(self, outputfilename=None):
if len(self.anormlyscoredict) == 0:
for clu in self.distribution:
cur_clu = self.distribution[clu]
for atnd in cur_clu['attachednodes']:
self.anormlyscoredict[atnd] = {}
self.anormlyscoredict[atnd]['kldivergence'] = cur_clu['attachednodes'][atnd]['kldivergence']
self.anormlyscoredict[atnd]['clusternumber'] = clu
if outputfilename:
with open(outputfilename,"w") as f:
f.write(json.dumps(self.anormlyscoredict))
return self.anormlyscoredict
def getNetworkxObj(self):
self.updateNxObj()
return self.NxObj
def getDistributionDict(self):
return self.distribution
def getClusteringResults(self):
return self.xmalgoResult, self.xmalgoCenter
def getGlobalStat(self):
return self.globalStat
|
from pyclustering.cluster import cluster_visualizer
from pyclustering.cluster.xmeans import xmeans
from pyclustering.cluster.center_initializer import kmeans_plusplus_initializer
from sklearn.preprocessing import normalize
class XmeansAlgorithm(object):
def __init__(self, NxObj, amount_initial_centers=2, amount_max_centers=16):
self.dataset = dict(NxObj.nodes.data())
self.namelist = []
self.datalist = []
self.resultDict = {}
self.amount_initial_centers = amount_initial_centers
self.amount_max_centers = amount_max_centers
def importData(self):
for dp in self.dataset:
self.namelist.append(dp)
self.datalist.append([self.dataset[dp]['data']['SYNRequest'],
self.dataset[dp]['data']['SYNAccept'] ,
self.dataset[dp]['data']['flow']])
self.datalist = normalize(self.datalist) # Normalize Data
#del self.dataset
def xmeansRoutine(self):
self.initial_centers = kmeans_plusplus_initializer(self.datalist, self.amount_initial_centers).initialize()
self.xmeans_instance = xmeans(self.datalist, self.initial_centers, self.amount_max_centers)
self.xmeans_instance.process()
self.clusters = self.xmeans_instance.get_clusters()
self.centers = self.xmeans_instance.get_centers()
def exportData(self):
for clu, arr in enumerate(self.clusters):
for n in arr:
self.resultDict[self.namelist[n]] = clu
def process(self):
self.importData()
self.xmeansRoutine()
self.exportData()
def getResult(self):
return self.resultDict
def getCenters(self):
return self.centers
def getVisualization(self):
self.visualizer = cluster_visualizer()
self.visualizer.append_clusters(self.clusters, self.datalist)
self.visualizer.append_cluster(self.centers, None, marker='*', markersize=10)
self.visualizer.show()
|
{
"imports": [
"/Algorithm.py"
]
}
|
0-8-4/nonebot_plugin_russian
|
refs/heads/main
|
/russian/__init__.py
|
from nonebot import on_command, require
import random
import asyncio
from nonebot.adapters.cqhttp import GROUP, Bot, GroupMessageEvent, Message, MessageSegment
from nonebot.typing import T_State
from .util import get_message_text, is_number, get_message_at
import time
from .data_source import rank, end_handle
from pathlib import Path
import os
import nonebot
try:
import ujson as json
except ModuleNotFoundError:
import json
__zx_plugin_name__ = '俄罗斯轮盘'
__plugin_usage__ = '''俄罗斯轮盘帮助：
开启游戏：装弹 [子弹数] [金额](默认200金币) [at](指定决斗对象，为空则所有群友都可接受决斗)
示例：装弹 1 10
接受对决：接受对决/拒绝决斗
开始对决：开枪（轮流开枪，30秒未开枪另一方可使用‘结算’命令结束对决并胜利）
结算：结算（当某一方30秒未开枪，可使用该命令强行结束对决并胜利）
我的战绩：我的战绩
排行榜：金币排行/胜场排行/败场排行/欧洲人排行/慈善家排行
【注：同一时间群内只能有一场对决】
'''
scheduler = require("nonebot_plugin_apscheduler").scheduler
driver: nonebot.Driver = nonebot.get_driver()
bot_name = list(driver.config.nickname)[0] if driver.config.nickname else '本裁判'
sign_gold = driver.config.sign_gold if driver.config.sign_gold else [1, 100]
max_bet_gold = driver.config.max_bet_gold if driver.config.max_bet_gold else 1000
russian_path = driver.config.russian_path if driver.config.russian_path else ''
player_data = {}
if russian_path:
file = Path(russian_path) / 'russian_data.json'
file.parent.mkdir(exist_ok=True, parents=True)
if file.exists():
player_data = json.load(open(file, 'r', encoding='utf8'))
else:
old_file = os.path.abspath(os.path.join(os.path.dirname(__file__), 'russian_data.json'))
if os.path.exists(old_file):
os.rename(old_file, file)
player_data = json.load(open(file, 'r', encoding='utf8'))
else:
file = os.path.abspath(os.path.join(os.path.dirname(__file__), 'russian_data.json'))
if os.path.exists(file):
player_data = json.load(open(file, 'r', encoding='utf8'))
rs_player = {}
sign = on_command('轮盘签到', permission=GROUP, priority=5, block=True)
rssian = on_command('俄罗斯轮盘', aliases={'装弹', '俄罗斯转盘'}, permission=GROUP, priority=5, block=True)
accept = on_command('接受对决', aliases={'接受决斗', '接受挑战'}, permission=GROUP, priority=5, block=True)
refuse = on_command('拒绝对决', aliases={'拒绝决斗', '拒绝挑战'}, permission=GROUP, priority=5, block=True)
shot = on_command('开枪', aliases={'咔', '嘭', '嘣'}, permission=GROUP, priority=5, block=True)
settlement = on_command('结算', permission=GROUP, priority=5, block=True)
record = on_command('我的战绩', permission=GROUP, priority=5, block=True)
rssian_rank = on_command('胜场排行', aliases={'金币排行', '胜利排行', '败场排行', '失败排行',
'欧洲人排行', '慈善家排行'}, permission=GROUP, priority=5, block=True)
my_gold = on_command('我的金币', permission=GROUP, priority=5, block=True)
@sign.handle()
async def _(bot: Bot, event: GroupMessageEvent, state: T_State):
global player_data
player_is_exists(event)
if player_data[str(event.group_id)][str(event.user_id)]['is_sign']:
await sign.finish('贪心的人是不会有好运的...', at_sender=True)
gold = random.randint(sign_gold[0], sign_gold[1])
player_data[str(event.group_id)][str(event.user_id)]['gold'] += gold
player_data[str(event.group_id)][str(event.user_id)]['make_gold'] += gold
player_data[str(event.group_id)][str(event.user_id)]['is_sign'] = True
await sign.send(random.choice([f'这是今天的钱，祝你好运...', '今天可别输光光了.']) + f'\n你获得了 {gold} 金币', at_sender=True)
with open(file, 'w', encoding='utf8') as f:
json.dump(player_data, f, ensure_ascii=False, indent=4)
@accept.handle()
async def _(bot: Bot, event: GroupMessageEvent, state: T_State):
global rs_player, player_data
player_is_exists(event)
try:
if rs_player[event.group_id][1] == 0:
await accept.finish('目前没有发起对决，你接受个啥？速速装弹！', at_sender=True)
except KeyError:
await accept.finish('目前没有进行的决斗，请发送 装弹 开启决斗吧！', at_sender=True)
if rs_player[event.group_id][2] != 0:
if rs_player[event.group_id][1] == event.user_id or rs_player[event.group_id][2] == event.user_id:
await accept.finish(f'你已经身处决斗之中了啊，给我认真一点啊！', at_sender=True)
else:
await accept.finish('已经有人接受对决了，你还是乖乖等待下一场吧！', at_sender=True)
if rs_player[event.group_id][1] == event.user_id:
await accept.finish('请不要自己枪毙自己！换人来接受对决...', at_sender=True)
if rs_player[event.group_id]['at'] != 0 and rs_player[event.group_id]['at'] != event.user_id:
await accept.finish(Message(f'这场对决是邀请 {MessageSegment.at(rs_player[event.group_id]["at"])}的，不要捣乱！'),
at_sender=True)
if time.time() - rs_player[event.group_id]['time'] > 30:
rs_player[event.group_id] = {}
await accept.finish('这场对决邀请已经过时了，请重新发起决斗...', at_sender=True)
user_money = player_data[str(event.group_id)][str(event.user_id)]['gold']
if user_money < rs_player[event.group_id]['money']:
if rs_player[event.group_id]['at'] != 0 and rs_player[event.group_id]['at'] == event.user_id:
rs_player[event.group_id] = {}
await accept.finish('你的金币不足以接受这场对决！对决还未开始便结束了，请重新装弹！', at_sender=True)
else:
await accept.finish('你的金币不足以接受这场对决！', at_sender=True)
player2_name = event.sender.card if event.sender.card else event.sender.nickname
rs_player[event.group_id][2] = event.user_id
rs_player[event.group_id]['player2'] = player2_name
rs_player[event.group_id]['time'] = time.time()
await accept.send(Message(f'{player2_name}接受了对决！\n'
f'请{MessageSegment.at(rs_player[event.group_id][1])}先开枪！'))
@refuse.handle()
async def _(bot: Bot, event: GroupMessageEvent, state: T_State):
global rs_player
player_is_exists(event)
try:
if rs_player[event.group_id][1] == 0:
await accept.finish('你要拒绝啥？明明都没有人发起对决的说！', at_sender=True)
except KeyError:
await refuse.finish('目前没有进行的决斗，请发送 装弹 开启决斗吧！', at_sender=True)
if rs_player[event.group_id]['at'] != 0 and event.user_id != rs_player[event.group_id]['at']:
await accept.finish('又不是找你决斗，你拒绝什么啊！气！', at_sender=True)
if rs_player[event.group_id]['at'] == event.user_id:
at_player_name = await bot.get_group_member_info(group_id=event.group_id, user_id=event.user_id)
at_player_name = at_player_name['card'] if at_player_name['card'] else at_player_name['nickname']
await accept.send(Message(f'{MessageSegment.at(rs_player[event.group_id][1])}\n'
f'{at_player_name}拒绝了你的对决！'))
rs_player[event.group_id] = {}
@settlement.handle()
async def _(bot: Bot, event: GroupMessageEvent, state: T_State):
global rs_player
player_is_exists(event)
if not rs_player.get(event.group_id) or rs_player[event.group_id][1] == 0 or rs_player[event.group_id][2] == 0:
await settlement.finish('比赛并没有开始...无法结算...', at_sender=True)
if event.user_id != rs_player[event.group_id][1] and event.user_id != rs_player[event.group_id][2]:
await settlement.finish('吃瓜群众不要捣乱！黄牌警告！', at_sender=True)
if time.time() - rs_player[event.group_id]['time'] <= 30:
await settlement.finish(f'{rs_player[event.group_id]["player1"]} 和'
f' {rs_player[event.group_id]["player2"]} 比赛并未超时，请继续比赛...')
win_name = rs_player[event.group_id]["player1"] if \
rs_player[event.group_id][2] == rs_player[event.group_id]['next'] else \
rs_player[event.group_id]["player2"]
await settlement.send(f'这场对决是 {win_name} 胜利了')
await end_game(bot, event)
@rssian.args_parser
async def _(bot: Bot, event: GroupMessageEvent, state: T_State):
player_is_exists(event)
msg = get_message_text(event.json())
if msg in ['取消', '算了']:
await rssian.finish('已取消操作...')
try:
if rs_player[event.group_id][1] != 0:
await rssian.finish('决斗已开始...', at_sender=True)
except KeyError:
pass
if not is_number(msg):
await rssian.reject('输入子弹数量必须是数字啊喂！')
if int(msg) < 1 or int(msg) > 6:
await rssian.reject('子弹数量必须大于0小于7！')
state['bullet_num'] = int(msg)
@rssian.handle()
async def _(bot: Bot, event: GroupMessageEvent, state: T_State):
global rs_player
player_is_exists(event)
msg = get_message_text(event.json())
if msg == '帮助':
await rssian.finish(__plugin_usage__)
try:
if rs_player[event.group_id][1] and not rs_player[event.group_id][2] and \
time.time() - rs_player[event.group_id]['time'] <= 30:
await rssian.finish(f'现在是 {rs_player[event.group_id]["player1"]} 发起的对决\n请等待比赛结束后再开始下一轮...')
if rs_player[event.group_id][1] and rs_player[event.group_id][2] and \
time.time() - rs_player[event.group_id]['time'] <= 30:
await rssian.finish(f'{rs_player[event.group_id]["player1"]} 和'
f' {rs_player[event.group_id]["player2"]}的对决还未结束！')
if rs_player[event.group_id][1] and rs_player[event.group_id][2] and \
time.time() - rs_player[event.group_id]['time'] > 30:
await rssian.send('决斗已过时，强行结算...')
await end_game(bot, event)
if not rs_player[event.group_id][2] and time.time() - rs_player[event.group_id]['time'] > 30:
rs_player[event.group_id][1] = 0
rs_player[event.group_id][2] = 0
rs_player[event.group_id]['at'] = 0
except KeyError:
pass
if msg:
msg = msg.split(' ')
if len(msg) == 1:
msg = msg[0]
if is_number(msg) and not (int(msg) < 1 or int(msg) > 6):
state['bullet_num'] = int(msg)
else:
money = msg[1].strip()
msg = msg[0].strip()
if is_number(msg) and not (int(msg) < 1 or int(msg) > 6):
state['bullet_num'] = int(msg)
if is_number(money) and 0 < int(money) <= max_bet_gold:
state['money'] = int(money)
state['at'] = get_message_at(event.json())
@rssian.got("bullet_num", prompt='请输入装填子弹的数量！(最多6颗)')
async def _(bot: Bot, event: GroupMessageEvent, state: T_State):
global rs_player, player_data
player_is_exists(event)
bullet_num = state['bullet_num']
at_ = state['at']
money = state['money'] if state.get('money') else 200
user_money = player_data[str(event.group_id)][str(event.user_id)]['gold']
if bullet_num < 0 or bullet_num > 6:
await rssian.reject('子弹数量必须大于0小于7！速速重新装弹！')
if money > max_bet_gold:
await rssian.finish(f'太多了！单次金额不能超过{max_bet_gold}！', at_sender=True)
if money > user_money:
await rssian.finish('你没有足够的钱支撑起这场挑战', at_sender=True)
player1_name = event.sender.card if event.sender.nickname else event.sender.nickname
if at_:
at_ = at_[0]
at_player_name = await bot.get_group_member_info(group_id=event.group_id, user_id=int(at_))
at_player_name = at_player_name['card'] if at_player_name['card'] else at_player_name['nickname']
msg = f'{player1_name} 向 {MessageSegment.at(at_)} 发起了决斗！请 {at_player_name} 在30秒内回复‘接受对决’ or ‘拒绝对决’，超时此次决斗作废！'
else:
at_ = 0
msg = '若30秒内无人接受挑战则此次对决作废【首次游玩请发送 ’俄罗斯轮盘帮助‘ 来查看命令】'
rs_player[event.group_id] = {1: event.user_id,
'player1': player1_name,
2: 0,
'player2': '',
'at': at_,
'next': event.user_id,
'money': money,
'bullet': random_bullet(bullet_num),
'bullet_num': bullet_num,
'null_bullet_num': 7 - bullet_num,
'index': 0,
'time': time.time()}
await rssian.send(Message(('咔 ' * bullet_num)[:-1] + f'，装填完毕\n挑战金额：{money}\n'
f'第一枪的概率为：{str(float(bullet_num) / 7.0 * 100)[:5]}%\n'
f'{msg}'))
@shot.handle()
async def _(bot: Bot, event: GroupMessageEvent, state: T_State):
global rs_player
player_is_exists(event)
try:
if time.time() - rs_player[event.group_id]['time'] > 30:
if rs_player[event.group_id][2] == 0:
rs_player[event.group_id][1] = 0
await shot.finish('这场对决已经过时了，请重新装弹吧！', at_sender=True)
else:
await shot.send('决斗已过时，强行结算...')
await end_game(bot, event)
return
except KeyError:
await shot.finish('目前没有进行的决斗，请发送 装弹 开启决斗吧！', at_sender=True)
if rs_player[event.group_id][1] == 0:
await shot.finish('没有对决，也还没装弹呢，请先输入 装弹 吧！', at_sender=True)
if rs_player[event.group_id][1] == event.user_id and rs_player[event.group_id][2] == 0:
await shot.finish('baka，你是要枪毙自己嘛笨蛋！', at_sender=True)
if rs_player[event.group_id][2] == 0:
await shot.finish('请这位勇士先发送 接受对决 来站上擂台...', at_sender=True)
player1_name = rs_player[event.group_id]['player1']
player2_name = rs_player[event.group_id]['player2']
if rs_player[event.group_id]['next'] != event.user_id:
if event.user_id != rs_player[event.group_id][1] and event.user_id != rs_player[event.group_id][2]:
nickname = event.sender.card if event.sender.card else event.sender.nickname
await shot.finish(random.choice([
f'不要打扰 {player1_name} 和 {player2_name} 的决斗啊！',
'给我好好做好一个观众！不然list(bot.config.nickname)[0]就要生气了',
f'不要捣乱啊baka{nickname}！'
]), at_sender=True)
nickname = player1_name if rs_player[event.group_id]["next"] == rs_player[event.group_id][1] else player2_name
await shot.finish(f'你的左轮不是连发的！该 {nickname} 开枪了')
if rs_player[event.group_id]['bullet'][rs_player[event.group_id]['index']] != 1:
await shot.send(Message(random.choice([
'呼呼，没有爆裂的声响，你活了下来',
'虽然黑洞洞的枪口很恐怖，但好在没有子弹射出来，你活下来了',
'\"咔\"，你没死，看来运气不错',
]) + f'\n下一枪中弹的概率'
f'：{str(float((rs_player[event.group_id]["bullet_num"])) / float(rs_player[event.group_id]["null_bullet_num"] - 1 + rs_player[event.group_id]["bullet_num"]) * 100)[:5]}%\n'
f'轮到 {MessageSegment.at(rs_player[event.group_id][1] if event.user_id == rs_player[event.group_id][2] else rs_player[event.group_id][2])}了'))
rs_player[event.group_id]["null_bullet_num"] -= 1
rs_player[event.group_id]['next'] = rs_player[event.group_id][1] if \
event.user_id == rs_player[event.group_id][2] else rs_player[event.group_id][2]
rs_player[event.group_id]['time'] = time.time()
rs_player[event.group_id]['index'] += 1
else:
await shot.send(random.choice([
'\"嘭！\"，你直接去世了',
'眼前一黑，你直接穿越到了异世界...(死亡)',
'终究还是你先走一步...',
]) + f'\n第 {rs_player[event.group_id]["index"] + 1} 发子弹送走了你...', at_sender=True)
win_name = player1_name if event.user_id == rs_player[event.group_id][2] else player2_name
await asyncio.sleep(0.5)
await shot.send(f'这场对决是 {win_name} 胜利了')
await end_game(bot, event)
async def end_game(bot: Bot, event: GroupMessageEvent):
global rs_player, player_data
player1_name = rs_player[event.group_id]['player1']
player2_name = rs_player[event.group_id]['player2']
if rs_player[event.group_id]['next'] == rs_player[event.group_id][1]:
win_user_id = rs_player[event.group_id][2]
lose_user_id = rs_player[event.group_id][1]
win_name = player2_name
lose_name = player1_name
else:
win_user_id = rs_player[event.group_id][1]
lose_user_id = rs_player[event.group_id][2]
win_name = player1_name
lose_name = player2_name
rand = random.randint(0, 5)
gold = rs_player[event.group_id]['money']
fee = int(gold * float(rand) / 100)
fee = 1 if fee < 1 and rand != 0 else fee
player_data = end_handle(player_data, win_user_id, lose_user_id, event.group_id, gold, fee)
win_user = player_data[str(event.group_id)][str(win_user_id)]
lose_user = player_data[str(event.group_id)][str(lose_user_id)]
bullet_str = ''
for x in rs_player[event.group_id]['bullet']:
bullet_str += '__ ' if x == 0 else '| '
print(f'俄罗斯轮盘：胜者：{win_name} - 败者：{lose_name} - 金币：{gold}')
await bot.send(event, message=f'结算：\n'
f'\t胜者：{win_name}\n'
f'\t赢取金币：{gold - fee}\n'
f'\t累计胜场：{win_user["win_count"]}\n'
f'\t累计赚取金币：{win_user["make_gold"]}\n'
f'-------------------\n'
f'\t败者：{lose_name}\n'
f'\t输掉金币：{gold}\n'
f'\t累计败场：{lose_user["lose_count"]}\n'
f'\t累计输掉金币：{lose_user["lose_gold"]}\n'
f'-------------------\n'
f'哼哼，{bot_name}从中收取了 {float(rand)}%({fee}金币) 作为手续费！\n'
f'子弹排列：{bullet_str[:-1]}')
rs_player[event.group_id] = {}
with open(file, 'w', encoding='utf8') as f:
json.dump(player_data, f, ensure_ascii=False, indent=4)
@record.handle()
async def _(bot: Bot, event: GroupMessageEvent, state: T_State):
global player_data
player_is_exists(event)
user = player_data[str(event.group_id)][str(event.user_id)]
await record.send(f'俄罗斯轮盘\n'
f'胜利场次：{user["win_count"]}\n'
f'失败场次：{user["lose_count"]}\n'
f'赚取金币：{user["make_gold"]}\n'
f'输掉金币：{user["lose_gold"]}', at_sender=True)
@rssian_rank.handle()
async def _(bot: Bot, event: GroupMessageEvent, state: T_State):
global player_data
if state["_prefix"]["raw_command"] in ['金币排行']:
await rssian_rank.finish(await rank(player_data, event.group_id, 'gold_rank'))
if state["_prefix"]["raw_command"] in ['胜场排行', '胜利排行']:
await rssian_rank.finish(await rank(player_data, event.group_id, 'win_rank'))
if state["_prefix"]["raw_command"] in ['败场排行', '失败排行']:
await rssian_rank.finish(await rank(player_data, event.group_id, 'lose_rank'))
if state["_prefix"]["raw_command"] == '欧洲人排行':
await rssian_rank.finish(await rank(player_data, event.group_id, 'make_gold'))
if state["_prefix"]["raw_command"] == '慈善家排行':
await rssian_rank.finish(await rank(player_data, event.group_id, 'lose_gold'))
@my_gold.handle()
async def _(bot: Bot, event: GroupMessageEvent, state: T_State):
global player_data
player_is_exists(event)
gold = player_data[str(event.group_id)][str(event.user_id)]['gold']
await my_gold.send(f'你还有 {gold} 枚金币', at_sender=True)
# 随机子弹排列
def random_bullet(num: int) -> list:
bullet_lst = [0, 0, 0, 0, 0, 0, 0]
for i in random.sample([0, 1, 2, 3, 4, 5, 6], num):
bullet_lst[i] = 1
return bullet_lst
def player_is_exists(event: GroupMessageEvent) -> dict:
global player_data
user_id = str(event.user_id)
group_id = str(event.group_id)
nickname = event.sender.card if event.sender.card else event.sender.nickname
if group_id not in player_data.keys():
player_data[group_id] = {}
if user_id not in player_data[group_id].keys():
player_data[group_id][user_id] = {
'user_id': user_id,
'group_id': group_id,
'nickname': nickname,
'gold': 0,
'make_gold': 0,
'lose_gold': 0,
'win_count': 0,
'lose_count': 0,
'is_sign': False,
}
return player_data
# 重置每日签到
@scheduler.scheduled_job(
'cron',
hour=0,
minute=0,
)
async def _():
global player_data
for group in player_data.keys():
for user_id in player_data[group].keys():
player_data[group][user_id]['is_sign'] = False
print('每日签到重置成功...')
|
try:
import ujson as json
except ModuleNotFoundError:
import json
def get_message_text(data: str) -> str:
data = json.loads(data)
result = ''
try:
for msg in data['message']:
if msg['type'] == 'text':
result += msg['data']['text'].strip() + ' '
return result.strip()
except Exception:
return ''
def get_message_at(data: str) -> list:
qq_list = []
data = json.loads(data)
try:
for msg in data['message']:
if msg['type'] == 'at':
qq_list.append(int(msg['data']['qq']))
return qq_list
except Exception:
return []
def is_number(s) -> bool:
try:
float(s)
return True
except ValueError:
pass
try:
import unicodedata
unicodedata.numeric(s)
return True
except (TypeError, ValueError):
pass
return False
--- FILE SEPARATOR ---
async def rank(player_data: dict, group_id: int, itype) -> str:
group_id = str(group_id)
all_user = list(player_data[group_id].keys())
if itype == 'gold_rank':
rank_name = '\t金币排行榜\n'
all_user_data = [player_data[group_id][x]['gold'] for x in all_user]
elif itype == 'win_rank':
rank_name = '\t胜场排行榜\n'
all_user_data = [player_data[group_id][x]['win_count'] for x in all_user]
elif itype == 'lose_rank':
rank_name = '\t败场排行榜\n'
all_user_data = [player_data[group_id][x]['lose_count'] for x in all_user]
elif itype == 'make_gold':
rank_name = '\t赢取金币排行榜\n'
all_user_data = [player_data[group_id][x]['make_gold'] for x in all_user]
else:
rank_name = '\t输掉金币排行榜\n'
all_user_data = [player_data[group_id][x]['lose_gold'] for x in all_user]
rst = ''
if all_user:
for _ in range(len(all_user) if len(all_user) < 10 else 10):
_max = max(all_user_data)
_max_id = all_user[all_user_data.index(_max)]
name = player_data[group_id][_max_id]['nickname']
rst += f'{name}：{_max}\n'
all_user_data.remove(_max)
all_user.remove(_max_id)
rst = rst[:-1]
return rank_name + rst
def end_handle(player_data: dict, win_user_id: int, lose_user_id, group_id: int, gold: int, fee: int):
win_user_id = str(win_user_id)
lose_user_id = str(lose_user_id)
group_id = str(group_id)
player_data[group_id][win_user_id]['gold'] += gold - fee
player_data[group_id][win_user_id]['make_gold'] += gold - fee
player_data[group_id][win_user_id]['win_count'] += 1
player_data[group_id][lose_user_id]['gold'] -= gold
player_data[group_id][lose_user_id]['lose_gold'] += gold
player_data[group_id][lose_user_id]['lose_count'] += 1
return player_data
|
{
"imports": [
"/russian/util.py",
"/russian/data_source.py"
]
}
|
0-GEE/SYSTER
|
refs/heads/main
|
/main.py
|
from discord.ext import commands
import cogs
from dotenv import load_dotenv
import os
load_dotenv()
TOKEN = os.getenv('DISCORD_TOKEN')
bot = commands.Bot(command_prefix='%')
bot.add_cog(cogs.Moderation(bot))
bot.add_cog(cogs.Util(bot))
bot.run(TOKEN)
|
import asyncio
from datetime import datetime
import traceback
from discord.channel import TextChannel
from discord.colour import Color
from discord.embeds import Embed
from discord.ext import commands
import discord
from discord.ext.commands.context import Context
from discord.guild import Guild
from discord.member import Member
from discord.message import Message
from discord.permissions import PermissionOverwrite
from discord.role import Role
import requests
import pymp4parse
import helpers
from loguru import logger
db_file = "servers.json"
class Moderation(commands.Cog):
def __init__(self, bot: commands.Bot) -> None:
self.bot = bot
@commands.Cog.listener()
async def on_message(self, msg: Message):
if msg.author == self.bot.user:
return
try:
channel: discord.TextChannel = msg.channel
msg_guild: Guild = msg.guild
print("message's guild's id: {}".format(msg_guild.id))
msg_guild_id = msg_guild.id
guilds = helpers.load_guilds()
configs: dict = guilds.get(str(msg_guild_id), {})
if len(configs) == 0:
print("configs not set!")
return
if not bool(configs["crash protection"]):
print("crash protection is off (false)")
return
caution_list = list(configs["caution list"])
log_channel_id = int(configs["logging channel"])
print("logging channel's id: {}".format(log_channel_id))
time = datetime.now()
time = "{}:{}:{}".format(time.hour, time.minute, time.second)
print("at {} from {} in {}:\n {}".format(time, msg.author,
channel.name, msg.content))
flagged = False
messageid = msg.id
await asyncio.sleep(0.9)
try:
msg = await channel.fetch_message(messageid)
except discord.errors.NotFound:
return
embeds: list[Embed] = msg.embeds
print("embeds:\n {}".format(str(embeds)))
for embed in embeds:
print(embed.video.url)
url: str = embed.video.url
if type(url) != str:
print("empty embed")
continue
for domain in caution_list:
if url.find(domain) != -1:
flagged = True
break
print(flagged)
if not flagged:
return
r = requests.get(url, allow_redirects=True)
with open('subject.mp4', 'wb') as f:
f.write(r.content)
f.close()
boxes = pymp4parse.F4VParser.parse(filename='subject.mp4')
mdat = False
for box in boxes:
dtype = box.type
if dtype == 'mdat':
mdat = True
elif mdat:
await msg.delete()
await channel.send("DO NOT SEND CRASH GIFS <@!{}>!".format(msg.author.id))
log_channel: TextChannel = msg_guild.get_channel(log_channel_id)
embed = Embed(title="Crash gif caught and handled in {}".format(channel.name),
color=Color.red())
embed.add_field(name="Message author and channel",
value="{} in {}".format(msg.author.mention, channel.mention))
embed.add_field(name="Message content", value=msg.content, inline=False)
embed.add_field(name="url to malicious file", value=url, inline=False)
await log_channel.send(embed=embed)
break
except Exception:
log_channel: TextChannel = msg_guild.get_channel(log_channel_id)
await log_channel.send("``an error occurred.``")
traceback.print_exc()
@commands.command(name='toggle', help='toggles crash gif protection')
@logger.catch
async def toggle(self, ctx: commands.Context):
auth: discord.Member = ctx.author
if not helpers.is_authorized(auth):
await ctx.send("you do not have permission for this command.")
return
try:
msg_guild: Guild = ctx.guild
msg_guild_id = msg_guild.id
guilds = helpers.load_guilds()
configs: dict = guilds.get(str(msg_guild_id), {})
if len(configs) == 0:
await ctx.send("Please run 'Setup' command and try again")
return
if configs["crash protection"]:
guilds[str(msg_guild_id)]["crash protection"] = False
helpers.save_guilds(guilds)
await ctx.send("Crash gif protection disabled!")
return
guilds[str(msg_guild_id)]["crash protection"] = True
helpers.save_guilds(guilds)
await ctx.send("Crash gif protection enabled!")
except Exception:
await ctx.send("``an error occurred.``")
traceback.print_exc()
class Util(commands.Cog):
def __init__(self, bot: commands.Bot) -> None:
self.bot = bot
@commands.command(name='setup',
help='perform quick server config for the bot (specify logging server if applicable)')
@logger.catch
async def setup(self, ctx: Context, *args):
auth: Member = ctx.author
if not helpers.is_authorized(auth):
await ctx.send("you do not have permission for this command")
return
try:
msg_guild: Guild = ctx.guild
msg_guild_id = msg_guild.id
guilds = helpers.load_guilds()
configs: dict = guilds.get(str(msg_guild_id), {})
if len(configs) != 0:
await ctx.send("I am already configured for this server!")
return
configs["crash protection"] = True
configs["caution list"] = ["gfycat.com"]
if len(args) > 0:
logging_channel_name = str(args[0])
channels = msg_guild.text_channels
logging_channel: TextChannel = None
found = False
for channel in channels:
if channel.name == logging_channel_name:
logging_channel = channel
found = True
break
if not found:
await ctx.send("Channel ``{}`` not found! Configuration aborted.".format(logging_channel_name))
return
configs["logging channel"] = str(logging_channel.id)
else:
msg_guild_roles: list[Role] = msg_guild.roles
overwrites = {}
for role in msg_guild_roles:
if role.permissions.view_audit_log:
overwrites[role] = PermissionOverwrite(read_messages=True,
send_messages=True)
else:
overwrites[role] = PermissionOverwrite(read_messages=False,
send_messages=False)
overwrites[msg_guild.me] = PermissionOverwrite(read_messages=True,
send_messages=True)
logging_channel: TextChannel = await msg_guild.create_text_channel(name='sys-log',
reason="log channel was not specified at 'setup' command call",
overwrites=overwrites)
configs["logging channel"] = str(logging_channel.id)
guilds[str(msg_guild_id)] = configs
helpers.save_guilds(guilds)
await ctx.send("Setup success! I am now ready for use in ``{}``".format(msg_guild.name))
except Exception:
traceback.print_exc()
await ctx.send("``an error occured.``")
@commands.command(name='setlog', help='set logging channel for the bot')
@logger.catch
async def setlog(self, ctx: Context, *args):
auth: Member = ctx.author
if not helpers.is_authorized(auth):
await ctx.send("You do not have permission for this command.")
return
if len(args) < 1:
await ctx.send("Please specify a channel by name and try again!")
return
try:
guilds = helpers.load_guilds()
msg_guild: Guild = ctx.guild
msg_guild_id = msg_guild.id
configs: dict = guilds.get(str(msg_guild_id), {})
if len(configs) == 0:
await ctx.send("Run 'setup' and try again!")
return
logging_channel_name = str(args[0])
logging_channel: TextChannel = None
found = False
msg_guild_channels: list[TextChannel] = msg_guild.channels
for channel in msg_guild_channels:
if channel.name == logging_channel_name:
logging_channel = channel
found = True
break
if not found:
await ctx.send("Channel ``{}`` not found.".format(logging_channel_name))
return
configs["logging channel"] = str(logging_channel.id)
guilds[str(msg_guild_id)] = configs
helpers.save_guilds(guilds)
await ctx.send("Successfully set logging channel to {}!".format(logging_channel.mention))
except Exception:
await ctx.send("``an error occured.``")
traceback.print_exc()
@commands.command(name='add', help='add a domain to the risk list')
@logger.catch
async def add(self, ctx: Context, *args):
auth: Member = ctx.author
if not helpers.is_authorized(auth):
await ctx.send("You do not have permission for this command.")
return
if len(args) < 1:
await ctx.send("please specify a domain name and try again")
return
try:
guilds = helpers.load_guilds()
msg_guild: Guild = ctx.guild
msg_guild_id = msg_guild.id
configs: dict = guilds.get(str(msg_guild_id), {})
if len(configs) == 0:
await ctx.send("Please run 'setup' command and try again")
return
caution_list: list[str] = list(configs["caution list"])
new_domain = str(args[0]).strip()
if caution_list.count(new_domain) > 0:
await ctx.send("Domain is already in list!")
return
caution_list.append(new_domain)
configs["caution list"] = caution_list
guilds[str(msg_guild_id)] = configs
helpers.save_guilds(guilds)
await ctx.send("Succesfully added ``{}`` to the risk list!".format(new_domain))
except Exception:
await ctx.send("``an error occurred.``")
traceback.print_exc()
@commands.command(name='remove', help='remove a domain from the risk list')
@logger.catch
async def remove(self, ctx: Context, *args):
auth: Member = ctx.author
if not helpers.is_authorized(auth):
await ctx.send("You do not have permission for this command")
return
if len(args) == 0:
await ctx.send("Please specify a domain and try again")
return
try:
guilds = helpers.load_guilds()
msg_guild: Guild = ctx.guild
msg_guild_id = msg_guild.id
configs: dict = guilds.get(str(msg_guild_id), {})
if len(configs) == 0:
await ctx.send("Please run 'setup' and try again")
return
caution_list: list[str] = configs["caution list"]
target = str(args[0])
try:
caution_list.remove(target)
await ctx.send("Succesfully removed ``{}`` from the risk list!".format(target))
except Exception:
await ctx.send("domain ``{}`` not found in risk list".format(target))
return
configs["caution list"] = caution_list
guilds[str(msg_guild_id)] = configs
helpers.save_guilds(guilds)
except Exception:
await ctx.send("``an error occurred.``")
traceback.print_exc()
@commands.Cog.listener()
@logger.catch
async def on_guild_remove(self, guild: Guild):
helpers.remove_guild(guild)
|
{
"imports": [
"/cogs.py"
]
}
|
0-GEE/SYSTER
|
refs/heads/main
|
/cogs.py
|
import asyncio
from datetime import datetime
import traceback
from discord.channel import TextChannel
from discord.colour import Color
from discord.embeds import Embed
from discord.ext import commands
import discord
from discord.ext.commands.context import Context
from discord.guild import Guild
from discord.member import Member
from discord.message import Message
from discord.permissions import PermissionOverwrite
from discord.role import Role
import requests
import pymp4parse
import helpers
from loguru import logger
db_file = "servers.json"
class Moderation(commands.Cog):
def __init__(self, bot: commands.Bot) -> None:
self.bot = bot
@commands.Cog.listener()
async def on_message(self, msg: Message):
if msg.author == self.bot.user:
return
try:
channel: discord.TextChannel = msg.channel
msg_guild: Guild = msg.guild
print("message's guild's id: {}".format(msg_guild.id))
msg_guild_id = msg_guild.id
guilds = helpers.load_guilds()
configs: dict = guilds.get(str(msg_guild_id), {})
if len(configs) == 0:
print("configs not set!")
return
if not bool(configs["crash protection"]):
print("crash protection is off (false)")
return
caution_list = list(configs["caution list"])
log_channel_id = int(configs["logging channel"])
print("logging channel's id: {}".format(log_channel_id))
time = datetime.now()
time = "{}:{}:{}".format(time.hour, time.minute, time.second)
print("at {} from {} in {}:\n {}".format(time, msg.author,
channel.name, msg.content))
flagged = False
messageid = msg.id
await asyncio.sleep(0.9)
try:
msg = await channel.fetch_message(messageid)
except discord.errors.NotFound:
return
embeds: list[Embed] = msg.embeds
print("embeds:\n {}".format(str(embeds)))
for embed in embeds:
print(embed.video.url)
url: str = embed.video.url
if type(url) != str:
print("empty embed")
continue
for domain in caution_list:
if url.find(domain) != -1:
flagged = True
break
print(flagged)
if not flagged:
return
r = requests.get(url, allow_redirects=True)
with open('subject.mp4', 'wb') as f:
f.write(r.content)
f.close()
boxes = pymp4parse.F4VParser.parse(filename='subject.mp4')
mdat = False
for box in boxes:
dtype = box.type
if dtype == 'mdat':
mdat = True
elif mdat:
await msg.delete()
await channel.send("DO NOT SEND CRASH GIFS <@!{}>!".format(msg.author.id))
log_channel: TextChannel = msg_guild.get_channel(log_channel_id)
embed = Embed(title="Crash gif caught and handled in {}".format(channel.name),
color=Color.red())
embed.add_field(name="Message author and channel",
value="{} in {}".format(msg.author.mention, channel.mention))
embed.add_field(name="Message content", value=msg.content, inline=False)
embed.add_field(name="url to malicious file", value=url, inline=False)
await log_channel.send(embed=embed)
break
except Exception:
log_channel: TextChannel = msg_guild.get_channel(log_channel_id)
await log_channel.send("``an error occurred.``")
traceback.print_exc()
@commands.command(name='toggle', help='toggles crash gif protection')
@logger.catch
async def toggle(self, ctx: commands.Context):
auth: discord.Member = ctx.author
if not helpers.is_authorized(auth):
await ctx.send("you do not have permission for this command.")
return
try:
msg_guild: Guild = ctx.guild
msg_guild_id = msg_guild.id
guilds = helpers.load_guilds()
configs: dict = guilds.get(str(msg_guild_id), {})
if len(configs) == 0:
await ctx.send("Please run 'Setup' command and try again")
return
if configs["crash protection"]:
guilds[str(msg_guild_id)]["crash protection"] = False
helpers.save_guilds(guilds)
await ctx.send("Crash gif protection disabled!")
return
guilds[str(msg_guild_id)]["crash protection"] = True
helpers.save_guilds(guilds)
await ctx.send("Crash gif protection enabled!")
except Exception:
await ctx.send("``an error occurred.``")
traceback.print_exc()
class Util(commands.Cog):
def __init__(self, bot: commands.Bot) -> None:
self.bot = bot
@commands.command(name='setup',
help='perform quick server config for the bot (specify logging server if applicable)')
@logger.catch
async def setup(self, ctx: Context, *args):
auth: Member = ctx.author
if not helpers.is_authorized(auth):
await ctx.send("you do not have permission for this command")
return
try:
msg_guild: Guild = ctx.guild
msg_guild_id = msg_guild.id
guilds = helpers.load_guilds()
configs: dict = guilds.get(str(msg_guild_id), {})
if len(configs) != 0:
await ctx.send("I am already configured for this server!")
return
configs["crash protection"] = True
configs["caution list"] = ["gfycat.com"]
if len(args) > 0:
logging_channel_name = str(args[0])
channels = msg_guild.text_channels
logging_channel: TextChannel = None
found = False
for channel in channels:
if channel.name == logging_channel_name:
logging_channel = channel
found = True
break
if not found:
await ctx.send("Channel ``{}`` not found! Configuration aborted.".format(logging_channel_name))
return
configs["logging channel"] = str(logging_channel.id)
else:
msg_guild_roles: list[Role] = msg_guild.roles
overwrites = {}
for role in msg_guild_roles:
if role.permissions.view_audit_log:
overwrites[role] = PermissionOverwrite(read_messages=True,
send_messages=True)
else:
overwrites[role] = PermissionOverwrite(read_messages=False,
send_messages=False)
overwrites[msg_guild.me] = PermissionOverwrite(read_messages=True,
send_messages=True)
logging_channel: TextChannel = await msg_guild.create_text_channel(name='sys-log',
reason="log channel was not specified at 'setup' command call",
overwrites=overwrites)
configs["logging channel"] = str(logging_channel.id)
guilds[str(msg_guild_id)] = configs
helpers.save_guilds(guilds)
await ctx.send("Setup success! I am now ready for use in ``{}``".format(msg_guild.name))
except Exception:
traceback.print_exc()
await ctx.send("``an error occured.``")
@commands.command(name='setlog', help='set logging channel for the bot')
@logger.catch
async def setlog(self, ctx: Context, *args):
auth: Member = ctx.author
if not helpers.is_authorized(auth):
await ctx.send("You do not have permission for this command.")
return
if len(args) < 1:
await ctx.send("Please specify a channel by name and try again!")
return
try:
guilds = helpers.load_guilds()
msg_guild: Guild = ctx.guild
msg_guild_id = msg_guild.id
configs: dict = guilds.get(str(msg_guild_id), {})
if len(configs) == 0:
await ctx.send("Run 'setup' and try again!")
return
logging_channel_name = str(args[0])
logging_channel: TextChannel = None
found = False
msg_guild_channels: list[TextChannel] = msg_guild.channels
for channel in msg_guild_channels:
if channel.name == logging_channel_name:
logging_channel = channel
found = True
break
if not found:
await ctx.send("Channel ``{}`` not found.".format(logging_channel_name))
return
configs["logging channel"] = str(logging_channel.id)
guilds[str(msg_guild_id)] = configs
helpers.save_guilds(guilds)
await ctx.send("Successfully set logging channel to {}!".format(logging_channel.mention))
except Exception:
await ctx.send("``an error occured.``")
traceback.print_exc()
@commands.command(name='add', help='add a domain to the risk list')
@logger.catch
async def add(self, ctx: Context, *args):
auth: Member = ctx.author
if not helpers.is_authorized(auth):
await ctx.send("You do not have permission for this command.")
return
if len(args) < 1:
await ctx.send("please specify a domain name and try again")
return
try:
guilds = helpers.load_guilds()
msg_guild: Guild = ctx.guild
msg_guild_id = msg_guild.id
configs: dict = guilds.get(str(msg_guild_id), {})
if len(configs) == 0:
await ctx.send("Please run 'setup' command and try again")
return
caution_list: list[str] = list(configs["caution list"])
new_domain = str(args[0]).strip()
if caution_list.count(new_domain) > 0:
await ctx.send("Domain is already in list!")
return
caution_list.append(new_domain)
configs["caution list"] = caution_list
guilds[str(msg_guild_id)] = configs
helpers.save_guilds(guilds)
await ctx.send("Succesfully added ``{}`` to the risk list!".format(new_domain))
except Exception:
await ctx.send("``an error occurred.``")
traceback.print_exc()
@commands.command(name='remove', help='remove a domain from the risk list')
@logger.catch
async def remove(self, ctx: Context, *args):
auth: Member = ctx.author
if not helpers.is_authorized(auth):
await ctx.send("You do not have permission for this command")
return
if len(args) == 0:
await ctx.send("Please specify a domain and try again")
return
try:
guilds = helpers.load_guilds()
msg_guild: Guild = ctx.guild
msg_guild_id = msg_guild.id
configs: dict = guilds.get(str(msg_guild_id), {})
if len(configs) == 0:
await ctx.send("Please run 'setup' and try again")
return
caution_list: list[str] = configs["caution list"]
target = str(args[0])
try:
caution_list.remove(target)
await ctx.send("Succesfully removed ``{}`` from the risk list!".format(target))
except Exception:
await ctx.send("domain ``{}`` not found in risk list".format(target))
return
configs["caution list"] = caution_list
guilds[str(msg_guild_id)] = configs
helpers.save_guilds(guilds)
except Exception:
await ctx.send("``an error occurred.``")
traceback.print_exc()
@commands.Cog.listener()
@logger.catch
async def on_guild_remove(self, guild: Guild):
helpers.remove_guild(guild)
|
import json
from discord.guild import Guild
from discord.member import Member
db_file = "servers.json"
def is_authorized(user: Member):
perms = user.guild_permissions
if perms.view_audit_log:
return True
return False
def load_guilds():
try:
with open(db_file, 'r') as f:
guilds: dict = json.load(f)
f.close()
return guilds
except Exception:
return {}
def save_guilds(guilds: dict):
with open(db_file, 'w') as f:
json.dump(guilds, f, indent=4)
f.close()
def remove_guild(guild: Guild):
guilds = load_guilds()
target_id = str(guild.id)
guilds.pop(target_id)
save_guilds(guilds)
|
{
"imports": [
"/helpers.py"
]
}
|
0-Raigi-0/SPO
|
refs/heads/main
|
/Core.py
|
import re
from Classes import LList, Node, List
class Lex(object):
token = {"ЕСЛИ": "^if$", "ИНАЧЕ": "^else$", "ПОКА": "^while$", "ОПЕРАЦИЯ": "^[-+*/]$", "Л_ОПЕРАЦИЯ": r"^==|>|>=|<|<=|!=$",
"Л_СКОБКА ": "[(]", "П_СКОБКА": "[)]", 'ТОЧКА': r'\.', "Л_ФИГУРНАЯ": "^[{]$",
'С_СПИСОК': r'LList', "П_ФИГУРНАЯ": "^[}]$", "ОПЕРАЦИЯ_П": "^=$",
"КОНЕЦ": "^;$", "ЧИСЛО": r"^0|([1-9][0-9]*)$", "СТРОКА": r"'[^']*'", "ПЕРЕМЕННАЯ": "^[a-zA-Z0-9_]+$", "НЕ_ОПРЕДЕЛЕНО": r".*[^.]*"}
def __init__(s):
s.l_tokens = []
def __set_token(s, item):
for key in s.token.keys():
if re.fullmatch(s.token[key], item):
return key
def get_term(s, file):
with open(file) as f_hand:
buf = ''
l_token = ''
for line in f_hand:
for char in line:
if not len(buf) and char == "'":
buf += char
continue
elif len(buf) and not buf.count("'") == 2:
if buf[0] == "'":
buf += char
continue
if l_token == 'ТОЧКА':
if not char == '(':
buf += char
continue
else:
s.l_tokens.append({'МЕТОД': buf})
buf = ''
l_token = s.__set_token(buf)
buf += char
token = s.__set_token(buf)
if token == "НЕ_ОПРЕДЕЛЕНО":
if len(buf) and not l_token == "НЕ_ОПРЕДЕЛЕНО":
s.l_tokens.append({l_token: buf[:-1]})
if not (buf[-1] == ' ' or buf[-1] == '\n'):
buf = buf[-1]
else:
buf = ''
token = s.__set_token(buf)
if not token == "НЕ_ОПРЕДЕЛЕНО":
s.l_tokens.append({token: buf[0]})
class StM:
pr = {'(': 0, ')': 1, '=': 1, '==': 3, '!=': 3, '>': 4, '>=': 4, '<': 4, '<=': 4, '+': 5, '-': 5, '*': 6, '/': 6,
'cont': 7, 'rm': 7, 'push': 7, 'get': 7}
log_op = ['==', '!=', '>', '>=', '<', '<=']
op = ['+', '-', '*', '/']
list_com = ['cont', 'rm', 'push', 'get']
def __init__(s, inp):
s.stack = []
s.input = inp
s.output = []
s.buf = []
s.bufel = []
s.nl = 0
s.index = -1
s.variables = {}
@staticmethod
def b_log_op(a, b, op):
if op == '>':
return a > b
elif op == '<':
return a < b
elif op == '>=':
return a >= b
elif op == '<=':
return a <= b
elif op == '==':
return a == b
elif op == '!=':
return a != b
@staticmethod
def b_op(a, b, op):
if op == '+':
return a + b
elif op == '-':
return a - b
elif op == '*':
return a * b
elif op == '/':
return a / b
@staticmethod
def methodList(a, b, op):
if op == 'push':
a.push(b)
elif op == 'rm':
a.rm(b)
elif op == 'get':
a.get(b)
elif op == 'cont':
a.cont(b)
def assign(s, a, b):
if re.fullmatch(r"0|([1-9][0-9]*)", str(b)):
s.variables[a] = int(b)
elif b == 'LList':
s.variables[a] = LList()
else:
s.variables[a] = b
def abs(s, item):
if item.name == 'while_expr':
s.buf.append({s.nl: len(s.output)})
if item.name not in Lex.token and not item.name == 'МЕТОД':
for i in item.children:
s.abs(i)
s.stack.reverse()
for y in s.stack:
if not y == '(':
s.output.append(y)
s.stack = []
else:
if item.name == 'ИНАЧЕ':
s.bufel.append(s.nl)
s.output.append('\t')
if item.name == 'П_ФИГУРНАЯ':
s.nl -= 1
if '\n' in s.output:
s.output.reverse()
s.output[s.output.index('\n')] = len(s.output)
s.output.reverse()
if len(s.buf):
if s.nl in list(s.buf[-1].keys()):
s.output.append('!' + str(s.buf[-1][s.nl]))
s.buf.pop(-1)
if item.name == 'Л_ФИГУРНАЯ':
s.nl += 1
if s.nl > 0:
s.output.append('\n')
if len(s.bufel) and not item.name == 'ИНАЧЕ':
if s.nl == s.bufel[-1]:
s.output.reverse()
s.output[s.output.index('\t')] =\
'!' + str(len(s.output))
s.output.reverse()
s.bufel.pop(-1)
if item.name in ['ПЕРЕМЕННАЯ', 'ЧИСЛО', 'ЧИСЛО', 'С_СПИСОК']:
s.output.append(str(item.value))
else:
if not item.value == '':
k = 0
for i in range(len(s.stack) - 1, -1, -1):
k += 1
if item.value == ')':
if not s.stack[i] == '(':
s.output.append(s.stack[i])
else:
break
elif s.pr[item.value] <= s.pr[s.stack[i]] \
and not item.value == '(':
s.output.append(s.stack[i])
else:
break
for j in range(1, k):
s.stack.pop(-j)
if not item.value == ')':
s.stack.append(item.value)
def start(s):
try:
for item in s.input:
s.abs(item)
s.stack = []
print(s.output)
s.compil()
print(s.variables)
except BaseException:
raise BaseException
def compil(s):
k = 0
while k < len(s.output):
if not s.output[k] in list(s.pr.keys()):
if not (str(type(s.output[k])) == "<class 'int'>" or
list(s.output[k])[0] == '!'):
s.stack.append(s.output[k])
k += 1
elif len(s.stack):
if not s.stack[-1] and\
not list(str(s.output[k]))[0] == '!':
if not s.stack[-1]:
if (s.output[k]) < len(s.output):
if isinstance(s.output[s.output[k]],
int):
k = s.output[k] + 1
s.stack.pop(-1)
continue
elif list(str(s.output[s.output[k]]))[0]\
== '!':
k = s.output[k] + 1
s.stack.pop(-1)
continue
else:
k = s.output[k]
s.stack.pop(-1)
continue
else:
k = s.output[k] + 1
s.stack.pop(-1)
continue
elif list(str(s.output[k]))[0] == '!':
k = s.output[k]
continue
else:
s.stack.pop(-1)
elif list(str(s.output[k]))[0] == '!':
k = int(str(s.output[k])[1:])
continue
else:
k += 1
else:
b = s.stack.pop(-1)
a = s.stack.pop(-1)
op = s.output[k]
k += 1
if op == '=':
s.assign(a, b)
elif op in s.log_op:
s.stack.append(s.b_log_op(s.variables[a],
s.variables[b], op))
elif op in s.op:
if not re.fullmatch(r"0|([1-9][0-9]*)", a):
a = s.variables[a]
else:
a = int(a)
if not re.fullmatch(r"0|([1-9][0-9]*)", b):
b = int(s.variables[b])
else:
b = int(b)
s.stack.append(s.b_op(a, b, op))
elif op in s.list_com:
s.stack.append(s.methodList(s.variables[a], b, op))
class Par:
def __init__(s, Lex):
s.height = 0
s.i = 0
s.start = Lex
s.LB = 0
def S(s):
S = Node('S')
while s.i < len(s.start) - 1:
s.height = 1
expr = s.expr()
if expr is not None:
S.children.append(expr)
s.i += 1
return S
def expr(s):
try:
expr = Node('expr', height=s.height)
s.height += 1
token = list(s.start[s.i].keys())[0]
if token == "ПЕРЕМЕННАЯ":
try:
assign_expr = s.assign_expr()
expr.children.append(assign_expr)
s.height -= 1
return expr
except BaseException:
expr.children.append(List(list(s.start[s.i].keys())[0], list(s.start[s.i].values())[0],
s.height))
s.check_next('ТОЧКА')
s.i += 1
method = s.method()
expr.children.append(method)
return expr
elif token == 'ПОКА':
while_expr = s.while_expr()
expr.children.append(while_expr)
s.height -= 1
return expr
elif token == 'ЕСЛИ':
if_expr = s.if_expr()
expr.children.append(if_expr)
s.height -= 1
return expr
else:
return None
except BaseException:
raise BaseException
def method(s):
method = Node('method', height=s.height)
s.height += 1
s.check_next('МЕТОД')
s.i += 1
method.children.append(List(name=list(s.start[s.i].keys())[0], value=list(s.start[s.i].values())[0],
height=s.height))
s.height += 1
s.check_next('Л_СКОБКА ')
s.i += 1
method.children.append(List(name=list(s.start[s.i].keys())[0], value=list(s.start[s.i].values())[0],
height=s.height))
math_expr = s.math_expr()
method.children.append(math_expr)
if not list(s.start[s.i].keys())[0] == 'КОНЕЦ':
raise BaseException
return method
def if_expr(s):
height = s.height
if_expr = Node('if_expr', height=s.height)
s.height += 1
start_height = s.height
s.check_next('Л_СКОБКА ')
if_expr.children.append(List('Л_СКОБКА ', '(', height=s.height))
s.i += 2
s.height += 1
token = list(s.start[s.i].keys())[0]
if token == 'ПЕРЕМЕННАЯ' or token == 'ЧИСЛО' or token == 'Л_СКОБКА ':
math_logic = s.math_logic(ht=[start_height])
if_expr.children.append(math_logic)
s.height = start_height
s.check_next('Л_ФИГУРНАЯ')
if_expr.children.append(Node('Л_ФИГУРНАЯ', height=start_height))
s.i += 1
num_L = 1
while num_L:
if list(s.start[s.i].keys())[0] == 'П_ФИГУРНАЯ':
num_L -= 1
if list(s.start[s.i].keys())[0] == 'Л_ФИГУРНАЯ':
num_L += 1
if num_L:
s.i += 1
s.height = start_height
s.height += 1
if list(s.start[s.i].keys())[0] == 'Л_ФИГУРНАЯ':
num_L += 1
if list(s.start[s.i].keys())[0] == 'П_ФИГУРНАЯ':
num_L -= 1
break
expr = s.expr()
if expr is not None:
if_expr.children.append(expr)
if_expr.children.append(Node('П_ФИГУРНАЯ', height=start_height))
if s.i < len(s.start) - 1:
s.check_next('ИНАЧЕ')
s.i += 1
s.check_next('Л_ФИГУРНАЯ')
s.height = height
if_expr.children.append(Node('ИНАЧЕ', height=s.height))
s.height += 1
start_height = s.height
if_expr.children.append(Node('Л_ФИГУРНАЯ', height=s.height))
num_L = 1
while num_L:
if list(s.start[s.i].keys())[0] == 'П_ФИГУРНАЯ':
num_L -= 1
if list(s.start[s.i].keys())[0] == 'Л_ФИГУРНАЯ':
num_L += 1
if num_L:
s.i += 1
s.height = start_height
s.height += 1
if list(s.start[s.i].keys())[0] == 'Л_ФИГУРНАЯ':
num_L += 1
if list(s.start[s.i].keys())[0] == 'П_ФИГУРНАЯ':
num_L -= 1
break
expr = s.expr()
if expr is not None:
if_expr.children.append(expr)
if_expr.children.append(Node('П_ФИГУРНАЯ', height=start_height))
return if_expr
def while_expr(s):
while_expr = Node('while_expr', height=s.height)
s.height += 1
start_height = s.height
s.check_next('Л_СКОБКА ')
while_expr.children.append(List('Л_СКОБКА ', '(', height=s.height))
s.i += 2
s.height += 1
token = list(s.start[s.i].keys())[0]
if token == 'ПЕРЕМЕННАЯ' or token == 'ЧИСЛО' or token == 'Л_СКОБКА ':
math_logic = s.math_logic(ht=[start_height])
while_expr.children.append(math_logic)
s.height = start_height
s.check_next('Л_ФИГУРНАЯ')
s.i += 1
while_expr.children.append(Node('Л_ФИГУРНАЯ', height=s.height))
num_L = 1
while num_L:
if list(s.start[s.i].keys())[0] == 'П_ФИГУРНАЯ':
num_L -= 1
if list(s.start[s.i].keys())[0] == 'Л_ФИГУРНАЯ':
num_L += 1
if num_L:
s.i += 1
s.height = start_height
s.height += 1
if list(s.start[s.i].keys())[0] == 'Л_ФИГУРНАЯ':
num_L += 1
if list(s.start[s.i].keys())[0] == 'П_ФИГУРНАЯ':
num_L -= 1
break
expr = s.expr()
if expr is not None:
while_expr.children.append(expr)
while_expr.children.append(Node('П_ФИГУРНАЯ', height=start_height))
return while_expr
else:
raise BaseException
def math_logic(s, ht=[]):
token = list(s.start[s.i].keys())[0]
if not token == 'П_СКОБКА' or not token == 'Л_ОПЕРАЦИЯ' \
or not token == 'ОПЕРАЦИЯ':
math_logic = Node('math_logic', height=s.height)
else:
math_logic = ''
s.height += 1
if token == 'Л_СКОБКА ':
ht.append(s.height)
LBreaket = s.LBreaket()
math_logic.children.append(LBreaket)
elif token == 'П_СКОБКА':
s.height = ht.pop(-1)
math_logic = Node('П_СКОБКА', height=s.height)
elif token == 'ЧИСЛО':
math_logic.children.append(List(list(s.start[s.i].keys())[0],
list(s.start[s.i].
values())[0],
s.height))
if s.i + 1 < len(s.start):
if list(s.start[s.i + 1].keys())[0] == 'Л_ОПЕРАЦИЯ':
s.i += 1
math_logic.children.append(List(list(s.start[s.i].
keys())[0],
list(s.start[s.i].
values())[0],
s.height))
elif list(s.start[s.i + 1].keys())[0] == 'ОПЕРАЦИЯ':
s.i += 1
math_logic.children.append(List(list(s.start[s.i].
keys())[0],
list(s.start[s.i].
values())[0],
s.height))
elif token == 'ПЕРЕМЕННАЯ':
math_logic.children.append(List(list(s.start[s.i].keys())[0],
list(s.start[s.i].
values())[0],
s.height))
if s.i + 1 < len(s.start):
if list(s.start[s.i + 1].keys())[0] == 'Л_ОПЕРАЦИЯ':
s.i += 1
math_logic.children.append(List(list(s.start[s.i].
keys())[0],
list(s.start[s.i].
values())[0],
s.height))
elif list(s.start[s.i + 1].keys())[0] == 'ОПЕРАЦИЯ':
s.i += 1
math_logic.children.append(List(list(s.start[s.i].
keys())[0],
list(s.start[s.i].
values())[0],
s.height))
elif token == 'Л_ОПЕРАЦИЯ':
s.height -= 1
math_logic = Node('Л_ОПЕРАЦИЯ' +
list(s.start[s.i].values())[0],
height=s.height)
elif token == 'ОПЕРАЦИЯ':
s.height -= 1
math_logic = Node('ОПЕРАЦИЯ' + list(s.start[s.i].values())[0],
height=s.height)
elif not token == 'КОНЕЦ':
raise BaseException
if len(ht):
s.i += 1
me = s.math_logic(ht)
math_logic.children.append(me)
return math_logic
def check_next(s, values):
token = list(s.start[s.i + 1].keys())[0]
if not token == values:
raise BaseException
def assign_expr(s):
assign_expr = Node('Н_ВЫРАЖ', '=', s.height)
s.check_next("ОПЕРАЦИЯ_П")
s.height += 1
assign_expr.children.append(List(list(s.start[s.i].keys())[0],
list(s.start[s.i].
values())[0], s.height))
s.i += 1
assign_expr.children.append(List(list(s.start[s.i].keys())[0],
list(s.start[s.i].
values())[0], s.height))
s.height -= 1
s.i += 1
token = list(s.start[s.i].keys())[0]
if token == 'СТРОКА':
s.height += 1
assign_expr.children.append(List('СТРОКА', list(s.start[s.i].
values())[0],
s.height))
s.check_next('КОНЕЦ')
s.i += 1
elif token == 'ЧИСЛО' or token == 'Л_СКОБКА ' or token == 'ПЕРЕМЕННАЯ':
s.height += 1
math_expr = s.math_expr()
assign_expr.children.append(math_expr)
elif token == 'С_СПИСОК':
s.height += 1
assign_expr.children.append(List('С_СПИСОК', list(s.start[s.i].values())[0], s.height))
return assign_expr
def math_expr(s, ht=[]):
token = list(s.start[s.i].keys())[0]
if not token == 'П_СКОБКА' or not token == 'ОПЕРАЦИЯ' or not token == 'ТОЧКА':
math_expr = Node('math_expr', height=s.height)
else:
math_expr = ''
s.height += 1
if token == 'Л_СКОБКА ':
ht.append(s.height)
LBreaket = s.LBreaket()
math_expr.children.append(LBreaket)
elif token == 'П_СКОБКА':
s.LB -= 1
s.height = ht.pop(-1)
if s.LB < 0:
raise BaseException
math_expr = Node('П_СКОБКА', value=')', height=s.height)
elif token == 'ЧИСЛО':
math_expr.children.append(List(list(s.start[s.i].keys())[0],
list(s.start[s.i].
values())[0],
s.height))
if s.i + 1 < len(s.start):
if list(s.start[s.i + 1].keys())[0] == 'ОПЕРАЦИЯ':
s.i += 1
math_expr.children.append(List(list(s.start[s.i].
keys())[0],
list(s.start[s.i].
values())[0],
s.height))
elif token == 'ОПЕРАЦИЯ':
s.height -= 1
math_expr = Node('ОПЕРАЦИЯ' + list(s.start[s.i].values())[0],
height=s.height)
elif token == 'ПЕРЕМЕННАЯ':
math_expr.children.append(List(list(s.start[s.i].keys())[0],
list(s.start[s.i].
values())[0],
s.height))
if s.i + 1 < len(s.start):
if list(s.start[s.i + 1].keys())[0] == 'ОПЕРАЦИЯ':
s.i += 1
math_expr.children.append(List(list(s.start[s.i].
keys())[0],
list(s.start[s.i].
values())[0],
s.height))
elif token == 'ТОЧКА':
math_expr = s.method()
s.i -= 1
elif not token == 'КОНЕЦ':
raise BaseException
s.i += 1
if not list(s.start[s.i].keys())[0] == 'КОНЕЦ':
me = s.math_expr(ht)
math_expr.children.append(me)
return math_expr
def LBreaket(s):
s.LB += 1
LBreaket = List('Л_СКОБКА ', '(', height=s.height)
return LBreaket
|
class Item:
def __init__(s, value=None):
s.value = value
s.nextValue = None
class LList:
def __init__(s):
s.head = None
def __repr__(s):
cur = s.head
sk = '[ '
while cur is not None:
sk += f'{cur.value},'
cur = cur.nextValue
sk += ']'
return sk
def cont(s, value):
LIm = s.head
while LIm:
if value == LIm.value:
return True
else:
LIm = LIm.nextValue
return False
def push(s, newValue):
NIm = Item(newValue)
if s.head is None:
s.head = NIm
return
LIm = s.head
while LIm.nextValue:
LIm = LIm.nextValue
LIm.nextValue = NIm
def get(s, ImIx):
LIm = s.head
BIx = 0
while BIx <= ImIx:
if BIx == ImIx:
return LIm.cat
BIx = BIx + 1
LIm = LIm.nextValue
def rm(s, rmValue):
HIm = s.head
if HIm is not None:
if HIm.value == rmValue:
s.head = HIm.nextValue
return
while HIm is not None:
if HIm.value == rmValue:
break
LIm = HIm
HIm = HIm.nextValue
if HIm is None:
return
LIm.nextValue = HIm.nextValue
class Node:
def __init__(s, name='', value='', height=0):
s.children = []
s.name = name
s.value = value
s.height = height
s.buffer = []
def __repr__(s):
str_end = ''
for child in s.children:
str_end += "\t" * child.height + f'{child}'
return f'{s.name}\n{str_end}'
class List:
def __init__(s, name='', value='', height=0):
s.name = name
s.value = value
s.height = height
def __repr__(s):
return f'{s.name} {s.value}\n'
|
{
"imports": [
"/Classes.py"
]
}
|
0-Raigi-0/SPO
|
refs/heads/main
|
/main.py
|
from Core import Lex, StM, Par
if __name__ == '__main__':
L = Lex()
L.get_term('code.txt')
print('Tokens:', L.l_tokens)
try:
P = Par(L.l_tokens)
Tree = P.S()
print('Tree:\n', Tree)
StM = StM(Tree.children)
StM.start()
except BaseException:
print('Syntax error')
|
import re
from Classes import LList, Node, List
class Lex(object):
token = {"ЕСЛИ": "^if$", "ИНАЧЕ": "^else$", "ПОКА": "^while$", "ОПЕРАЦИЯ": "^[-+*/]$", "Л_ОПЕРАЦИЯ": r"^==|>|>=|<|<=|!=$",
"Л_СКОБКА ": "[(]", "П_СКОБКА": "[)]", 'ТОЧКА': r'\.', "Л_ФИГУРНАЯ": "^[{]$",
'С_СПИСОК': r'LList', "П_ФИГУРНАЯ": "^[}]$", "ОПЕРАЦИЯ_П": "^=$",
"КОНЕЦ": "^;$", "ЧИСЛО": r"^0|([1-9][0-9]*)$", "СТРОКА": r"'[^']*'", "ПЕРЕМЕННАЯ": "^[a-zA-Z0-9_]+$", "НЕ_ОПРЕДЕЛЕНО": r".*[^.]*"}
def __init__(s):
s.l_tokens = []
def __set_token(s, item):
for key in s.token.keys():
if re.fullmatch(s.token[key], item):
return key
def get_term(s, file):
with open(file) as f_hand:
buf = ''
l_token = ''
for line in f_hand:
for char in line:
if not len(buf) and char == "'":
buf += char
continue
elif len(buf) and not buf.count("'") == 2:
if buf[0] == "'":
buf += char
continue
if l_token == 'ТОЧКА':
if not char == '(':
buf += char
continue
else:
s.l_tokens.append({'МЕТОД': buf})
buf = ''
l_token = s.__set_token(buf)
buf += char
token = s.__set_token(buf)
if token == "НЕ_ОПРЕДЕЛЕНО":
if len(buf) and not l_token == "НЕ_ОПРЕДЕЛЕНО":
s.l_tokens.append({l_token: buf[:-1]})
if not (buf[-1] == ' ' or buf[-1] == '\n'):
buf = buf[-1]
else:
buf = ''
token = s.__set_token(buf)
if not token == "НЕ_ОПРЕДЕЛЕНО":
s.l_tokens.append({token: buf[0]})
class StM:
pr = {'(': 0, ')': 1, '=': 1, '==': 3, '!=': 3, '>': 4, '>=': 4, '<': 4, '<=': 4, '+': 5, '-': 5, '*': 6, '/': 6,
'cont': 7, 'rm': 7, 'push': 7, 'get': 7}
log_op = ['==', '!=', '>', '>=', '<', '<=']
op = ['+', '-', '*', '/']
list_com = ['cont', 'rm', 'push', 'get']
def __init__(s, inp):
s.stack = []
s.input = inp
s.output = []
s.buf = []
s.bufel = []
s.nl = 0
s.index = -1
s.variables = {}
@staticmethod
def b_log_op(a, b, op):
if op == '>':
return a > b
elif op == '<':
return a < b
elif op == '>=':
return a >= b
elif op == '<=':
return a <= b
elif op == '==':
return a == b
elif op == '!=':
return a != b
@staticmethod
def b_op(a, b, op):
if op == '+':
return a + b
elif op == '-':
return a - b
elif op == '*':
return a * b
elif op == '/':
return a / b
@staticmethod
def methodList(a, b, op):
if op == 'push':
a.push(b)
elif op == 'rm':
a.rm(b)
elif op == 'get':
a.get(b)
elif op == 'cont':
a.cont(b)
def assign(s, a, b):
if re.fullmatch(r"0|([1-9][0-9]*)", str(b)):
s.variables[a] = int(b)
elif b == 'LList':
s.variables[a] = LList()
else:
s.variables[a] = b
def abs(s, item):
if item.name == 'while_expr':
s.buf.append({s.nl: len(s.output)})
if item.name not in Lex.token and not item.name == 'МЕТОД':
for i in item.children:
s.abs(i)
s.stack.reverse()
for y in s.stack:
if not y == '(':
s.output.append(y)
s.stack = []
else:
if item.name == 'ИНАЧЕ':
s.bufel.append(s.nl)
s.output.append('\t')
if item.name == 'П_ФИГУРНАЯ':
s.nl -= 1
if '\n' in s.output:
s.output.reverse()
s.output[s.output.index('\n')] = len(s.output)
s.output.reverse()
if len(s.buf):
if s.nl in list(s.buf[-1].keys()):
s.output.append('!' + str(s.buf[-1][s.nl]))
s.buf.pop(-1)
if item.name == 'Л_ФИГУРНАЯ':
s.nl += 1
if s.nl > 0:
s.output.append('\n')
if len(s.bufel) and not item.name == 'ИНАЧЕ':
if s.nl == s.bufel[-1]:
s.output.reverse()
s.output[s.output.index('\t')] =\
'!' + str(len(s.output))
s.output.reverse()
s.bufel.pop(-1)
if item.name in ['ПЕРЕМЕННАЯ', 'ЧИСЛО', 'ЧИСЛО', 'С_СПИСОК']:
s.output.append(str(item.value))
else:
if not item.value == '':
k = 0
for i in range(len(s.stack) - 1, -1, -1):
k += 1
if item.value == ')':
if not s.stack[i] == '(':
s.output.append(s.stack[i])
else:
break
elif s.pr[item.value] <= s.pr[s.stack[i]] \
and not item.value == '(':
s.output.append(s.stack[i])
else:
break
for j in range(1, k):
s.stack.pop(-j)
if not item.value == ')':
s.stack.append(item.value)
def start(s):
try:
for item in s.input:
s.abs(item)
s.stack = []
print(s.output)
s.compil()
print(s.variables)
except BaseException:
raise BaseException
def compil(s):
k = 0
while k < len(s.output):
if not s.output[k] in list(s.pr.keys()):
if not (str(type(s.output[k])) == "<class 'int'>" or
list(s.output[k])[0] == '!'):
s.stack.append(s.output[k])
k += 1
elif len(s.stack):
if not s.stack[-1] and\
not list(str(s.output[k]))[0] == '!':
if not s.stack[-1]:
if (s.output[k]) < len(s.output):
if isinstance(s.output[s.output[k]],
int):
k = s.output[k] + 1
s.stack.pop(-1)
continue
elif list(str(s.output[s.output[k]]))[0]\
== '!':
k = s.output[k] + 1
s.stack.pop(-1)
continue
else:
k = s.output[k]
s.stack.pop(-1)
continue
else:
k = s.output[k] + 1
s.stack.pop(-1)
continue
elif list(str(s.output[k]))[0] == '!':
k = s.output[k]
continue
else:
s.stack.pop(-1)
elif list(str(s.output[k]))[0] == '!':
k = int(str(s.output[k])[1:])
continue
else:
k += 1
else:
b = s.stack.pop(-1)
a = s.stack.pop(-1)
op = s.output[k]
k += 1
if op == '=':
s.assign(a, b)
elif op in s.log_op:
s.stack.append(s.b_log_op(s.variables[a],
s.variables[b], op))
elif op in s.op:
if not re.fullmatch(r"0|([1-9][0-9]*)", a):
a = s.variables[a]
else:
a = int(a)
if not re.fullmatch(r"0|([1-9][0-9]*)", b):
b = int(s.variables[b])
else:
b = int(b)
s.stack.append(s.b_op(a, b, op))
elif op in s.list_com:
s.stack.append(s.methodList(s.variables[a], b, op))
class Par:
def __init__(s, Lex):
s.height = 0
s.i = 0
s.start = Lex
s.LB = 0
def S(s):
S = Node('S')
while s.i < len(s.start) - 1:
s.height = 1
expr = s.expr()
if expr is not None:
S.children.append(expr)
s.i += 1
return S
def expr(s):
try:
expr = Node('expr', height=s.height)
s.height += 1
token = list(s.start[s.i].keys())[0]
if token == "ПЕРЕМЕННАЯ":
try:
assign_expr = s.assign_expr()
expr.children.append(assign_expr)
s.height -= 1
return expr
except BaseException:
expr.children.append(List(list(s.start[s.i].keys())[0], list(s.start[s.i].values())[0],
s.height))
s.check_next('ТОЧКА')
s.i += 1
method = s.method()
expr.children.append(method)
return expr
elif token == 'ПОКА':
while_expr = s.while_expr()
expr.children.append(while_expr)
s.height -= 1
return expr
elif token == 'ЕСЛИ':
if_expr = s.if_expr()
expr.children.append(if_expr)
s.height -= 1
return expr
else:
return None
except BaseException:
raise BaseException
def method(s):
method = Node('method', height=s.height)
s.height += 1
s.check_next('МЕТОД')
s.i += 1
method.children.append(List(name=list(s.start[s.i].keys())[0], value=list(s.start[s.i].values())[0],
height=s.height))
s.height += 1
s.check_next('Л_СКОБКА ')
s.i += 1
method.children.append(List(name=list(s.start[s.i].keys())[0], value=list(s.start[s.i].values())[0],
height=s.height))
math_expr = s.math_expr()
method.children.append(math_expr)
if not list(s.start[s.i].keys())[0] == 'КОНЕЦ':
raise BaseException
return method
def if_expr(s):
height = s.height
if_expr = Node('if_expr', height=s.height)
s.height += 1
start_height = s.height
s.check_next('Л_СКОБКА ')
if_expr.children.append(List('Л_СКОБКА ', '(', height=s.height))
s.i += 2
s.height += 1
token = list(s.start[s.i].keys())[0]
if token == 'ПЕРЕМЕННАЯ' or token == 'ЧИСЛО' or token == 'Л_СКОБКА ':
math_logic = s.math_logic(ht=[start_height])
if_expr.children.append(math_logic)
s.height = start_height
s.check_next('Л_ФИГУРНАЯ')
if_expr.children.append(Node('Л_ФИГУРНАЯ', height=start_height))
s.i += 1
num_L = 1
while num_L:
if list(s.start[s.i].keys())[0] == 'П_ФИГУРНАЯ':
num_L -= 1
if list(s.start[s.i].keys())[0] == 'Л_ФИГУРНАЯ':
num_L += 1
if num_L:
s.i += 1
s.height = start_height
s.height += 1
if list(s.start[s.i].keys())[0] == 'Л_ФИГУРНАЯ':
num_L += 1
if list(s.start[s.i].keys())[0] == 'П_ФИГУРНАЯ':
num_L -= 1
break
expr = s.expr()
if expr is not None:
if_expr.children.append(expr)
if_expr.children.append(Node('П_ФИГУРНАЯ', height=start_height))
if s.i < len(s.start) - 1:
s.check_next('ИНАЧЕ')
s.i += 1
s.check_next('Л_ФИГУРНАЯ')
s.height = height
if_expr.children.append(Node('ИНАЧЕ', height=s.height))
s.height += 1
start_height = s.height
if_expr.children.append(Node('Л_ФИГУРНАЯ', height=s.height))
num_L = 1
while num_L:
if list(s.start[s.i].keys())[0] == 'П_ФИГУРНАЯ':
num_L -= 1
if list(s.start[s.i].keys())[0] == 'Л_ФИГУРНАЯ':
num_L += 1
if num_L:
s.i += 1
s.height = start_height
s.height += 1
if list(s.start[s.i].keys())[0] == 'Л_ФИГУРНАЯ':
num_L += 1
if list(s.start[s.i].keys())[0] == 'П_ФИГУРНАЯ':
num_L -= 1
break
expr = s.expr()
if expr is not None:
if_expr.children.append(expr)
if_expr.children.append(Node('П_ФИГУРНАЯ', height=start_height))
return if_expr
def while_expr(s):
while_expr = Node('while_expr', height=s.height)
s.height += 1
start_height = s.height
s.check_next('Л_СКОБКА ')
while_expr.children.append(List('Л_СКОБКА ', '(', height=s.height))
s.i += 2
s.height += 1
token = list(s.start[s.i].keys())[0]
if token == 'ПЕРЕМЕННАЯ' or token == 'ЧИСЛО' or token == 'Л_СКОБКА ':
math_logic = s.math_logic(ht=[start_height])
while_expr.children.append(math_logic)
s.height = start_height
s.check_next('Л_ФИГУРНАЯ')
s.i += 1
while_expr.children.append(Node('Л_ФИГУРНАЯ', height=s.height))
num_L = 1
while num_L:
if list(s.start[s.i].keys())[0] == 'П_ФИГУРНАЯ':
num_L -= 1
if list(s.start[s.i].keys())[0] == 'Л_ФИГУРНАЯ':
num_L += 1
if num_L:
s.i += 1
s.height = start_height
s.height += 1
if list(s.start[s.i].keys())[0] == 'Л_ФИГУРНАЯ':
num_L += 1
if list(s.start[s.i].keys())[0] == 'П_ФИГУРНАЯ':
num_L -= 1
break
expr = s.expr()
if expr is not None:
while_expr.children.append(expr)
while_expr.children.append(Node('П_ФИГУРНАЯ', height=start_height))
return while_expr
else:
raise BaseException
def math_logic(s, ht=[]):
token = list(s.start[s.i].keys())[0]
if not token == 'П_СКОБКА' or not token == 'Л_ОПЕРАЦИЯ' \
or not token == 'ОПЕРАЦИЯ':
math_logic = Node('math_logic', height=s.height)
else:
math_logic = ''
s.height += 1
if token == 'Л_СКОБКА ':
ht.append(s.height)
LBreaket = s.LBreaket()
math_logic.children.append(LBreaket)
elif token == 'П_СКОБКА':
s.height = ht.pop(-1)
math_logic = Node('П_СКОБКА', height=s.height)
elif token == 'ЧИСЛО':
math_logic.children.append(List(list(s.start[s.i].keys())[0],
list(s.start[s.i].
values())[0],
s.height))
if s.i + 1 < len(s.start):
if list(s.start[s.i + 1].keys())[0] == 'Л_ОПЕРАЦИЯ':
s.i += 1
math_logic.children.append(List(list(s.start[s.i].
keys())[0],
list(s.start[s.i].
values())[0],
s.height))
elif list(s.start[s.i + 1].keys())[0] == 'ОПЕРАЦИЯ':
s.i += 1
math_logic.children.append(List(list(s.start[s.i].
keys())[0],
list(s.start[s.i].
values())[0],
s.height))
elif token == 'ПЕРЕМЕННАЯ':
math_logic.children.append(List(list(s.start[s.i].keys())[0],
list(s.start[s.i].
values())[0],
s.height))
if s.i + 1 < len(s.start):
if list(s.start[s.i + 1].keys())[0] == 'Л_ОПЕРАЦИЯ':
s.i += 1
math_logic.children.append(List(list(s.start[s.i].
keys())[0],
list(s.start[s.i].
values())[0],
s.height))
elif list(s.start[s.i + 1].keys())[0] == 'ОПЕРАЦИЯ':
s.i += 1
math_logic.children.append(List(list(s.start[s.i].
keys())[0],
list(s.start[s.i].
values())[0],
s.height))
elif token == 'Л_ОПЕРАЦИЯ':
s.height -= 1
math_logic = Node('Л_ОПЕРАЦИЯ' +
list(s.start[s.i].values())[0],
height=s.height)
elif token == 'ОПЕРАЦИЯ':
s.height -= 1
math_logic = Node('ОПЕРАЦИЯ' + list(s.start[s.i].values())[0],
height=s.height)
elif not token == 'КОНЕЦ':
raise BaseException
if len(ht):
s.i += 1
me = s.math_logic(ht)
math_logic.children.append(me)
return math_logic
def check_next(s, values):
token = list(s.start[s.i + 1].keys())[0]
if not token == values:
raise BaseException
def assign_expr(s):
assign_expr = Node('Н_ВЫРАЖ', '=', s.height)
s.check_next("ОПЕРАЦИЯ_П")
s.height += 1
assign_expr.children.append(List(list(s.start[s.i].keys())[0],
list(s.start[s.i].
values())[0], s.height))
s.i += 1
assign_expr.children.append(List(list(s.start[s.i].keys())[0],
list(s.start[s.i].
values())[0], s.height))
s.height -= 1
s.i += 1
token = list(s.start[s.i].keys())[0]
if token == 'СТРОКА':
s.height += 1
assign_expr.children.append(List('СТРОКА', list(s.start[s.i].
values())[0],
s.height))
s.check_next('КОНЕЦ')
s.i += 1
elif token == 'ЧИСЛО' or token == 'Л_СКОБКА ' or token == 'ПЕРЕМЕННАЯ':
s.height += 1
math_expr = s.math_expr()
assign_expr.children.append(math_expr)
elif token == 'С_СПИСОК':
s.height += 1
assign_expr.children.append(List('С_СПИСОК', list(s.start[s.i].values())[0], s.height))
return assign_expr
def math_expr(s, ht=[]):
token = list(s.start[s.i].keys())[0]
if not token == 'П_СКОБКА' or not token == 'ОПЕРАЦИЯ' or not token == 'ТОЧКА':
math_expr = Node('math_expr', height=s.height)
else:
math_expr = ''
s.height += 1
if token == 'Л_СКОБКА ':
ht.append(s.height)
LBreaket = s.LBreaket()
math_expr.children.append(LBreaket)
elif token == 'П_СКОБКА':
s.LB -= 1
s.height = ht.pop(-1)
if s.LB < 0:
raise BaseException
math_expr = Node('П_СКОБКА', value=')', height=s.height)
elif token == 'ЧИСЛО':
math_expr.children.append(List(list(s.start[s.i].keys())[0],
list(s.start[s.i].
values())[0],
s.height))
if s.i + 1 < len(s.start):
if list(s.start[s.i + 1].keys())[0] == 'ОПЕРАЦИЯ':
s.i += 1
math_expr.children.append(List(list(s.start[s.i].
keys())[0],
list(s.start[s.i].
values())[0],
s.height))
elif token == 'ОПЕРАЦИЯ':
s.height -= 1
math_expr = Node('ОПЕРАЦИЯ' + list(s.start[s.i].values())[0],
height=s.height)
elif token == 'ПЕРЕМЕННАЯ':
math_expr.children.append(List(list(s.start[s.i].keys())[0],
list(s.start[s.i].
values())[0],
s.height))
if s.i + 1 < len(s.start):
if list(s.start[s.i + 1].keys())[0] == 'ОПЕРАЦИЯ':
s.i += 1
math_expr.children.append(List(list(s.start[s.i].
keys())[0],
list(s.start[s.i].
values())[0],
s.height))
elif token == 'ТОЧКА':
math_expr = s.method()
s.i -= 1
elif not token == 'КОНЕЦ':
raise BaseException
s.i += 1
if not list(s.start[s.i].keys())[0] == 'КОНЕЦ':
me = s.math_expr(ht)
math_expr.children.append(me)
return math_expr
def LBreaket(s):
s.LB += 1
LBreaket = List('Л_СКОБКА ', '(', height=s.height)
return LBreaket
|
{
"imports": [
"/Core.py"
]
}
|
0-Yama/Net-Way
|
refs/heads/master
|
/main.py
| "from re import split\nfrom src.interface.menuCreator import MenuCreator as mc\nimport tkinter as tk(...TRUNCATED)
| "from hashlib import blake2b\nimport tkinter as tk\nfrom tkinter import *\nfrom tkinter.ttk import *(...TRUNCATED)
|
{
"imports": [
"/src/interface/menuCreator.py",
"/src/gestUser/gestuser.py"
]
}
|
End of preview. Expand
in Data Studio
README.md exists but content is empty.
- Downloads last month
- 62