def p_dtypeSolo(p):
'''dtypeSolo : DTYPE_SOLO
| DTYPE_BOTH_1PARAM
| DTYPE_SOLO_1PARAM2
| DTYPE_BOTH_1PARAM LPAREN parameter RPAREN
| DTYPE_SOLO_1PARAM2 LPAREN parameter RPAREN
| DTYPE_SOLO_1PARAM2 LPAREN parameter COMMA parameter RPAREN'''
debug("dtypeSolo")
p[0] = p[1]
global param_list
param_list = [] # inicializes param_list
#NOTE: we add our own limitations to this potentially unlimited numeric
# for filling reasons
if len(p) == 2 and p[1] == "numeric":
param_list.append(NUMERIC_INT)
param_list.append(NUMERIC_FRAC)
elif len(p) == 2 and (p[1] == "bit" or p[1] == "character"):
param_list.append(DEFAULT_BIT_CHAR)
if len(p) == 5: # variant: DTYPE_BOTH_1PARAM LPAREN parameter RPAREN
param_list.append(p[3])
elif len(p) == 7: # variant: DTYPE_SOLO_1PARAM2 LPAREN parameter COMMA parameter RPAREN
param_list.append(p[3])
param_list.append(p[5])
def p_multi_1param(p):
'''multi_1param : idOrDtypeName COMMA
| idOrDtypeName'''
debug("multi_1param")
global alter_attr
global alter_table
global TO_SET_CONSTR
global PARAM_COUNTER
alter_attr = None
alter_name = None
#finding the attribute to get altered
for attr in alter_table.attr_list:
if attr.name == p[1]: # p[1] stands for the attribute name in both cases
alter_attr = attr
break
#did we find anything?
if alter_attr is None:
msg = "Input error: Couldn't find the given attribute name '" + p[7] \
+ "' in the list of attributes of table '" + alter_table.name \
+ "' while processing a multiparameter ADD CONSTRAINT.\n"
errprint(msg, ERRCODE["INPUT"])
alter_attr.constraint_flag = True
alter_attr.constraint_cnt += 1 # increments the cnt
TO_SET_CONSTR.append(alter_attr) # we pass the attribute to alter
def p_constraints(p):
'''constraints : NOT NULL
| NULL
| UNIQUE
| DEFAULT NUMBER retype
| DEFAULT FLOATNUM retype
| DEFAULT QUOTE QUOTE retype
| DEFAULT QUOTE inquote QUOTE retype
| DEFAULT LPAREN NUMBER RPAREN retype
| DEFAULT LPAREN FLOATNUM RPAREN retype'''
debug("constraints")
if p[1] == "NOT":
constr = p[1] + ' ' + p[2]
else:
constr = p[1]
global new_attribute
new_attribute.constraint_flag = True
new_attribute.constraint_cnt += 1 # increments the cnt
new_attribute.set_constraint(constr)
if new_attribute.default:
if len(p) == 6: # default different than just ''
new_attribute.default_value = p[3]
elif len(p) == 4 and p[1] == "DEFAULT":
new_attribute.default_value = p[2]
async def read_datas(self):
while True:
datas = await self._read_bytes()
# 本函数对bytes进行相关操作，不特别声明，均为bytes
if datas is None:
return
data_l = 0
len_datas = len(datas)
while data_l != len_datas:
# 每片data都分为header和body，data和data可能粘连
# data_l == header_l && next_data_l = next_header_l
# ||header_l...header_r|body_l...body_r||next_data_l...
tuple_header = self.structer.unpack_from(datas[data_l:])
len_data, len_header, ver, opt, seq = tuple_header
body_l = data_l + len_header
next_data_l = data_l + len_data
body = datas[body_l:next_data_l]
# 人气值(或者在线人数或者类似)以及心跳
if opt == 3:
# UserCount, = struct.unpack('!I', remain_data)
printer.debug(f'弹幕心跳检测{self._area_id}')
# cmd
elif opt == 5:
if not self.handle_danmu(body):
return
# 握手确认
elif opt == 8:
printer.info([f'{self._area_id}号弹幕监控进入房间（{self._room_id}）'], True)
else:
printer.warn(datas[data_l:next_data_l])
data_l = next_data_l
def p_multi_attr_constr(p):
'''multi_attr_constr : ADD CONSTRAINT IDENTIFIER UNIQUE LPAREN multi_params RPAREN
| ADD CONSTRAINT IDENTIFIER PRIMARY KEY LPAREN multi_params RPAREN'''
debug("multi_attr_constr")
global TO_SET_CONSTR
global GROUP_COUNTER
global PARAM_COUNTER
if len(p) == 9: # two word constraint
constr = p[4] + " " + p[5]
else:
constr = p[4]
PARAM_COUNTER = len(TO_SET_CONSTR) # gets size of PARAM_COUNTER so we know how many there are
#checking if we got more than 1 param. If yes, it means more attributes create a unique group
for attr in TO_SET_CONSTR:
attr.set_constraint(
constr) # sets flag for each attribute
if PARAM_COUNTER > 1: # more than one attribute given as parameter -> group
attr.unique_group = GROUP_COUNTER # puts all attributes into the same group
else:
attr.unique_group = 0 # single unique attr
if PARAM_COUNTER > 1: # if we used the current group number
GROUP_COUNTER = GROUP_COUNTER + 1 # we increment the counter
TO_SET_CONSTR = [] # inicialize the set
PARAM_COUNTER = 0 # and turns param counter back to zero
def p_dtypes(p):
'''dtypes : TYPE_NOPARAM
| TYPE_1PARAM LPAREN NUMBER RPAREN
| TYPE_2PARAM LPAREN NUMBER COMMA NUMBER RPAREN
| TYPE_2PARAM_TIME LPAREN NUMBER COMMA TIMEZONE_PARAM RPAREN'''
global new_attribute
global new_table
new_attribute.data_type = p[1]
new_attribute.parameters = [] # inicializes to no parameters
if len(p) == 5: # stands for "DTYPE (1_param)"
new_attribute.parameters.append(p[3]) # appends the parameter
elif len(p) == 7: # DTYPE_2PARAM
new_attribute.parameters.append(p[3])
new_attribute.parameters.append(p[5])
if p[1] == 'SERIAL' or p[1] == 'BIGSERIAL':
new_attribute.serial = True
if p[1] == "TIME":
print new_attribute.parameters
debug("dtypes")
async def handle_msg(self):
while True:
bytes_datas = await self.__read_msg()
if bytes_datas is None:
return
len_read = 0
len_bytes_datas = len(bytes_datas)
while len_read != len_bytes_datas:
split_header = self.structer.unpack(bytes_datas[len_read:16 +
len_read])
len_data, len_header, ver, opt, seq = split_header
remain_data = bytes_datas[len_read + 16:len_read + len_data]
# 人气值/心跳 3s间隔
if opt == 3:
# self._UserCount, = struct.unpack('!I', remain_data)
printer.debug(f'弹幕心跳检测{self.area_id}')
# cmd
elif opt == 5:
if not self.handle_danmu(remain_data):
return
# 握手确认
elif opt == 8:
printer.info([f'{self.area_id}号弹幕监控进入房间（{self.roomid}）'],
True)
else:
printer.warn(bytes_datas[len_read:len_read + len_data])
len_read += len_data
async def ReceiveMessageLoop(self):
while True:
bytes_datas = await self.ReadSocketData()
if bytes_datas is None:
break
len_read = 0
len_bytes_datas = len(bytes_datas)
while len_read != len_bytes_datas:
state = None
split_header = self.structer.unpack(bytes_datas[len_read:16 +
len_read])
len_data, len_header, ver, opt, seq = split_header
remain_data = bytes_datas[len_read + 16:len_read + len_data]
# 人气值/心跳 3s间隔
if opt == 3:
# self._UserCount, = struct.unpack('!I', remain_data)
printer.debug(f'弹幕心跳检测{self.area_id}')
# cmd
elif opt == 5:
messages = remain_data.decode('utf-8')
dic = json.loads(messages)
state = self.loop_func(dic)
# 握手确认
elif opt == 8:
printer.info([f'{self.area_id}号弹幕监控进入房间（{self.roomid}）'],
True)
else:
printer.warn(bytes_datas[len_read:len_read + len_data])
if state is not None and not state:
return
len_read += len_data
def p_attributeName(p):
'attributeName : DOUBLE_COLON IDENTIFIER endline'
global new_attribute
new_attribute = table.Attribute() # new attribute instance
new_attribute.values_list = []
new_attribute.name = p[2]
debug("attributeName")
def p_moreBlocks(p):
'''moreBlocks : moreBlocks tableBlock
| empty'''
debug("moreBlocks")
global table_list
global new_table
table_list.append(new_table)
def p_alterBody(p):
'''alterBody : ADD CONSTRAINT IDENTIFIER PRIMARY KEY LPAREN idOrDtypeName RPAREN
| ADD CONSTRAINT IDENTIFIER FOREIGN KEY LPAREN idOrDtypeName RPAREN REFERENCES IDENTIFIER LPAREN IDENTIFIER RPAREN
| multi_attr_constr'''
debug("alterBody")
global alter_attr
global alter_table
alter_attr = None
alter_name = None
#the multi_attr constraint has been solved already
#this goes just for the KEYs
if len(p) != 2:
constr = p[4] + " " + p[5]
#finding the attribute to get altered
for attr in alter_table.attr_list:
if attr.name == p[7]: # p[7] stands for the attribute name in both cases
alter_attr = attr
break
#did we find anything?
if alter_attr is None:
msg = "Input error: Couldn't find the given attribute name '" + p[7] \
+ "' in the list of attributes of table '" + alter_table.name \
+ "' while processing a " + constr + ".\n"
errprint(msg, ERRCODE["INPUT"])
alter_attr.constraint_flag = True
alter_attr.constraint_cnt += 1 # increments the cnt
alter_attr.set_constraint(constr)
#for foreign key
if p[4] == 'FOREIGN':
#existence of foreign table check
if not p[10] in name_dict.keys():
msg = "Input error: Foreign table '" + \
p[10] + "' couldn't be found.\n"
errprint(msg, ERRCODE["INPUT"])
alter_attr.fk_table = name_dict[p[10]]
#gets the foreign table object
for attr in alter_attr.fk_table.attr_list:
if attr.name == p[12]:
alter_attr.fk_attribute = attr
break
#existence of foreign attribute check
if alter_attr.fk_attribute is None:
msg = "Input error: Foreign attribute '" + p[12] \
+ "' couldn't be found in table '" + p[10] \
+ "' while processing a " + constr + ".\n"
errprint(msg, ERRCODE["INPUT"])
def p_dtypeNames(p):
'''dtypeNames : DTYPE_SOLO
| DTYPE_BOTH_1PARAM
| DTYPE_SOLO_1PARAM2
| DTYPE_TIMEZONE_PARAM
| DTYPE_PART2
| DTYPE_PART1'''
debug("dtypeNames")
p[0] = p[1]
def p_moreBlocks(p):
'''moreBlocks : moreBlocks tableBlock
| empty'''
global new_table
global attr_list
new_table.attr_list = attr_list # adds complete list of attributes
new_table.count_attributes(
) # stores the count of attributes in table.attr_count
debug("moreBlocks")
def p_alterHeader(p):
'alterHeader : ALTER TABLE ONLY IDENTIFIER'
debug("alterHeader")
global alter_table
if not p[4] in name_dict.keys():
msg = "Input error: Table '" + p[4] + \
"'given in ALTER part couldn't be found.\n"
errprint(msg, ERRCODE["INPUT"])
alter_table = name_dict[p[4]]
def p_tableHeader(p):
'tableHeader : CREATE TABLE IDENTIFIER LPAREN'
debug("tableHeader")
global new_table
global name_dict
new_table = table.Table() # creates new table instance
new_table.name = p[3]
name_dict[new_table.name] = new_table
def p_attributeName(p):
'''attributeName : IDENTIFIER
| dtypeNames
| DQUOTES IDENTIFIER DQUOTES
| DQUOTES dtypeNames DQUOTES'''
debug("attributeName")
if len(p) == 2:
p[0] = p[1] # we pass the attribute name
else:
p[0] = p[2]
def p_parameter(p):
'''parameter : PATH
| REGEX
| NUMBER
| IDENTIFIER
| IDENTIFIER COLON IDENTIFIER'''
p[0] = p[1] # returns the value in p[0]
debug("parameter")
if len(p) == 4: # IDENTIFIER COLON IDENTIFIER variant
p[0] = p[1] + ":" + p[3]
def p_fillMethod(p):
'''fillMethod : FILL FILL_METHOD_NOPARAM LPAREN RPAREN endline
| FILL FILL_METHOD_1PARAM LPAREN parameter RPAREN endline'''
global new_attribute
global new_table
new_attribute.fill_method = p[2].lower() # lower case to be sure
debug("fillMethod")
if len(p) == 7: # one parameter
new_attribute.fill_parameters = [] # clears the list
new_attribute.fill_parameters.append(p[4])
def p_tableHeader(p):
'''tableHeader : TABLE COLON IDENTIFIER LPAREN NUMBER RPAREN endline
| TABLE COLON IDENTIFIER LPAREN FILLED RPAREN endline'''
global new_table
new_table = table.Table() # creates new table instance
new_table.fill_count = p[5]
new_table.name = p[3] # corresponds to the IDENTIFIER token
global attr_list
attr_list = [] # inicializes empty list for this table
debug("tableHeader")
def p_attributeBlock(p):
'''attributeBlock : attributeName dtypes COMMA
| attributeName dtypes constraintPart COMMA
| attributeName dtypes
| attributeName dtypes constraintPart'''
debug("attributeBlock")
global new_table
global new_attribute
new_attribute.name = p[1]
new_table.attr_list.append(new_attribute)
def p_attributeBlock(p):
'''attributeBlock : attributeName dataType fillMethod
| attributeName dataType fillMethod constraintPart'''
global new_attribute
global attr_list
#first we check compatibility of given functions, parameters and data types
check_valid(new_attribute)
#then we check possible data_type and constraint collisions
check_collision()
attr_list.append(new_attribute) # appends the new attribute
new_attribute.constraint_flag = False # nulls the flag
debug("attributeBlock")
def p_dtypeTwopart(p):
'''dtypeTwopart : DTYPE_BOTH_1PARAM DTYPE_PART2
| DTYPE_PART1 DTYPE_PART2
| DTYPE_BOTH_1PARAM DTYPE_PART2 LPAREN parameter RPAREN'''
debug("dtypeTwopart")
p[0] = p[1] + ' ' + p[2]
#creates one string from the two-part name
global param_list
param_list = []
if len(p) == 6: # variant: DTYPE_BOTH_1PARAM DTYPE_PART2 LPAREN parameter RPAREN
param_list.append(p[4])
global TO_ADD
global ADD_VAL
if p[0] in TO_ADD and len(param_list) == 0: # we will add parameter for filling purposes if not given
param_list.append(
ADD_VAL) # -> varchar(8) and varbit(8)
def p_constr(p):
'''constr : CONSTR_NOPARAM
| CONSTR_1PARAM LPAREN NUMBER RPAREN'''
debug("constraintPart")
global new_attribute
if p[1] == "foreign_key":
#new_attribute.foreign_key = True
return # like nothing happened, fm_reference sets the flag
elif p[1] == "primary_key":
new_attribute.primary_key = True
new_attribute.unique_group = p[3]
elif p[1] == "unique":
new_attribute.unique = True
new_attribute.unique_group = p[3]
elif p[1] == "null":
new_attribute.null = True
new_attribute.constraint_parameters = p[3]
elif p[1] == "not_null":
new_attribute.not_null = True
elif p[1] == "default":
new_attribute.default = True
#if len(p) == 5:
# val = p[3]
#elif len(p) == 6:
# val = "''"
#else:
# val = p[4]
new_attribute.default_value = p[3] # stores the percentage
new_attribute.constraint_type = p[1]
new_attribute.constraint_flag = True
new_attribute.constraint_cnt += 1
#TODO:check if it's really neccessary to make generator go more easy, feels chaotic here
if new_attribute.primary_key:
new_attribute.unique = True
def p_dtypeTimezone(p):
'''dtypeTimezone : DTYPE_TIMEZONE_PARAM LPAREN parameter RPAREN
| DTYPE_TIMEZONE_PARAM IDENTIFIER DTYPE_TIMEZONE_PARAM IDENTIFIER
| DTYPE_TIMEZONE_PARAM LPAREN parameter RPAREN IDENTIFIER DTYPE_TIMEZONE_PARAM IDENTIFIER'''
#The second DTYPE_TIMEZONE_PARAM token is there because "time" is already a keyword
#'with' and 'zone' could be keywords but I didn't think it was necessary
debug("dtypeTimezone")
p[0] = p[1]
global param_list
param_list = [] # inicializes param_list
#if with/without timezone is missing, it's automatically without
if len(p) == 5 and p[2] == "(":
word1 = "without"
word2 = "time"
word3 = "zone"
param_list.append(p[3]) # we append precision
if len(p) == 5:
word1 = p[2]
word2 = p[3]
word3 = p[4]
param_list.append(DEFAULT_TIME_PRECISION) # we append precision
else:
word1 = p[5]
word2 = p[6]
word3 = p[7]
param_list.append(p[3]) # we append precision
st1 = (word1 == "with" or word1 == "without")
st2 = (word2 == "time")
st3 = (word3 == "zone")
if st1 and st2 and st3: # all true
if word1 == "with":
x = "+TMZ"
else:
x = "-TMZ"
param_list.append(x) # we append with/without code
def p_sequenceBlock(p):
'sequenceBlock : SEQUENCE IDENTIFIER OWNED BY IDENTIFIER PERIOD IDENTIFIER SEMICOLON'
debug("sequenceBlock")
#we find the table
if not p[5] in name_dict.keys():
msg = "Semantic error: Table '" + p[5] + \
"'given in ALTER SEQUENCE part couldn't be found.\n"
errprint(msg, ERRCODE["SEMANTIC"])
seq_table = name_dict[p[5]]
name = p[7] # name of the attribute
seq_attr = None
#search for the attribute
for attr in seq_table.attr_list:
if attr.name == name:
seq_attr = attr
break
#we didn't find it, there is a prob (shouldn't happen with not-edited dump but you never know)
if seq_attr is None:
msg = "Semantic error: Couldn't find the attribute which SEQUENCE '" + p[2] \
+ "' refers to in table '" + p[5] \
+ "' while processing a " + constr + ".\n"
errprint(msg, ERRCODE["INPUT"])
#now we simply change the data type to corresponding serial type
if seq_attr.data_type == "integer":
seq_attr.data_type = "serial"
elif seq_attr.data_type == "bigint":
seq_attr.data_type = "bigserial"
#any other type that has a filling sequence gets serial dtype
#gonna get 'DEFAULT' as insert value
else:
seq_attr.data_type = "serial"
def p_dtypes(p):
'''dtypes : dtype moreDimensions'''
debug("dtypes")
global new_attribute
global param_list
global ARRAY_FLAG
global DIM_CNT
global DIM_SIZE
new_attribute = table.Attribute()
new_attribute.data_type = p[1]
new_attribute.parameters = param_list
if ARRAY_FLAG:
new_attribute.array_flag = True
new_attribute.array_dim_cnt = DIM_CNT
new_attribute.array_dim_size = DIM_SIZE
ARRAY_FLAG = False # iniciates them for next attributes
DIM_CNT = 0
DIM_SIZE = []
thorings = monomer.mark_thio(monomer1)
intermono = monomer.find_intermono(monomer1)
halfmono = monomer.get_single_alist(monomer1)
attach = monomer.find_attach(monomer1,halfmono)
test2 = monomer.attach(halfmono,attach,monomer1,length)
monomer.print_mono(test2,"outputs/test")
#monomer.create_polymer_cml(mname,halfmono,attach,monomer1)
sys.stdout = sys.__stdout__
#create babel and read to get better partials
babel.read_babel_set(mname,atoms)
atom.adjust_partials(atoms)
#write different dft finders
#write_nwchem.dft(dihedrals)
#write_qchem.write(atoms,dihedrals)
sys.stdout = sys.__stdout__
if debug:
printer.debug(atoms,bonds,angles,dihedrals,rings,fused_rings,opls_atoms,opls_bonds,opls_angles,opls_dihedrals)
#print all the output files
printer.print_data(dname,atoms,bonds,angles,dihedrals,unique_a,unique_b,unique_ang,unique_d,xmin,xmax,ymin,ymax,zmin,zmax)
if help == False or isfile == False:
printer.print_lammpsin(inname,dataname,lammpsinput)
sys.stdout = sys.__stdout__
printer.print_srun(lammpsinput)
#autorun
#os.system('sbatch run_%s' % lammpsinput)
def p_alterBlock(p):
'alterBlock : alterHeader alterBody SEMICOLON'
debug("alterBlock")
def p_checkBlock(p):
'''checkBlock : CONSTRAINT IDENTIFIER CHECK CHECKATTR
| CONSTRAINT IDENTIFIER CHECK CHECKATTR COMMA'''
debug("moreCheckBlocks")
def p_moreSequenceBlocks(p):
'''moreSequenceBlocks : moreSequenceBlocks sequenceBlock
| empty'''
debug("moreSequenceBlocks")
def p_multi_params(p):
'''multi_params : multi_1param multi_params
| empty'''
debug("multi_params")
def p_moreAlterBlocks(p):
'''moreAlterBlocks : moreAlterBlocks alterBlock
| empty'''
debug("moreAlterBlocks")
def p_idOrDtypeName(p):
'''idOrDtypeName : IDENTIFIER
| dtypeNames'''
debug("idOrDtypeName")
p[0] = p[1]
