ansi depumper plugin
This commit is contained in:
parent
8e5ebc11f6
commit
0ac14554d7
|
|
@ -0,0 +1,742 @@
|
|||
# -*- coding: utf-8 -*- ########################################################################################### SOF
|
||||
"""# MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM ####
|
||||
#### MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMh+MMMMMMMMMMMMMMhsMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM ####
|
||||
#### MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMm/ oMMMMMMMMMMMMMMm +NMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM ####
|
||||
#### MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMy` yMMMMMMMMMMMMMMM- -mMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM ####
|
||||
#### MMMMMMMMMMMMMMMMMMMMMMMMs+dMMMMMMMMMM+ sMMMMMMMMMMMMMMM- `dMMMMMMMMMMms/NMMMMMMMMMMMMMMMMMMMMMMM ####
|
||||
#### MMMMMMMMMMMMMMMMMMMMMMMMM+ .omMMMMMM: -MMMMMMMMMMMMMMo `yMMMMMMMy: `dMMMMMMMMMMMMMMMMMMMMMMMM ####
|
||||
#### MMMMMMMMMMMMMMMMMMMMMMMMMM- /dMMM+ sMMMMMMMMMMMMh `hMMMNo` sMMMMMMMMMMMMMMMMMMMMMMMMM ####
|
||||
#### MMMMMMMMMMMMMMMMMMMMMMMMMMd :dm `mMMMMMMMMMMN. .NNo` .MMMMMMMMMMMMMMMMMMMMMMMMMM ####
|
||||
#### MMMMMMMMMMMMMMMMMMMMMMMMMMM: - :MMMMMMMMMMs :` sMMMMMMMMMMMMMMMMMMMMMMMMMM ####
|
||||
#### MMMMMMMMMMMMMMMMMMMMMMMMMMMs ymNMMMMMNm. NMMMMMMMMMMMMMMMMMMMMMMMMMM ####
|
||||
#### MMMMMMMMMMMMMMMMMMMMMMMMMMMy `-/-` .MMMMMMMMMMMMMMMMMMMMMMMMMMM ####
|
||||
#### MMMMMMMMMMMMMMMMMMMMMMMMMMMo .NMMMMMMMMMMMMMMMMMMMMMMMMMM ####
|
||||
#### MMMMMMMMMMMMMMMMMMMMMMMNh+. :sdMMMMMMMMMMMMMMMMMMMMMMM ####
|
||||
#### MMMMMMMMMMMMMMMMMhso+:. `-/+syMMMMMMMMMMMMMMMMM ####
|
||||
#### MMMMMMMMMMMMMMMMM- dMMMMMMMMMMMMMMMM ####
|
||||
#### MMMMMMMMMMMMMMMMM` `.:+/. `/s+:. sMMMMMMMMMMMMMMMM ####
|
||||
#### MMMMMMMMMMMMMMMNo -oms. .//-` `:/:` `+md+` .hMMMMMMMMMMMMMMM ####
|
||||
#### MMMMMMMMMMMMMNs` .odNdo. .ohmd+` :dMMMMMMMMMMMMM ####
|
||||
#### MMMMMMMMMMMNo` .. .- :hMMMMMMMMMMM ####
|
||||
#### MMMMMMMMMd+` -sNMMMMMMMM ####
|
||||
#### ###MMMNs- `.. `/-. `+dMMMMMM ####
|
||||
#### ###Ny: ./sdNMMMh: `sNMMMNds/. .odMMM ####
|
||||
#### MM+ :ymMMMMMMMMMMh. +NMMMMMMMMMMmo- /NM ####
|
||||
#### MMMh: .sNMMMMMMMMMMMMMMN- `hMMMMMMMMMMMMMMMm+` :hMMM ####
|
||||
#### MMMMMd:` ``-:+shmMMMMMMMMMMMMMMMMMMN. hMMMMMMMMMMMMMMMMMMMmhs+/-..``````./dMMMMM ####
|
||||
#### MMMMMMMMMNNNNNNMMMMMMMMMMMMMMMMMMMMMMMMMMMo .MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM ####
|
||||
#### MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMy .MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM ####
|
||||
#### MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMN. /MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM ####
|
||||
#### MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMN+` `+NMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM ####
|
||||
#### MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNs. -hMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM ####
|
||||
#### MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMdyymMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM #"""
|
||||
|
||||
import os
|
||||
import re
|
||||
import subprocess
|
||||
from datetime import datetime
|
||||
|
||||
import irc3
|
||||
import requests
|
||||
from irc3.plugins.command import command
|
||||
from irc3.plugins.cron import cron
|
||||
|
||||
from plugins.tool_guds_plugin import guds
|
||||
|
||||
#######################################################################################################################
|
||||
|
||||
global REASSEMBLY
|
||||
global iCount
|
||||
|
||||
REASSEMBLY="1B5B306D"
|
||||
iCount=-1
|
||||
|
||||
REGEX = re.compile("\x03(?:\d{1,2}(?:,\d{1,2})?)?",re.UNICODE)
|
||||
|
||||
DEBUGGING = False
|
||||
|
||||
ANSI_HOME='databases/ansi'
|
||||
if not os.path.exists(ANSI_HOME):
|
||||
os.mkdir(ANSI_HOME)
|
||||
|
||||
COLOR_SET_A = "\x1b[38;2;196;0;255m"
|
||||
COLOR_SET_B = "\x1b[38;2;128;64;255m"
|
||||
COLOR_SET_C = "\x1b[38;2;128;0;255m"
|
||||
COLOR_SET_D = "\x1b[2;35m"
|
||||
COLOR_SET_E = "\x1b[2;31m"
|
||||
|
||||
#######################################################################################################################
|
||||
|
||||
############
|
||||
@irc3.plugin
|
||||
############ ##########################################################################################################
|
||||
|
||||
############# #########################################################################################################
|
||||
class Plugin:
|
||||
#############
|
||||
|
||||
########################### #######################################################################################
|
||||
class HYDRA_FILE_HANDLER():
|
||||
###########################
|
||||
|
||||
###################
|
||||
def __init__(self):
|
||||
###################
|
||||
|
||||
self.txt=[]
|
||||
self.ans=[]
|
||||
self.png=[]
|
||||
|
||||
self.ptr=[]
|
||||
|
||||
########################### #######################################################################################
|
||||
class DR1P_STATE_MACHINE():
|
||||
###########################
|
||||
|
||||
FLAGS = ['ESCAPED']
|
||||
|
||||
###################
|
||||
def __init__(self):
|
||||
###################
|
||||
|
||||
self.ESCAPED = False
|
||||
self.ASSEMBLY = False
|
||||
self.bseq = []
|
||||
self.interrupt = 0
|
||||
self.stack = []
|
||||
self.attr_bright = False
|
||||
self.attr_fg = 0
|
||||
self.attr_bg = 0
|
||||
self.attr_last = False
|
||||
self.attr_reset = False
|
||||
|
||||
#################
|
||||
def fog(self, s):
|
||||
#################
|
||||
|
||||
if DEBUGGING:
|
||||
print(s)
|
||||
|
||||
##################
|
||||
def flip(self, b):
|
||||
##################
|
||||
|
||||
FLIP = ({'03': '1B5B'})
|
||||
fog = self.fog
|
||||
if b in FLIP:
|
||||
fog(f'flp:{b}>{FLIP[b]}')
|
||||
return FLIP[b]
|
||||
else:
|
||||
return b
|
||||
|
||||
#################
|
||||
def seq(self, b):
|
||||
#################
|
||||
|
||||
global REASSEMBLY
|
||||
fog = self.fog
|
||||
fog(f'\033[38;2;0;255;0mseq:{b}')
|
||||
if b == "1B5B":
|
||||
self.ack(flag="ESCAPED")
|
||||
REASSEMBLY += str(b)
|
||||
self.ASSEMBLY = False
|
||||
self.stack = []
|
||||
if self.interrupt:
|
||||
if DEBUGGING: fog(f'\033[38;2;255;0;0minterrupted')
|
||||
if int("30", 16) <= int(str(b), 16) <= int("39", 16):
|
||||
if DEBUGGING: fog('\n\033[38;2;255;255;255m<<< <<< BINGO - CODES >>> >>>\x1b[\x1b[92m')
|
||||
self.stack.append(b)
|
||||
if DEBUGGING:
|
||||
fog('')
|
||||
elif b == "2C":
|
||||
if DEBUGGING: fog('\n\033[38;2;0;255;255m<<< <<< BINGO - DELIMITER >>> >>>\x1b[\x1b[92m')
|
||||
self.stack.append(b)
|
||||
if DEBUGGING: fog('')
|
||||
else:
|
||||
if self.interrupt == True and len(self.stack) >= 1:
|
||||
if not b == "1B" or not int("30", 16) <= int(str(b), 16) <= int("39", 16) or not b == "2C":
|
||||
self.ack(flag="ESCAPED")
|
||||
color_table = [ 1, 5, 3, 7, 2, 6, 10, 15,
|
||||
14, 4, 9, 8, 12, 13, 11, 0 ]
|
||||
try:
|
||||
REVERT = bytes([int(x, 16)
|
||||
for x in self.stack]).decode()
|
||||
if ',' in REVERT:
|
||||
A = REVERT.split(',')[0]
|
||||
B = '2C'
|
||||
C = REVERT.split(',')[1]
|
||||
AA = color_table.index(int(A))
|
||||
if int(A) > 7:
|
||||
self.attr_bright = True
|
||||
REASSEMBLY += "313B"
|
||||
CC = color_table.index(int(C))
|
||||
if AA > 7 or CC > 7:
|
||||
if self.attr_bright:
|
||||
AA -= 8
|
||||
A = ''
|
||||
C = ''
|
||||
for _ in range(len(str(AA))):
|
||||
A += "33" + \
|
||||
hex(int(str(AA)[_]) +
|
||||
0x30)[2:].zfill(2).upper()
|
||||
for _ in range(len(str(CC))):
|
||||
C += "34" + \
|
||||
hex(int(str(CC)[_]) +
|
||||
0x30)[2:].zfill(2).upper()
|
||||
REASSEMBLY += A
|
||||
REASSEMBLY += "3B"
|
||||
REASSEMBLY += C
|
||||
else:
|
||||
A = ''
|
||||
AA = color_table.index(int(REVERT))
|
||||
if AA > 7:
|
||||
AA -= 8
|
||||
if not self.attr_bright:
|
||||
REASSEMBLY += "313B"
|
||||
self.attr_bright = True
|
||||
for _ in range(len(str(AA))):
|
||||
A += "33" + \
|
||||
hex(int(str(AA)[_]) +
|
||||
0x30)[2:].zfill(2).upper()
|
||||
REASSEMBLY += A
|
||||
REASSEMBLY += "6D"
|
||||
self.stack = []
|
||||
self.ASSEMBLY = True
|
||||
except:
|
||||
self.ASSEMBLY = False
|
||||
if DEBUGGING:
|
||||
fog('')
|
||||
if self.ASSEMBLY:
|
||||
self.stack.append(b)
|
||||
REASSEMBLY += b
|
||||
self.bseq.append(b)
|
||||
if len(self.bseq) == 1:
|
||||
if REASSEMBLY == "1B5B306D":
|
||||
REASSEMBLY += b
|
||||
if b == "0A":
|
||||
if REASSEMBLY.endswith('0A'):
|
||||
REASSEMBLY = REASSEMBLY[:-2]
|
||||
if REASSEMBLY.endswith('0D'):
|
||||
REASSEMBLY = REASSEMBLY[:-2]
|
||||
while REASSEMBLY.endswith('20'):
|
||||
REASSEMBLY = REASSEMBLY[:-2]
|
||||
REASSEMBLY += "1B5B306D0D0A"
|
||||
return
|
||||
|
||||
###############################
|
||||
def ack(self, flag="", cmd=""):
|
||||
###############################
|
||||
|
||||
fog = self.fog
|
||||
if cmd == "escaped":
|
||||
if flag == "ESCAPED":
|
||||
return 1
|
||||
else:
|
||||
return 0
|
||||
if not flag:
|
||||
for i, _ in enumerate(self.FLAGS):
|
||||
if eval(f"self.{self.FLAGS[i]}"):
|
||||
if DEBUGGING:
|
||||
fog(f'\033[38;2;0;0;255m{_} FLAG IS {str(eval(f"self.{self.FLAGS[i]}")).upper()}')
|
||||
else:
|
||||
if flag in self.FLAGS:
|
||||
if flag == "ESCAPED":
|
||||
self.ESCAPED = not self.ESCAPED
|
||||
if DEBUGGING:
|
||||
fog(f"ESCAPED flag set {self.ESCAPED}")
|
||||
if self.ESCAPED:
|
||||
self.interrupt = 1
|
||||
else:
|
||||
self.interrupt = 0
|
||||
|
||||
#################
|
||||
def fmt(self, b):
|
||||
#################
|
||||
|
||||
b = hex(int(b, 16))[2:].upper().zfill(2)
|
||||
return b
|
||||
|
||||
#################
|
||||
def asm(self, b):
|
||||
#################
|
||||
|
||||
b = self.fmt(b)
|
||||
b = self.flip(b)
|
||||
self.seq(b)
|
||||
|
||||
##################
|
||||
def push(self, b):
|
||||
##################
|
||||
|
||||
fog = self.fog
|
||||
global iCount
|
||||
iCount += 1
|
||||
fog = self.fog
|
||||
if DEBUGGING: fog(f'{COLOR_SET_B}{str(iCount).zfill(8)} {hex(iCount)[2:].zfill(8).upper()}{COLOR_SET_A}')
|
||||
asm = self.asm
|
||||
self.ack()
|
||||
asm(b)
|
||||
|
||||
########################### #######################################################################################
|
||||
|
||||
##################################### #############################################################################
|
||||
class ESCAPE_CODE_DETECTION_SYSTEM():
|
||||
#####################################
|
||||
|
||||
###################
|
||||
def __init__(self):
|
||||
###################
|
||||
|
||||
self.REGEX=re.compile("\x03(?:\d{1,2}(?:,\d{1,2})?)?",re.UNICODE)
|
||||
self.cycle = 0
|
||||
self.count = 0
|
||||
self.lastcount =- 1
|
||||
self.sorted = []
|
||||
self.sorting = []
|
||||
self.buffering = False
|
||||
|
||||
INDEX = 0
|
||||
|
||||
FILE_PREFIX = "bounce__irc_codes_"
|
||||
self.STRINCREMENT = f"{str(INDEX)}".zfill(8)
|
||||
self.FILENAME = f"{ANSI_HOME}/{FILE_PREFIX}{self.STRINCREMENT}.txt"
|
||||
|
||||
while os.path.exists(self.FILENAME):
|
||||
INDEX += 1
|
||||
self.STRINCREMENT = f"{str(INDEX)}".zfill(8)
|
||||
self.FILENAME = f"{ANSI_HOME}/{FILE_PREFIX}{self.STRINCREMENT}.txt"
|
||||
|
||||
self.f1 = open(self.FILENAME, "w") # file handle f1
|
||||
|
||||
#################################################
|
||||
def push(self,nick,channel,dataline,hexdataline):
|
||||
#################################################
|
||||
|
||||
if not self.buffering:
|
||||
self.sorting.append([nick,True,channel,[datetime.now().timestamp()],[dataline],[hexdataline]])
|
||||
self.sorting[0][3].pop()
|
||||
self.sorting[0][4].pop()
|
||||
self.sorting[0][5].pop()
|
||||
self.buffering = True
|
||||
|
||||
try:
|
||||
for x in self.sorting:
|
||||
if x[0]==nick:
|
||||
if x[1]:
|
||||
x[3].append(datetime.now().timestamp())
|
||||
x[4].append(dataline)
|
||||
x[5].append(hexdataline)
|
||||
except Exception as e:
|
||||
pass
|
||||
|
||||
##################################### #############################################################################
|
||||
|
||||
######################## ##########################################################################################
|
||||
def __init__(self, bot):
|
||||
########################
|
||||
|
||||
self.bot = bot
|
||||
self.bot.hfh = self.HYDRA_FILE_HANDLER()
|
||||
self.bot.ecds = self.ESCAPE_CODE_DETECTION_SYSTEM()
|
||||
globals()['guds'].memories.append([self.HYDRA_FILE_HANDLER,'net_krylon_plugin:__init__.HYDRA_FILE_HANDLER(HFH)'])
|
||||
globals()['guds'].memories.append([self.ESCAPE_CODE_DETECTION_SYSTEM,'net_krylon_plugin:__init__.ESCAPE_CODE_DETECTION_SYSTEM(ECDS)'])
|
||||
globals()['guds'].memories.append([self.bot,'net_krylon_plugin:__init__.self'])
|
||||
self.processing_byte=[]
|
||||
self.processing_command=[]
|
||||
self.DELIMIT=False
|
||||
self.hexdataline=None
|
||||
|
||||
############
|
||||
@irc3.extend
|
||||
###################### ######################################################################################### find every instance of a string within a string
|
||||
def depumper_reset(self):
|
||||
######################
|
||||
|
||||
self.bot.hfh = guds.memory('HYDRA_FILE_HANDLER')()
|
||||
self.bot.ecds = guds.memory('ESCAPE_CODE_DETECTION_SYSTEM')()
|
||||
self.processing_byte=[]
|
||||
self.processing_command=[]
|
||||
self.DELIMIT=False
|
||||
self.hexdataline=None
|
||||
global REASSEMBLY
|
||||
global iCount
|
||||
REASSEMBLY="1B5B306D"
|
||||
iCount=-1
|
||||
|
||||
|
||||
############
|
||||
@irc3.extend
|
||||
###################### ######################################################################################### find every instance of a string within a string
|
||||
def findall(self,s,w):
|
||||
######################
|
||||
|
||||
result=[i for i in range(len(s)) if s.startswith(w, i)]
|
||||
|
||||
#############
|
||||
return result
|
||||
#############
|
||||
|
||||
############
|
||||
@irc3.extend
|
||||
####################### ######################################################################################## used to strip a string of escape codes
|
||||
def stripcodes(self,s):
|
||||
#######################
|
||||
|
||||
codes=[]
|
||||
buffer=s
|
||||
escapes=self.findall(s,'\x1b')
|
||||
commands=self.findall(s,'m')
|
||||
if not len(escapes)==len(commands):
|
||||
for i,_ in enumerate(commands):
|
||||
try:
|
||||
int(commands[i])
|
||||
except:
|
||||
commands.pop(i)
|
||||
if len(escapes)==len(commands):
|
||||
for i in range(len(escapes)):
|
||||
codes.append(s[escapes[i]:commands[i]+1])
|
||||
for _ in codes:
|
||||
buffer=buffer.replace(_,'')
|
||||
|
||||
#############
|
||||
return buffer
|
||||
#############
|
||||
|
||||
############
|
||||
@irc3.extend
|
||||
################################################################################################################ used to make sure a string fits into a space
|
||||
def padding(self,s,n):
|
||||
######################
|
||||
|
||||
pad=n-len(self.stripcodes(s))
|
||||
padding=(" "*pad)
|
||||
s+=padding
|
||||
|
||||
########
|
||||
return s
|
||||
########
|
||||
|
||||
############
|
||||
@irc3.extend
|
||||
############################ ######################################################################################
|
||||
def process_irc_codes(self,ecds):
|
||||
############################
|
||||
|
||||
# self.bot = self
|
||||
self.ecds = ecds
|
||||
dsm=self.DR1P_STATE_MACHINE()
|
||||
if not guds.memory('DR1P_STATE_MACHINEE'):
|
||||
globals()['guds'].memories.append([dsm,'net_krylon_plugin:__new__.DR1P_STATE_MACHINE(DSM)'])
|
||||
|
||||
for i in range(0,len(self.ecds.l)):
|
||||
|
||||
#########################
|
||||
# REQUIRES MOTION FROM CRONJOB
|
||||
#########################
|
||||
DYTE=hex(self.ecds.l[i])[2:].zfill(2).upper()
|
||||
DINT=hex(self.ecds.l[i])
|
||||
self.processing_byte.append(DYTE)
|
||||
dsm.push(DINT)
|
||||
if DYTE=='03':
|
||||
self.processing_command.append(f'{COLOR_SET_B}>> {self.padding("^ESCAPE CODE:",10)} 1B{COLOR_SET_D}')
|
||||
elif DYTE=='0A':
|
||||
self.processing_command.append(f'{COLOR_SET_B}>> {self.padding("ENTER NEWLINE",10)} {COLOR_SET_D}')
|
||||
elif 0x30 <= self.ecds.l[i] <= 0x39:
|
||||
b=1; dytes=[hex(self.ecds.l[i])[2:].zfill(2).upper()]
|
||||
|
||||
if 0x30 <= self.ecds.l[i+1] <= 0x39:
|
||||
b+=1
|
||||
dytes.append(f'{hex(self.ecds.l[i+1])[2:].zfill(2).upper()}')
|
||||
|
||||
LAYER='None'
|
||||
|
||||
if b==1:
|
||||
|
||||
if hex(self.ecds.l[i])[2:].zfill(2).upper()=='2C':
|
||||
LAYER='FG COLOR'
|
||||
elif hex(self.ecds.l[i])[2:].zfill(2).upper()=='03':
|
||||
LAYER='FG COLOR'
|
||||
if 0x30 <= self.ecds.l[i-1] <= 0x39:
|
||||
b-=1; dytes=""; LAYER=""
|
||||
if dytes or LAYER:
|
||||
if self.DELIMIT:
|
||||
self.DELIMIT=False; LAYER="BG COLOR"
|
||||
else:
|
||||
LAYER="FG COLOR"
|
||||
self.processing_command.append(f'{COLOR_SET_C}>> {b} {self.padding("CODE BYTES:",11)} {dytes} - {LAYER}{COLOR_SET_E}')
|
||||
else:
|
||||
self.processing_command.append(f"{COLOR_SET_C}>> {self.padding('- CODE BYTES:',11)} ['{DYTE}']")
|
||||
|
||||
if b==2:
|
||||
|
||||
if hex(self.ecds.l[i+2])[2:].zfill(2).upper()=='2C':
|
||||
LAYER='FG COLOR'
|
||||
else:
|
||||
LAYER='BG COLOR'
|
||||
if hex(self.ecds.l[i-1])[2:].zfill(2).upper()=='03' or hex(self.ecds.l[i-1])[2:].zfill(2).upper()=='2C':
|
||||
self.processing_command.append(f'{COLOR_SET_C}>> {b} {self.padding("CODE BYTES:",11)} {dytes} - {LAYER}{COLOR_SET_D}')
|
||||
else:
|
||||
self.processing_command.append(f'{COLOR_SET_A}>> {b} {self.padding("CODE BYTES:",11)} {dytes} - {LAYER}')
|
||||
# if DEBUGGING:
|
||||
# return self.ecds.l
|
||||
elif DYTE=='2C':
|
||||
self.processing_command.append(f"{COLOR_SET_B}>> {self.padding('CODE DELIMIT:',11)} ['3B']")
|
||||
self.DELIMIT=True
|
||||
else:
|
||||
self.processing_command.append(f'{COLOR_SET_E}..')
|
||||
|
||||
if DEBUGGING: print(f'{">"*64} [ {len(REASSEMBLY)} CHARS - {len(REASSEMBLY)//2} BYTES ] {REASSEMBLY}')
|
||||
|
||||
#####################
|
||||
return self.ecds.l
|
||||
#####################
|
||||
|
||||
#############################
|
||||
@irc3.event(irc3.rfc.PRIVMSG)
|
||||
########################################################################## ########################################
|
||||
def on_privmsg(self, mask=None, event=None, target=None, data=None, **kw):
|
||||
##########################################################################
|
||||
|
||||
if mask.nick == self.bot.nick: return
|
||||
self.hexdataline = ''
|
||||
inverse = self.bot.ecds.REGEX.sub("", data)
|
||||
if inverse != data:
|
||||
for c in data:
|
||||
self.hexdataline += hex(ord(c))[2:].upper()
|
||||
self.bot.ecds.push(mask.nick, target, data, self.hexdataline)
|
||||
|
||||
################################################################################################################### DMZ
|
||||
# DMZ #################################################################################################################
|
||||
################################################################################################################### DMZ
|
||||
|
||||
######################
|
||||
@cron('* * * * * */1')
|
||||
###################### ################################################################################################
|
||||
|
||||
###################### ################################################################################################
|
||||
def ecds_cronjob(bot):
|
||||
######################
|
||||
|
||||
ecds = bot.ecds
|
||||
|
||||
##############################
|
||||
if bot.ecds.buffering == True:
|
||||
##############################
|
||||
|
||||
ecds.cycle += 1
|
||||
for z, entry in enumerate(ecds.sorting):
|
||||
if entry[1]:
|
||||
distances = []
|
||||
timestamps = entry[3]
|
||||
ecds.lastcount = ecds.count
|
||||
ecds.count = len(timestamps)
|
||||
|
||||
if ecds.count != ecds.lastcount: return
|
||||
|
||||
timestamps.reverse()
|
||||
for i in range(0, len(timestamps)-1):
|
||||
distance = timestamps[i]-timestamps[i+1]
|
||||
distances.append(distance)
|
||||
longest_distance = max(distances)
|
||||
timestamp = datetime.now().timestamp()
|
||||
active_distance = timestamp-timestamps[0]
|
||||
if active_distance > longest_distance*2.0:
|
||||
ecds.sorting[z][1] = False
|
||||
nick = ecds.sorting[z][0]
|
||||
channel = ecds.sorting[z][2]
|
||||
ecds.sorted.append([nick, channel, entry[4], entry[5]])
|
||||
ecds.sorting.remove(ecds.sorting[z])
|
||||
ecds_sorted = ecds.sorted[-1]
|
||||
for dataline in ecds_sorted[2]:
|
||||
ecds.f1.write(f"{dataline}\n") # file handle f1
|
||||
# bot.privmsg(hydrachan,dataline)
|
||||
|
||||
########################
|
||||
SELF_DISABLE_FLAG = True
|
||||
########################
|
||||
|
||||
try:
|
||||
for ecds_sorting in ecds.sorting:
|
||||
for isnotdisabled in ecds_sorting[1]:
|
||||
if isnotdisabled:
|
||||
#########################
|
||||
SELF_DISABLE_FLAG = False
|
||||
#########################
|
||||
except:
|
||||
pass
|
||||
|
||||
#####################
|
||||
if SELF_DISABLE_FLAG:
|
||||
#####################
|
||||
|
||||
msg = f'<<< ________ansi_plugin >>> [ event: control code buffer ]'
|
||||
msg += ' - '
|
||||
msg += 'finished, disabling cleanup cronjob'
|
||||
print(msg)
|
||||
ecds.buffering = False
|
||||
|
||||
|
||||
bot.ecds.f1.close() # file handle f1
|
||||
print('\x1b[36m'+'█'*16+'\n█ \x1b[32mDEPUMPER █\n'+'█'*16)
|
||||
|
||||
try:
|
||||
ecds.IN__FILE__UTF8_IRC_ARTWORK_TXT = ecds.FILENAME
|
||||
ecds.OUT_FILE_CP437_ANS_ARTWORK_BIN = ecds.IN__FILE__UTF8_IRC_ARTWORK_TXT+".ans"
|
||||
ecds.f2 = open(ecds.IN__FILE__UTF8_IRC_ARTWORK_TXT, "rb") # file handle f2
|
||||
ecds.l = ecds.f2.read() # file handle f2
|
||||
ecds.f2.close() # file handle f2
|
||||
except:
|
||||
print('\n\x1b[31mERROR: NO INPUT BUFFER/FILE')
|
||||
|
||||
try:
|
||||
if DEBUGGING:
|
||||
print(chr(27)+"[2J")
|
||||
print(f'\x1b[36mPROCESSING: {ecds.IN__FILE__UTF8_IRC_ARTWORK_TXT}')
|
||||
|
||||
#################################
|
||||
#################################printhex(main(DR1P_STATE_MACHINE))
|
||||
#################################
|
||||
bot.process_irc_codes(ecds)
|
||||
#################################
|
||||
#################################
|
||||
#################################
|
||||
|
||||
irc_bytes = []
|
||||
for i in range(len(REASSEMBLY)//2):
|
||||
irc_bytes.append(int(REASSEMBLY[i*2:i*2+2], 16))
|
||||
bot.ecds.f3 = open(bot.ecds.OUT_FILE_CP437_ANS_ARTWORK_BIN, 'wb') # file handle f3
|
||||
bad_byte_seq = [226, 150, 172]
|
||||
good_byte_seq = []
|
||||
rebuilt_bytes = []
|
||||
baseptr = 0
|
||||
|
||||
try:
|
||||
FOUND = [ (i, i+len(bad_byte_seq)) for i in range(len(irc_bytes)) if irc_bytes[i:i+len(bad_byte_seq)] == bad_byte_seq ]
|
||||
|
||||
for offset in FOUND:
|
||||
good_byte_seq.append([x for x in irc_bytes[baseptr:offset[0]]])
|
||||
good_byte_seq.append([95])
|
||||
baseptr = offset[1]
|
||||
|
||||
good_byte_seq.append(irc_bytes[baseptr:])
|
||||
|
||||
for _ in good_byte_seq:
|
||||
try:
|
||||
for __ in _:
|
||||
rebuilt_bytes.append(__)
|
||||
except:
|
||||
pass
|
||||
|
||||
irc_bytes = rebuilt_bytes
|
||||
|
||||
except Exception as e:
|
||||
print(f"error: pre-codec-conversion: {e}")
|
||||
|
||||
try:
|
||||
irc_bytes = bytes(irc_bytes).decode().encode('cp437')
|
||||
bot.ecds.f3.write(irc_bytes) # file handle f3
|
||||
except Exception as e:
|
||||
print(f"error: post-codec-conversion: {e}")
|
||||
|
||||
bot.ecds.f3.close() # file handle f3
|
||||
|
||||
MSG=f'\x1b[32mSUCCESS:\n'
|
||||
MSG+=f'\x1b[35mIN < PROCESSED: {bot.ecds.IN__FILE__UTF8_IRC_ARTWORK_TXT}\n'
|
||||
MSG+=f'\x1b[35mOUT > RENDERED: {bot.ecds.OUT_FILE_CP437_ANS_ARTWORK_BIN}'
|
||||
print(MSG)
|
||||
|
||||
###########################################################
|
||||
if os.path.exists(bot.ecds.OUT_FILE_CP437_ANS_ARTWORK_BIN):
|
||||
###########################################################
|
||||
|
||||
fin = bot.ecds.OUT_FILE_CP437_ANS_ARTWORK_BIN
|
||||
fout = fin+".png"
|
||||
|
||||
print('\x1b[36m'+'█'*16 +'\n█ \x1b[32mANSILOVE █\n'+'█'*16)
|
||||
|
||||
lines = REGEX.sub('', bot.stripcodes(bot.ecds.l.decode())).splitlines()
|
||||
columns = (sum([len(x) for x in lines])//len(lines)//1)+1
|
||||
subprocess.call(["ansilove", "-r", fin, "-c", str(columns)])
|
||||
|
||||
########################
|
||||
if os.path.exists(fout):
|
||||
########################
|
||||
|
||||
###############
|
||||
OK_FLAG = False
|
||||
###############
|
||||
|
||||
files = {'upload': open(fin+".png", 'rb'), }
|
||||
response = requests.post("https://tcp.ac/i/put", files=files, auth=('tcpac', 'kuevEacshmej5'))
|
||||
|
||||
for _ in response.text.split(',')[0].split('"'):
|
||||
if 'https://tcp.ac/i/' in _:
|
||||
bot.ecds.url_tcpac = _
|
||||
OK_FLAG = True
|
||||
|
||||
###########
|
||||
if OK_FLAG:
|
||||
###########
|
||||
|
||||
MSG = f'\x02\x0302{bot.ecds.sorted[-1][0]} \x0F\x1D'
|
||||
MSG+= f'◹ \x02\x0303\x1D\x1Fansilove \x0F\x1D◸ \x0F\x1D'
|
||||
MSG+= f'◹ \x0F\x02\x0312{bot.ecds.url_tcpac} \x0F\x1D◸'
|
||||
MSG=bot.emo(MSG)
|
||||
bot.privmsg(bot.ecds.sorted[-1][1], MSG)
|
||||
|
||||
print('\x1b[36m'+'█'*16 +'\n█ \x1b[32mREPUMPED █\n'+'█'*16)
|
||||
|
||||
try: bot.ecds.f1.close()
|
||||
except: print('error: f1 already closed')
|
||||
|
||||
try: bot.ecds.f2.close()
|
||||
except: print('error: f2 already closed')
|
||||
|
||||
try: bot.ecds.f3.close()
|
||||
except: print('error: f3 already closed')
|
||||
|
||||
except Exception as e:
|
||||
print(f'\x1b[31mFAILURE: {e}')
|
||||
|
||||
###########################################################
|
||||
###########################################################
|
||||
|
||||
del bot.ecds;
|
||||
bot.ecds = guds.memory('ESCAPE_CODE_DETECTION_SYSTEM')()
|
||||
bot.depumper_reset()
|
||||
###########################################################
|
||||
###########################################################
|
||||
|
||||
################################################################################################################### EOF
|
||||
|
||||
"""# MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMmyydMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM ####
|
||||
#### MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMh- .sNMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM ####
|
||||
#### MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMN+' '+NMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM ####
|
||||
#### MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM/ .NMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM ####
|
||||
#### MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM. yMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM ####
|
||||
#### MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM. oMMMMMMMMMMMMMMMMMMMMMMMMMMMNNNNNNMMMMMMMMM ####
|
||||
#### MMMMMd/.''''''..-/+shmMMMMMMMMMMMMMMMMMMMh .NMMMMMMMMMMMMMMMMMMmhs+:-'' ':dMMMMM ####
|
||||
#### MMMh: '+mMMMMMMMMMMMMMMMh' -NMMMMMMMMMMMMMMNs. :hMMM ####
|
||||
#### MN/ -omMMMMMMMMMMN+ .hMMMMMMMMMMmy: +MM ####
|
||||
#### MMMdo. ./sdNMMMNs' :hMMMNds/. :yN### ####
|
||||
#### MMMMMMd+' .-/' ..' -sNMMM### ####
|
||||
#### MMMMMMMMNs- '+dMMMMMMMMM ####
|
||||
#### MMMMMMMMMMMh: -. .. 'oNMMMMMMMMMMM ####
|
||||
#### MMMMMMMMMMMMMd: '+dmho. .odNdo. 'sNMMMMMMMMMMMMM ####
|
||||
#### MMMMMMMMMMMMMMMh. '+dm+' ':/:' '-//. .smo- oNMMMMMMMMMMMMMMM ####
|
||||
#### MMMMMMMMMMMMMMMMs .:+s/' ./+:.' 'MMMMMMMMMMMMMMMMM ####
|
||||
#### MMMMMMMMMMMMMMMMd -MMMMMMMMMMMMMMMMM ####
|
||||
#### MMMMMMMMMMMMMMMMMys+/-' .:+oshMMMMMMMMMMMMMMMMM ####
|
||||
#### MMMMMMMMMMMMMMMMMMMMMMMds: .+hNMMMMMMMMMMMMMMMMMMMMMMM ####
|
||||
#### MMMMMMMMMMMMMMMMMMMMMMMMMMN. oMMMMMMMMMMMMMMMMMMMMMMMMMMM ####
|
||||
#### MMMMMMMMMMMMMMMMMMMMMMMMMMM. '-/-' yMMMMMMMMMMMMMMMMMMMMMMMMMMM ####
|
||||
#### MMMMMMMMMMMMMMMMMMMMMMMMMMN .mNMMMMMNmy sMMMMMMMMMMMMMMMMMMMMMMMMMMM ####
|
||||
#### MMMMMMMMMMMMMMMMMMMMMMMMMMs ': sMMMMMMMMMM: - :MMMMMMMMMMMMMMMMMMMMMMMMMMM ####
|
||||
#### MMMMMMMMMMMMMMMMMMMMMMMMMM. 'oNN. .NMMMMMMMMMMm' md: dMMMMMMMMMMMMMMMMMMMMMMMMMM ####
|
||||
#### MMMMMMMMMMMMMMMMMMMMMMMMMs 'oNMMMh' hMMMMMMMMMMMMs +MMMd/ -MMMMMMMMMMMMMMMMMMMMMMMMMM ####
|
||||
#### MMMMMMMMMMMMMMMMMMMMMMMMd' :yMMMMMMMy' oMMMMMMMMMMMMMM- :MMMMMMmo. +MMMMMMMMMMMMMMMMMMMMMMMMM ####
|
||||
#### MMMMMMMMMMMMMMMMMMMMMMMN/smMMMMMMMMMMd' -MMMMMMMMMMMMMMMs +MMMMMMMMMMd+sMMMMMMMMMMMMMMMMMMMMMMMM ####
|
||||
#### MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMm- -MMMMMMMMMMMMMMMy 'yMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM ####
|
||||
#### MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMN+ mMMMMMMMMMMMMMMo /mMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM ####
|
||||
#### MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMshMMMMMMMMMMMMMM+hMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM ####
|
||||
#### MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM #"""
|
||||
Loading…
Reference in New Issue