forked from zgrep/happybot
387 lines
13 KiB
Python
387 lines
13 KiB
Python
#!/usr/bin/env python3
|
|
|
|
from subprocess import Popen, PIPE
|
|
from os import chdir, environ
|
|
from pathlib import Path
|
|
import re
|
|
|
|
# Make sure we're in the correct directory, for module imports and such too.
|
|
basedir = Path(environ.get('basedir', '.'))
|
|
chdir(basedir)
|
|
|
|
def cmd(args):
|
|
proc = Popen(args, stdout=PIPE)
|
|
while True:
|
|
line = proc.stdout.readline()
|
|
if line:
|
|
try:
|
|
yield str(line[:-1], 'utf-8', 'ignore')
|
|
except:
|
|
pass
|
|
else:
|
|
break
|
|
|
|
def irc(chan):
|
|
global trigger
|
|
server = environ.get('serv', 'irc.libera.chat')
|
|
fdir = '/home/zgrep/offtopiabday/' + server + '/' + chan
|
|
fin = fdir + '/in'
|
|
fout = fdir + '/out'
|
|
|
|
for line in cmd(['tail', '-n', '0', '-f', fout]):
|
|
date, time, nick, line = line.split(' ', 3)
|
|
if nick[0] != '<' or nick[-1] != '>':
|
|
continue
|
|
nick = nick[1:-1]
|
|
m = re.match(r'(?i)^(?:@?(?:happy|hate)bot[:,] (?:unicode|char)|!char) ((?:-[8qvd]+ )+)?(.+)$', line)
|
|
if m:
|
|
flags, query = m.groups()
|
|
if not flags:
|
|
flags = ''
|
|
result = doit(flags, query).split('\n')
|
|
result = [ f'\u200b{nick}: ' + line for line in result ]
|
|
result = result[:4] # capping at 4 lines max
|
|
result = '\n'.join(result)
|
|
with open(fin, 'w') as fh:
|
|
fh.write(result + '\n')
|
|
|
|
from collections import defaultdict
|
|
from math import ceil, log
|
|
from random import choice
|
|
import json
|
|
|
|
# Copied from: https://www.unicode.org/reports/tr44/#GC_Values_Table
|
|
categories = '''
|
|
Lu Uppercase_Letter an uppercase letter
|
|
Ll Lowercase_Letter a lowercase letter
|
|
Lt Titlecase_Letter a digraphic character, with first part uppercase
|
|
LC Cased_Letter Lu | Ll | Lt
|
|
Lm Modifier_Letter a modifier letter
|
|
Lo Other_Letter other letters, including syllables and ideographs
|
|
L Letter Lu | Ll | Lt | Lm | Lo
|
|
Mn Nonspacing_Mark a nonspacing combining mark (zero advance width)
|
|
Mc Spacing_Mark a spacing combining mark (positive advance width)
|
|
Me Enclosing_Mark an enclosing combining mark
|
|
M Mark Mn | Mc | Me
|
|
Nd Decimal_Number a decimal digit
|
|
Nl Letter_Number a letterlike numeric character
|
|
No Other_Number a numeric character of other type
|
|
N Number Nd | Nl | No
|
|
Pc Connector_Punctuation a connecting punctuation mark, like a tie
|
|
Pd Dash_Punctuation a dash or hyphen punctuation mark
|
|
Ps Open_Punctuation an opening punctuation mark (of a pair)
|
|
Pe Close_Punctuation a closing punctuation mark (of a pair)
|
|
Pi Initial_Punctuation an initial quotation mark
|
|
Pf Final_Punctuation a final quotation mark
|
|
Po Other_Punctuation a punctuation mark of other type
|
|
P Punctuation Pc | Pd | Ps | Pe | Pi | Pf | Po
|
|
Sm Math_Symbol a symbol of mathematical use
|
|
Sc Currency_Symbol a currency sign
|
|
Sk Modifier_Symbol a non-letterlike modifier symbol
|
|
So Other_Symbol a symbol of other type
|
|
S Symbol Sm | Sc | Sk | So
|
|
Zs Space_Separator a space character (of various non-zero widths)
|
|
Zl Line_Separator U+2028 LINE SEPARATOR only
|
|
Zp Paragraph_Separator U+2029 PARAGRAPH SEPARATOR only
|
|
Z Separator Zs | Zl | Zp
|
|
Cc Control a C0 or C1 control code
|
|
Cf Format a format control character
|
|
Cs Surrogate a surrogate code point
|
|
Co Private_Use a private-use character
|
|
Cn Unassigned a reserved unassigned code point or a noncharacter
|
|
C Other Cc | Cf | Cs | Co | Cn
|
|
'''.strip().split('\n')
|
|
categories = [ row.split('\t', 2) for row in categories ]
|
|
categories = { left: (right.replace('_', ' '), righter) for left, right, righter in categories if len(left) == 2 }
|
|
|
|
def utf8uni(ordinal):
|
|
s = hex(int.from_bytes(chr(ordinal).encode('utf-8'), 'big'))[2:]
|
|
if len(s) % 2 == 1:
|
|
s = '0' + s
|
|
return '0x' + s
|
|
|
|
def uniuni(ordinal):
|
|
return 'U+' + hex(ordinal)[2:].zfill(4).upper()
|
|
|
|
UnicodeDataFull = 'UnicodeDataFull.json'
|
|
|
|
tokens = re.compile(r'\s*\b(?:U\+([0-9A-Fa-f]+)|[Uu]([0-9A-F]{4,6})|0x([0-9a-f]+)|0b([01]+))\b\s*')
|
|
invalid = [None, "Cn", False, ["<invalid>"]]
|
|
unknown = [None, "Cn", False, ["<unknown>"]]
|
|
|
|
def doit(flags, query):
|
|
if 'q' in flags and 'v' in flags:
|
|
sub1 = 1
|
|
else:
|
|
sub1 = 0
|
|
|
|
verbosity = (flags.count('v') - sub1) - (flags.count('q') - sub1)
|
|
if verbosity > 0:
|
|
quiet = False
|
|
verbose = True
|
|
elif verbosity < 0:
|
|
quiet = True
|
|
verbose = False
|
|
elif verbosity == 0:
|
|
if sub1:
|
|
quiet = True
|
|
verbose = True
|
|
else:
|
|
quiet = False
|
|
verbose = False
|
|
|
|
if verbosity < -1:
|
|
return choice(['Ssssshh.', '[silence]', 'Complete quie-- oh, darn, I spoke.', '[the sound of nothing]', '[complete silence]'])
|
|
|
|
decode = 'd' in flags
|
|
utf8 = '8' in flags
|
|
|
|
if utf8:
|
|
unif = utf8uni
|
|
else:
|
|
unif = uniuni
|
|
|
|
cache = dict()
|
|
|
|
if len(query) <= 2:
|
|
decode = True
|
|
|
|
if decode:
|
|
search = list(map(ord, query))
|
|
|
|
else:
|
|
index, merge = 0, False
|
|
search = []
|
|
for match in tokens.finditer(query):
|
|
missed = query[index:match.start()]
|
|
if missed:
|
|
if merge:
|
|
search[-1] += missed
|
|
else:
|
|
search.append(missed)
|
|
index = match.end()
|
|
merge = False
|
|
uni1, uni2, hexa, bina = match.groups()
|
|
uni = uni1 or uni2
|
|
if uni:
|
|
search.append(int(uni, 16))
|
|
elif hexa:
|
|
try:
|
|
byt = int(hexa, 16).to_bytes(ceil(len(hexa)/2), 'big').decode('utf-8', 'error')
|
|
search.extend(map(ord, byt))
|
|
except:
|
|
if isinstance(search[-1], str):
|
|
search[-1] += '0x' + hexa
|
|
else:
|
|
search.append('0x' + hexa)
|
|
merge = True
|
|
elif bina:
|
|
try:
|
|
byt = int(bina, 2).to_bytes(ceil(len(bina)/8), 'big').decode('utf-8', 'error')
|
|
search.extend(map(ord, byt))
|
|
except:
|
|
if isinstance(search[-1], str):
|
|
search[-1] += '0b' + bina
|
|
else:
|
|
search.append('0b' + bina)
|
|
merge = True
|
|
missed = query[index:]
|
|
if missed:
|
|
if merge:
|
|
search[-1] += missed
|
|
else:
|
|
search.append(missed)
|
|
|
|
results = [[] for _ in range(len(search))]
|
|
whymatched = defaultdict(set)
|
|
|
|
numbers = defaultdict(list)
|
|
strings = defaultdict(set)
|
|
for i, elem in enumerate(search):
|
|
if isinstance(elem, int):
|
|
numbers[elem].append(i)
|
|
elif isinstance(elem, str):
|
|
strings[elem.lower()].add(i)
|
|
numbers = list(sorted(numbers.items(), reverse=True))
|
|
|
|
# The actual searching.
|
|
filled = set()
|
|
with open(UnicodeDataFull, 'r') as fh:
|
|
for line in fh:
|
|
row = json.loads(line)
|
|
if numbers:
|
|
if row[0] == numbers[-1][0]:
|
|
cache[row[0]] = row
|
|
for index in numbers[-1][1]:
|
|
filled.add(index)
|
|
results[index].append(row[0])
|
|
numbers.pop()
|
|
elif row[1]:
|
|
while numbers and row[0] <= numbers[-1][0] <= row[1]:
|
|
cache[numbers[-1][0]] = row
|
|
for index in numbers[-1][1]:
|
|
filled.add(index)
|
|
results[index].append(numbers[-1][0])
|
|
numbers.pop()
|
|
elif not strings:
|
|
break
|
|
for string, indices in strings.items():
|
|
for i, name in enumerate(row[4]):
|
|
if string in name.lower():
|
|
num = row[0]
|
|
if row[1]:
|
|
num = -num
|
|
cache[num] = row
|
|
# Prioritize shown name matches first for string matches.
|
|
# Also save _why_ it matched.
|
|
if i > 0:
|
|
whymatched[num].add(name)
|
|
for index in indices:
|
|
filled.add(index)
|
|
if not results[index]:
|
|
results[index] = [[], []]
|
|
results[index][i > 0].append(num)
|
|
break
|
|
|
|
# Merge priority and non-priority matches.
|
|
for string, indices in strings.items():
|
|
for index in indices & filled:
|
|
results[index] = results[index][0] + results[index][1]
|
|
|
|
missing = set(range(len(search))) - filled
|
|
numbers = defaultdict(list)
|
|
indices = set()
|
|
for i in missing:
|
|
elem = search[i]
|
|
if isinstance(elem, int):
|
|
cache[elem] = [elem] + invalid
|
|
results[i].append(elem)
|
|
elif isinstance(elem, str):
|
|
results[i] = [None] * len(elem)
|
|
for j, c in enumerate(elem):
|
|
numbers[ord(c)].append((i, j))
|
|
indices.add((i, j))
|
|
numbers = list(sorted(numbers.items(), reverse=True))
|
|
|
|
if indices:
|
|
# Decoding what we have left, just some numbers.
|
|
with open(UnicodeDataFull, 'r') as fh:
|
|
for line in fh:
|
|
row = json.loads(line)
|
|
if numbers:
|
|
if row[0] == numbers[-1][0]:
|
|
cache[row[0]] = row
|
|
for i, j in numbers[-1][1]:
|
|
indices.remove((i, j))
|
|
results[i][j] = row[0]
|
|
numbers.pop()
|
|
elif row[1]:
|
|
while numbers and row[0] <= numbers[-1][0] <= row[1]:
|
|
cache[numbers[-1][0]] = row
|
|
for i, j in numbers[-1][1]:
|
|
indices.remove((i, j))
|
|
results[i][j] = numbers[-1][0]
|
|
numbers.pop()
|
|
else:
|
|
break
|
|
|
|
for i, j in indices:
|
|
num = ord(search[i][j])
|
|
cache[num] = [num] + unknown
|
|
results[i][j] = num
|
|
|
|
if len(search) == 1:
|
|
# This means we've fallen back on decoding our single input as a string.
|
|
# Setting this lets us display output differently, hopefully more usefully.
|
|
decode = True
|
|
|
|
results = [r for inner in results for r in inner]
|
|
|
|
if quiet and not verbose:
|
|
if decode:
|
|
fmt = '{code}'
|
|
else:
|
|
fmt = '{char}'
|
|
join = ' '
|
|
elif verbose and not quiet:
|
|
if verbosity > 1:
|
|
fmt = '{code} [{long_category}, {extra_category}] {names}: {char}'
|
|
else:
|
|
fmt = '{code} [{long_category}] {names}: {char}'
|
|
join = '\n'
|
|
elif quiet and verbose:
|
|
fmt = '{code} [{category}] {name}: {char}'
|
|
join = '\n'
|
|
else:
|
|
fmt = '{code} [{category}] {namee}: {char}'
|
|
join = '\n'
|
|
|
|
def get_output(results):
|
|
output = []
|
|
|
|
for num in results:
|
|
is_range = False
|
|
if num < 0:
|
|
is_range = True
|
|
range_start, range_end, category, compose, names = cache[num]
|
|
if is_range:
|
|
if compose:
|
|
char = '\u25cc' + chr(range_start) + '..\u25cc' + chr(range_end)
|
|
else:
|
|
char = chr(range_start) + '..' + chr(range_end)
|
|
code = unif(range_start) + '..' + unif(range_end)
|
|
else:
|
|
char = chr(num)
|
|
if compose:
|
|
char = '\u25cc' + char
|
|
code = unif(num)
|
|
|
|
extra = ''
|
|
if num in whymatched:
|
|
extra = ' (' + ', '.join(whymatched[num]) + ')'
|
|
|
|
output.append(fmt.format(
|
|
code=code,
|
|
name=names[0],
|
|
namee=names[0] + extra,
|
|
names=', '.join(names),
|
|
char=char,
|
|
category=category,
|
|
long_category=categories[category][0],
|
|
extra_category=categories[category][1],
|
|
))
|
|
|
|
return join.join(output)
|
|
|
|
if quiet:
|
|
output = get_output(results)
|
|
output8 = output.encode('utf-8')
|
|
if len(output8) > 470:
|
|
cut = len(results) // 2
|
|
clen = cut
|
|
tried_okay = set()
|
|
for i in range(ceil(log(len(results), 2)) + 1):
|
|
output8 = (get_output(results[:cut]) + ' ...').encode('utf-8')
|
|
clen //= 2
|
|
if len(output8) < 450:
|
|
tried_okay.add(cut)
|
|
cut += clen
|
|
else:
|
|
cut -= clen
|
|
output = get_output(results[:max(tried_okay)]) + ' ...'
|
|
return output
|
|
else:
|
|
return get_output(results)
|
|
|
|
if __name__ == '__main__':
|
|
from sys import argv
|
|
|
|
if len(argv) == 2:
|
|
irc(argv[1])
|
|
elif len(argv) == 3:
|
|
print(doit(argv[1], argv[2]))
|
|
else:
|
|
print('Usage:', argv[0], '#channel')
|
|
print(' or:', argv[0], '[qvd]*', 'query')
|
|
exit(1)
|