mirror of
https://github.com/erkin/ponysay.git
synced 2024-11-29 15:37:59 +01:00
splitting into multiple files
Signed-off-by: Mattias Andrée <maandree@operamail.com>
This commit is contained in:
Mattias Andrée
parent
9a8fa37ab8
commit
5df821d7cd
9 changed files with 2905 additions and 2784 deletions
2786
src/__main__.py
2786
src/__main__.py
File diff suppressed because it is too large
Load diff
304
src/argparser.py
Normal file
304
src/argparser.py
Normal file
|
|
@ -0,0 +1,304 @@
|
|||
#!/usr/bin/env python3
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
'''
|
||||
ponysay - Ponysay, cowsay reimplementation for ponies
|
||||
Copyright (C) 2012, 2013 Erkin Batu Altunbaş et al.
|
||||
|
||||
This program is free software. It comes without any warranty, to
|
||||
the extent permitted by applicable law. You can redistribute it
|
||||
and/or modify it under the terms of the Do What The Fuck You Want
|
||||
To Public License, Version 2, as published by Sam Hocevar. See
|
||||
http://sam.zoy.org/wtfpl/COPYING for more details.
|
||||
'''
|
||||
from common import *
|
||||
|
||||
|
||||
|
||||
'''
|
||||
Option takes no arguments
|
||||
'''
|
||||
ARGUMENTLESS = 0
|
||||
|
||||
'''
|
||||
Option takes one argument per instance
|
||||
'''
|
||||
ARGUMENTED = 1
|
||||
|
||||
'''
|
||||
Option consumes all following arguments
|
||||
'''
|
||||
VARIADIC = 2
|
||||
|
||||
'''
|
||||
Simple argument parser
|
||||
'''
|
||||
class ArgParser():
|
||||
'''
|
||||
Constructor.
|
||||
The short description is printed on same line as the program name
|
||||
|
||||
@param program:str The name of the program
|
||||
@param description:str Short, single-line, description of the program
|
||||
@param usage:str Formated, multi-line, usage text
|
||||
@param longdescription:str Long, multi-line, description of the program, may be `None`
|
||||
'''
|
||||
def __init__(self, program, description, usage, longdescription = None):
|
||||
self.linuxvt = ('TERM' in os.environ) and (os.environ['TERM'] == 'linux')
|
||||
self.__program = program
|
||||
self.__description = description
|
||||
self.__usage = usage
|
||||
self.__longdescription = longdescription
|
||||
self.__arguments = []
|
||||
self.opts = {}
|
||||
self.optmap = {}
|
||||
|
||||
|
||||
'''
|
||||
Add option that takes no arguments
|
||||
|
||||
@param alternatives:list<str> Option names
|
||||
@param help:str Short description, use `None` to hide the option
|
||||
'''
|
||||
def add_argumentless(self, alternatives, help = None):
|
||||
self.__arguments.append((ARGUMENTLESS, alternatives, None, help))
|
||||
stdalt = alternatives[0]
|
||||
self.opts[stdalt] = None
|
||||
for alt in alternatives:
|
||||
self.optmap[alt] = (stdalt, ARGUMENTLESS)
|
||||
|
||||
'''
|
||||
Add option that takes one argument
|
||||
|
||||
@param alternatives:list<str> Option names
|
||||
@param arg:str The name of the takes argument, one word
|
||||
@param help:str Short description, use `None` to hide the option
|
||||
'''
|
||||
def add_argumented(self, alternatives, arg, help = None):
|
||||
self.__arguments.append((ARGUMENTED, alternatives, arg, help))
|
||||
stdalt = alternatives[0]
|
||||
self.opts[stdalt] = None
|
||||
for alt in alternatives:
|
||||
self.optmap[alt] = (stdalt, ARGUMENTED)
|
||||
|
||||
'''
|
||||
Add option that takes all following argument
|
||||
|
||||
@param alternatives:list<str> Option names
|
||||
@param arg:str The name of the takes arguments, one word
|
||||
@param help:str Short description, use `None` to hide the option
|
||||
'''
|
||||
def add_variadic(self, alternatives, arg, help = None):
|
||||
self.__arguments.append((VARIADIC, alternatives, arg, help))
|
||||
stdalt = alternatives[0]
|
||||
self.opts[stdalt] = None
|
||||
for alt in alternatives:
|
||||
self.optmap[alt] = (stdalt, VARIADIC)
|
||||
|
||||
|
||||
'''
|
||||
Parse arguments
|
||||
|
||||
@param args:list<str> The command line arguments, should include the execute file at index 0, `sys.argv` is default
|
||||
@return :bool Whether no unrecognised option is used
|
||||
'''
|
||||
def parse(self, argv = sys.argv):
|
||||
self.argcount = len(argv) - 1
|
||||
self.files = []
|
||||
|
||||
argqueue = []
|
||||
optqueue = []
|
||||
deque = []
|
||||
for arg in argv[1:]:
|
||||
deque.append(arg)
|
||||
|
||||
dashed = False
|
||||
tmpdashed = False
|
||||
get = 0
|
||||
dontget = 0
|
||||
self.rc = True
|
||||
|
||||
self.unrecognisedCount = 0
|
||||
def unrecognised(arg):
|
||||
self.unrecognisedCount += 1
|
||||
if self.unrecognisedCount <= 5:
|
||||
sys.stderr.write('%s: warning: unrecognised option %s\n' % (self.__program, arg))
|
||||
self.rc = False
|
||||
|
||||
while len(deque) != 0:
|
||||
arg = deque[0]
|
||||
deque = deque[1:]
|
||||
if (get > 0) and (dontget == 0):
|
||||
get -= 1
|
||||
argqueue.append(arg)
|
||||
elif tmpdashed:
|
||||
self.files.append(arg)
|
||||
tmpdashed = False
|
||||
elif dashed: self.files.append(arg)
|
||||
elif arg == '++': tmpdashed = True
|
||||
elif arg == '--': dashed = True
|
||||
elif (len(arg) > 1) and (arg[0] in ('-', '+')):
|
||||
if (len(arg) > 2) and (arg[:2] in ('--', '++')):
|
||||
if dontget > 0:
|
||||
dontget -= 1
|
||||
elif (arg in self.optmap) and (self.optmap[arg][1] == ARGUMENTLESS):
|
||||
optqueue.append(arg)
|
||||
argqueue.append(None)
|
||||
elif '=' in arg:
|
||||
arg_opt = arg[:arg.index('=')]
|
||||
if (arg_opt in self.optmap) and (self.optmap[arg_opt][1] >= ARGUMENTED):
|
||||
optqueue.append(arg_opt)
|
||||
argqueue.append(arg[arg.index('=') + 1:])
|
||||
if self.optmap[arg_opt][1] == VARIADIC:
|
||||
dashed = True
|
||||
else:
|
||||
unrecognised(arg)
|
||||
elif (arg in self.optmap) and (self.optmap[arg][1] == ARGUMENTED):
|
||||
optqueue.append(arg)
|
||||
get += 1
|
||||
elif (arg in self.optmap) and (self.optmap[arg][1] == VARIADIC):
|
||||
optqueue.append(arg)
|
||||
argqueue.append(None)
|
||||
dashed = True
|
||||
else:
|
||||
unrecognised(arg)
|
||||
else:
|
||||
sign = arg[0]
|
||||
i = 1
|
||||
n = len(arg)
|
||||
while i < n:
|
||||
narg = sign + arg[i]
|
||||
i += 1
|
||||
if (narg in self.optmap):
|
||||
if self.optmap[narg][1] == ARGUMENTLESS:
|
||||
optqueue.append(narg)
|
||||
argqueue.append(None)
|
||||
elif self.optmap[narg][1] == ARGUMENTED:
|
||||
optqueue.append(narg)
|
||||
nargarg = arg[i:]
|
||||
if len(nargarg) == 0:
|
||||
get += 1
|
||||
else:
|
||||
argqueue.append(nargarg)
|
||||
break
|
||||
elif self.optmap[narg][1] == VARIADIC:
|
||||
optqueue.append(narg)
|
||||
nargarg = arg[i:]
|
||||
argqueue.append(nargarg if len(nargarg) > 0 else None)
|
||||
dashed = True
|
||||
break
|
||||
else:
|
||||
unrecognised(narg)
|
||||
else:
|
||||
self.files.append(arg)
|
||||
|
||||
i = 0
|
||||
n = len(optqueue)
|
||||
while i < n:
|
||||
opt = optqueue[i]
|
||||
arg = argqueue[i] if len(argqueue) > i else None
|
||||
i += 1
|
||||
opt = self.optmap[opt][0]
|
||||
if (opt not in self.opts) or (self.opts[opt] is None):
|
||||
self.opts[opt] = []
|
||||
if len(argqueue) >= i:
|
||||
self.opts[opt].append(arg)
|
||||
|
||||
for arg in self.__arguments:
|
||||
if arg[0] == VARIADIC:
|
||||
varopt = self.opts[arg[1][0]]
|
||||
if varopt is not None:
|
||||
additional = ','.join(self.files).split(',') if len(self.files) > 0 else []
|
||||
if varopt[0] is None:
|
||||
self.opts[arg[1][0]] = additional
|
||||
else:
|
||||
self.opts[arg[1][0]] = varopt[0].split(',') + additional
|
||||
self.files = []
|
||||
break
|
||||
|
||||
self.message = ' '.join(self.files) if len(self.files) > 0 else None
|
||||
|
||||
if self.unrecognisedCount > 5:
|
||||
sys.stderr.write('%s: warning: %i more unrecognised %s\n' % (self.unrecognisedCount - 5, 'options' if self.unrecognisedCount == 6 else 'options'))
|
||||
|
||||
return self.rc
|
||||
|
||||
|
||||
'''
|
||||
Prints a colourful help message
|
||||
'''
|
||||
def help(self):
|
||||
print('\033[1m%s\033[21m %s %s' % (self.__program, '-' if self.linuxvt else '—', self.__description))
|
||||
print()
|
||||
if self.__longdescription is not None:
|
||||
print(self.__longdescription)
|
||||
print()
|
||||
|
||||
print('\033[1mUSAGE:\033[21m', end='')
|
||||
first = True
|
||||
for line in self.__usage.split('\n'):
|
||||
if first:
|
||||
first = False
|
||||
else:
|
||||
print(' or', end='')
|
||||
print('\t%s' % (line))
|
||||
print()
|
||||
|
||||
maxfirstlen = []
|
||||
for opt in self.__arguments:
|
||||
opt_alts = opt[1]
|
||||
opt_help = opt[3]
|
||||
if opt_help is None:
|
||||
continue
|
||||
first = opt_alts[0]
|
||||
last = opt_alts[-1]
|
||||
if first is not last:
|
||||
maxfirstlen.append(first)
|
||||
maxfirstlen = len(max(maxfirstlen, key = len))
|
||||
|
||||
print('\033[1mSYNOPSIS:\033[21m')
|
||||
(lines, lens) = ([], [])
|
||||
for opt in self.__arguments:
|
||||
opt_type = opt[0]
|
||||
opt_alts = opt[1]
|
||||
opt_arg = opt[2]
|
||||
opt_help = opt[3]
|
||||
if opt_help is None:
|
||||
continue
|
||||
(line, l) = ('', 0)
|
||||
first = opt_alts[0]
|
||||
last = opt_alts[-1]
|
||||
alts = ['', last] if first is last else [first, last]
|
||||
alts[0] += ' ' * (maxfirstlen - len(alts[0]))
|
||||
for opt_alt in alts:
|
||||
if opt_alt is alts[-1]:
|
||||
line += '%colour%' + opt_alt
|
||||
l += len(opt_alt)
|
||||
if opt_type == ARGUMENTED: line += ' \033[4m%s\033[24m' % (opt_arg); l += len(opt_arg) + 1
|
||||
elif opt_type == VARIADIC: line += ' [\033[4m%s\033[24m...]' % (opt_arg); l += len(opt_arg) + 6
|
||||
else:
|
||||
line += ' \033[2m%s\033[22m ' % (opt_alt)
|
||||
l += len(opt_alt) + 6
|
||||
lines.append(line)
|
||||
lens.append(l)
|
||||
|
||||
col = max(lens)
|
||||
col += 8 - ((col - 4) & 7)
|
||||
index = 0
|
||||
for opt in self.__arguments:
|
||||
opt_help = opt[3]
|
||||
if opt_help is None:
|
||||
continue
|
||||
first = True
|
||||
colour = '36' if (index & 1) == 0 else '34'
|
||||
print(lines[index].replace('%colour%', '\033[%s;1m' % (colour)), end=' ' * (col - lens[index]))
|
||||
for line in opt_help.split('\n'):
|
||||
if first:
|
||||
first = False
|
||||
print('%s' % (line), end='\033[21;39m\n')
|
||||
else:
|
||||
print('%s\033[%sm%s\033[39m' % (' ' * col, colour, line))
|
||||
index += 1
|
||||
|
||||
print()
|
||||
|
||||
628
src/backend.py
Normal file
628
src/backend.py
Normal file
|
|
@ -0,0 +1,628 @@
|
|||
#!/usr/bin/env python3
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
'''
|
||||
ponysay - Ponysay, cowsay reimplementation for ponies
|
||||
Copyright (C) 2012, 2013 Erkin Batu Altunbaş et al.
|
||||
|
||||
This program is free software. It comes without any warranty, to
|
||||
the extent permitted by applicable law. You can redistribute it
|
||||
and/or modify it under the terms of the Do What The Fuck You Want
|
||||
To Public License, Version 2, as published by Sam Hocevar. See
|
||||
http://sam.zoy.org/wtfpl/COPYING for more details.
|
||||
'''
|
||||
from common import *
|
||||
|
||||
|
||||
|
||||
'''
|
||||
Super-ultra-extreme-awesomazing replacement for cowsay
|
||||
'''
|
||||
class Backend():
|
||||
'''
|
||||
Constructor
|
||||
|
||||
@param message:str The message spoken by the pony
|
||||
@param ponyfile:str The pony file
|
||||
@param wrapcolumn:int The column at where to wrap the message, `None` for no wrapping
|
||||
@param width:int The width of the screen, `None` if truncation should not be applied
|
||||
@param balloon:Balloon The balloon style object, `None` if only the pony should be printed
|
||||
@param hyphen:str How hyphens added by the wordwrapper should be printed
|
||||
@param linkcolour:str How to colour the link character, empty string if none
|
||||
@param ballooncolour:str How to colour the balloon, empty string if none
|
||||
@param mode:str Mode string for the pony
|
||||
@parma infolevel:int 2 if ++info is used, 1 if --info is used and 0 otherwise
|
||||
'''
|
||||
def __init__(self, message, ponyfile, wrapcolumn, width, balloon, hyphen, linkcolour, ballooncolour, mode, infolevel):
|
||||
self.message = message
|
||||
self.ponyfile = ponyfile
|
||||
self.wrapcolumn = None if wrapcolumn is None else wrapcolumn - (0 if balloon is None else balloon.minwidth)
|
||||
self.width = width
|
||||
self.balloon = balloon
|
||||
self.hyphen = hyphen
|
||||
self.ballooncolour = ballooncolour
|
||||
self.mode = mode
|
||||
self.balloontop = 0
|
||||
self.balloonbottom = 0
|
||||
self.infolevel = infolevel
|
||||
|
||||
if self.balloon is not None:
|
||||
self.link = {'\\' : linkcolour + self.balloon.link,
|
||||
'/' : linkcolour + self.balloon.linkmirror}
|
||||
else:
|
||||
self.link = {}
|
||||
|
||||
self.output = ''
|
||||
self.pony = None
|
||||
|
||||
|
||||
'''
|
||||
Process all data
|
||||
'''
|
||||
def parse(self):
|
||||
self.__loadFile()
|
||||
|
||||
if self.pony.startswith('$$$\n'):
|
||||
self.pony = self.pony[4:]
|
||||
if self.pony.startswith('$$$\n'):
|
||||
infoend = 4
|
||||
info = ''
|
||||
else:
|
||||
infoend = self.pony.index('\n$$$\n')
|
||||
info = self.pony[:infoend]
|
||||
infoend += 5
|
||||
if self.infolevel == 2:
|
||||
self.message = Backend.formatInfo(info)
|
||||
elif self.infolevel == 1:
|
||||
self.pony = Backend.formatInfo(info).replace('$', '$$')
|
||||
else:
|
||||
info = info.split('\n')
|
||||
for line in info:
|
||||
sep = line.find(':')
|
||||
if sep > 0:
|
||||
key = line[:sep].strip()
|
||||
if key == 'BALLOON TOP':
|
||||
value = line[sep + 1:].strip()
|
||||
if len(value) > 0:
|
||||
self.balloontop = int(value)
|
||||
if key == 'BALLOON BOTTOM':
|
||||
value = line[sep + 1:].strip()
|
||||
if len(value) > 0:
|
||||
self.balloonbottom = int(value)
|
||||
printinfo(info)
|
||||
self.pony = self.pony[infoend:]
|
||||
elif self.infolevel == 2:
|
||||
self.message = '\033[01;31mI am the mysterious mare...\033[21;39m'
|
||||
elif self.infolevel == 1:
|
||||
self.pony = 'There is not metadata for this pony file'
|
||||
self.pony = self.mode + self.pony
|
||||
|
||||
self.__expandMessage()
|
||||
self.__unpadMessage()
|
||||
self.__processPony()
|
||||
self.__truncate()
|
||||
|
||||
|
||||
'''
|
||||
Format metadata to be nicely printed, this include bold keys
|
||||
|
||||
@param info:str The metadata
|
||||
@return :str The metadata nicely formated
|
||||
'''
|
||||
@staticmethod
|
||||
def formatInfo(info):
|
||||
info = info.split('\n')
|
||||
tags = ''
|
||||
comment = ''
|
||||
for line in info:
|
||||
sep = line.find(':')
|
||||
if sep > 0:
|
||||
key = line[:sep]
|
||||
test = key
|
||||
for c in 'ABCDEFGHIJKLMN OPQRSTUVWXYZ':
|
||||
test = test.replace(c, '')
|
||||
if (len(test) == 0) and (len(key.replace(' ', '')) > 0):
|
||||
value = line[sep + 1:].strip()
|
||||
line = '\033[1m%s\033[21m: %s\n' % (key.strip(), value)
|
||||
tags += line
|
||||
continue
|
||||
comment += '\n' + line
|
||||
comment = comment.lstrip('\n')
|
||||
if len(comment) > 0:
|
||||
comment = '\n' + comment
|
||||
return tags + comment
|
||||
|
||||
|
||||
'''
|
||||
Remove padding spaces fortune cookies are padded with whitespace (damn featherbrains)
|
||||
'''
|
||||
def __unpadMessage(self):
|
||||
lines = self.message.split('\n')
|
||||
for spaces in (8, 4, 2, 1):
|
||||
padded = True
|
||||
for line in lines:
|
||||
if not line.startswith(' ' * spaces):
|
||||
padded = False
|
||||
break
|
||||
if padded:
|
||||
for i in range(0, len(lines)):
|
||||
line = lines[i]
|
||||
while line.startswith(' ' * spaces):
|
||||
line = line[spaces:]
|
||||
lines[i] = line
|
||||
lines = [line.rstrip(' ') for line in lines]
|
||||
self.message = '\n'.join(lines)
|
||||
|
||||
|
||||
'''
|
||||
Converts all tabs in the message to spaces by expanding
|
||||
'''
|
||||
def __expandMessage(self):
|
||||
lines = self.message.split('\n')
|
||||
buf = ''
|
||||
for line in lines:
|
||||
(i, n, x) = (0, len(line), 0)
|
||||
while i < n:
|
||||
c = line[i]
|
||||
i += 1
|
||||
if c == '\033':
|
||||
colour = Backend.getcolour(line, i - 1)
|
||||
i += len(colour) - 1
|
||||
buf += colour
|
||||
elif c == '\t':
|
||||
nx = 8 - (x & 7)
|
||||
buf += ' ' * nx
|
||||
x += nx
|
||||
else:
|
||||
buf += c
|
||||
if not UCS.isCombining(c):
|
||||
x += 1
|
||||
buf += '\n'
|
||||
self.message = buf[:-1]
|
||||
|
||||
|
||||
'''
|
||||
Loads the pony file
|
||||
'''
|
||||
def __loadFile(self):
|
||||
with open(self.ponyfile, 'rb') as ponystream:
|
||||
self.pony = ponystream.read().decode('utf8', 'replace')
|
||||
|
||||
|
||||
'''
|
||||
Truncate output to the width of the screen
|
||||
'''
|
||||
def __truncate(self):
|
||||
if self.width is None:
|
||||
return
|
||||
lines = self.output.split('\n')
|
||||
self.output = ''
|
||||
for line in lines:
|
||||
(i, n, x) = (0, len(line), 0)
|
||||
while i < n:
|
||||
c = line[i]
|
||||
i += 1
|
||||
if c == '\033':
|
||||
colour = Backend.getcolour(line, i - 1)
|
||||
i += len(colour) - 1
|
||||
self.output += colour
|
||||
else:
|
||||
if x < self.width:
|
||||
self.output += c
|
||||
if not UCS.isCombining(c):
|
||||
x += 1
|
||||
self.output += '\n'
|
||||
self.output = self.output[:-1]
|
||||
|
||||
|
||||
'''
|
||||
Process the pony file and generate output to self.output
|
||||
'''
|
||||
def __processPony(self):
|
||||
self.output = ''
|
||||
|
||||
AUTO_PUSH = '\033[01010~'
|
||||
AUTO_POP = '\033[10101~'
|
||||
|
||||
variables = {'' : '$'}
|
||||
for key in self.link:
|
||||
variables[key] = AUTO_PUSH + self.link[key] + AUTO_POP
|
||||
|
||||
indent = 0
|
||||
dollar = None
|
||||
balloonLines = None
|
||||
colourstack = ColourStack(AUTO_PUSH, AUTO_POP)
|
||||
|
||||
(i, n, lineindex, skip, nonskip) = (0, len(self.pony), 0, 0, 0)
|
||||
while i < n:
|
||||
c = self.pony[i]
|
||||
if c == '\t':
|
||||
n += 7 - (indent & 7)
|
||||
ed = ' ' * (8 - (indent & 7))
|
||||
c = ' '
|
||||
self.pony = self.pony[:i] + ed + self.pony[i + 1:]
|
||||
i += 1
|
||||
if c == '$':
|
||||
if dollar is not None:
|
||||
if '=' in dollar:
|
||||
name = dollar[:dollar.find('=')]
|
||||
value = dollar[dollar.find('=') + 1:]
|
||||
variables[name] = value
|
||||
elif not dollar.startswith('balloon'):
|
||||
data = variables[dollar].replace('$', '$$')
|
||||
if data == '$$': # if not handled specially we will get an infinity loop
|
||||
if (skip == 0) or (nonskip > 0):
|
||||
if nonskip > 0:
|
||||
nonskip -= 1
|
||||
self.output += '$'
|
||||
indent += 1
|
||||
else:
|
||||
skip -= 1
|
||||
else:
|
||||
n += len(data)
|
||||
self.pony = self.pony[:i] + data + self.pony[i:]
|
||||
elif self.balloon is not None:
|
||||
(w, h, x, justify) = ('0', 0, 0, None)
|
||||
props = dollar[7:]
|
||||
if len(props) > 0:
|
||||
if ',' in props:
|
||||
if props[0] is not ',':
|
||||
w = props[:props.index(',')]
|
||||
h = int(props[props.index(',') + 1:])
|
||||
else:
|
||||
w = props
|
||||
if 'l' in w:
|
||||
(x, w) = (int(w[:w.find('l')]), int(w[w.find('l') + 1:]))
|
||||
justify = 'l'
|
||||
w -= x;
|
||||
elif 'c' in w:
|
||||
(x, w) = (int(w[:w.find('c')]), int(w[w.find('c') + 1:]))
|
||||
justify = 'c'
|
||||
w -= x;
|
||||
elif 'r' in w:
|
||||
(x, w) = (int(w[:w.find('r')]), int(w[w.find('r') + 1:]))
|
||||
justify = 'r'
|
||||
w -= x;
|
||||
else:
|
||||
w = int(w)
|
||||
balloon = self.__getballoon(w, h, x, justify, indent)
|
||||
balloon = balloon.split('\n')
|
||||
balloon = [AUTO_PUSH + self.ballooncolour + item + AUTO_POP for item in balloon]
|
||||
for b in balloon[0]:
|
||||
self.output += b + colourstack.feed(b)
|
||||
if lineindex == 0:
|
||||
balloonpre = '\n' + (' ' * indent)
|
||||
for line in balloon[1:]:
|
||||
self.output += balloonpre;
|
||||
for b in line:
|
||||
self.output += b + colourstack.feed(b);
|
||||
indent = 0
|
||||
elif len(balloon) > 1:
|
||||
balloonLines = balloon
|
||||
balloonLine = 0
|
||||
balloonIndent = indent
|
||||
indent += Backend.len(balloonLines[0])
|
||||
balloonLines[0] = None
|
||||
dollar = None
|
||||
else:
|
||||
dollar = ''
|
||||
elif dollar is not None:
|
||||
if c == '\033':
|
||||
c = self.pony[i]
|
||||
i += 1
|
||||
dollar += c
|
||||
elif c == '\033':
|
||||
colour = Backend.getcolour(self.pony, i - 1)
|
||||
for b in colour:
|
||||
self.output += b + colourstack.feed(b);
|
||||
i += len(colour) - 1
|
||||
elif c == '\n':
|
||||
self.output += c
|
||||
indent = 0
|
||||
(skip, nonskip) = (0, 0)
|
||||
lineindex += 1
|
||||
if balloonLines is not None:
|
||||
balloonLine += 1
|
||||
if balloonLine == len(balloonLines):
|
||||
balloonLines = None
|
||||
else:
|
||||
if (balloonLines is not None) and (balloonLines[balloonLine] is not None) and (balloonIndent == indent):
|
||||
data = balloonLines[balloonLine]
|
||||
datalen = Backend.len(data)
|
||||
skip += datalen
|
||||
nonskip += datalen
|
||||
data = data.replace('$', '$$')
|
||||
n += len(data)
|
||||
self.pony = self.pony[:i] + data + self.pony[i:]
|
||||
balloonLines[balloonLine] = None
|
||||
else:
|
||||
if (skip == 0) or (nonskip > 0):
|
||||
if nonskip > 0:
|
||||
nonskip -= 1
|
||||
self.output += c + colourstack.feed(c);
|
||||
if not UCS.isCombining(c):
|
||||
indent += 1
|
||||
else:
|
||||
skip -= 1
|
||||
|
||||
if balloonLines is not None:
|
||||
for line in balloonLines[balloonLine:]:
|
||||
data = ' ' * (balloonIndent - indent) + line + '\n'
|
||||
for b in data:
|
||||
self.output += b + colourstack.feed(b);
|
||||
indent = 0
|
||||
|
||||
self.output = self.output.replace(AUTO_PUSH, '').replace(AUTO_POP, '')
|
||||
|
||||
if self.balloon is not None:
|
||||
if (self.balloontop > 0) or (self.balloonbottom > 0):
|
||||
self.output = self.output.split('\n')
|
||||
self.output = self.output[self.balloontop : ~(self.balloonbottom)]
|
||||
self.output = '\n'.join(self.output)
|
||||
|
||||
|
||||
'''
|
||||
Gets colour code att the currect offset in a buffer
|
||||
|
||||
@param input:str The input buffer
|
||||
@param offset:int The offset at where to start reading, a escape must begin here
|
||||
@return :str The escape sequence
|
||||
'''
|
||||
@staticmethod
|
||||
def getcolour(input, offset):
|
||||
(i, n) = (offset, len(input))
|
||||
rc = input[i]
|
||||
i += 1
|
||||
if i == n: return rc
|
||||
c = input[i]
|
||||
i += 1
|
||||
rc += c
|
||||
|
||||
if c == ']':
|
||||
if i == n: return rc
|
||||
c = input[i]
|
||||
i += 1
|
||||
rc += c
|
||||
if c == 'P':
|
||||
di = 0
|
||||
while (di < 7) and (i < n):
|
||||
c = input[i]
|
||||
i += 1
|
||||
di += 1
|
||||
rc += c
|
||||
while c == '0':
|
||||
c = input[i]
|
||||
i += 1
|
||||
rc += c
|
||||
if c == '4':
|
||||
c = input[i]
|
||||
i += 1
|
||||
rc += c
|
||||
if c == ';':
|
||||
c = input[i]
|
||||
i += 1
|
||||
rc += c
|
||||
while c != '\\':
|
||||
c = input[i]
|
||||
i += 1
|
||||
rc += c
|
||||
elif c == '[':
|
||||
while i < n:
|
||||
c = input[i]
|
||||
i += 1
|
||||
rc += c
|
||||
if (c == '~') or (('a' <= c) and (c <= 'z')) or (('A' <= c) and (c <= 'Z')):
|
||||
break
|
||||
|
||||
return rc
|
||||
|
||||
|
||||
'''
|
||||
Calculates the number of visible characters in a text
|
||||
|
||||
@param input:str The input buffer
|
||||
@return :int The number of visible characters
|
||||
'''
|
||||
@staticmethod
|
||||
def len(input):
|
||||
(rc, i, n) = (0, 0, len(input))
|
||||
while i < n:
|
||||
c = input[i]
|
||||
if c == '\033':
|
||||
i += len(Backend.getcolour(input, i))
|
||||
else:
|
||||
i += 1
|
||||
if not UCS.isCombining(c):
|
||||
rc += 1
|
||||
return rc
|
||||
|
||||
|
||||
'''
|
||||
Generates a balloon with the message
|
||||
|
||||
@param width:int The minimum width of the balloon
|
||||
@param height:int The minimum height of the balloon
|
||||
@param innerleft:int The left column of the required span, excluding that of `left`
|
||||
@param justify:str Balloon placement justification, 'c' → centered,
|
||||
'l' → left (expand to right), 'r' → right (expand to left)
|
||||
@param left:int The column where the balloon starts
|
||||
@return :str The balloon the the message as a string
|
||||
'''
|
||||
def __getballoon(self, width, height, innerleft, justify, left):
|
||||
wrap = None
|
||||
if self.wrapcolumn is not None:
|
||||
wrap = self.wrapcolumn - left
|
||||
if wrap < 8:
|
||||
wrap = 8
|
||||
|
||||
msg = self.message
|
||||
if wrap is not None:
|
||||
msg = self.__wrapMessage(msg, wrap)
|
||||
|
||||
msg = msg.replace('\n', '\033[0m%s\n' % (self.ballooncolour)) + '\033[0m' + self.ballooncolour
|
||||
msg = msg.split('\n')
|
||||
|
||||
extraleft = 0
|
||||
if justify is not None:
|
||||
msgwidth = self.len(max(msg, key = self.len)) + self.balloon.minwidth
|
||||
extraleft = innerleft
|
||||
if msgwidth > width:
|
||||
if (justify == 'l') and (wrap is not None):
|
||||
if innerleft + msgwidth > wrap:
|
||||
extraleft -= msgwidth - wrap
|
||||
elif justify == 'r':
|
||||
extraleft -= msgwidth - width
|
||||
elif justify == 'c':
|
||||
extraleft -= (msgwidth - width) >> 1
|
||||
if extraleft < 0:
|
||||
extraleft = 0
|
||||
if wrap is not None:
|
||||
if extraleft + msgwidth > wrap:
|
||||
extraleft -= msgwidth - wrap
|
||||
|
||||
rc = self.balloon.get(width, height, msg, Backend.len);
|
||||
if extraleft > 0:
|
||||
rc = ' ' * extraleft + rc.replace('\n', '\n' + ' ' * extraleft)
|
||||
return rc
|
||||
|
||||
|
||||
'''
|
||||
Wraps the message
|
||||
|
||||
@param message:str The message to wrap
|
||||
@param wrap:int The width at where to force wrapping
|
||||
@return :str The message wrapped
|
||||
'''
|
||||
def __wrapMessage(self, message, wrap):
|
||||
wraplimit = os.environ['PONYSAY_WRAP_LIMIT'] if 'PONYSAY_WRAP_LIMIT' in os.environ else ''
|
||||
wraplimit = 8 if len(wraplimit) == 0 else int(wraplimit)
|
||||
|
||||
wrapexceed = os.environ['PONYSAY_WRAP_EXCEED'] if 'PONYSAY_WRAP_EXCEED' in os.environ else ''
|
||||
wrapexceed = 5 if len(wrapexceed) == 0 else int(wrapexceed)
|
||||
|
||||
buf = ''
|
||||
try:
|
||||
AUTO_PUSH = '\033[01010~'
|
||||
AUTO_POP = '\033[10101~'
|
||||
msg = message.replace('\n', AUTO_PUSH + '\n' + AUTO_POP);
|
||||
cstack = ColourStack(AUTO_PUSH, AUTO_POP)
|
||||
for c in msg:
|
||||
buf += c + cstack.feed(c)
|
||||
lines = buf.replace(AUTO_PUSH, '').replace(AUTO_POP, '').split('\n')
|
||||
buf = ''
|
||||
|
||||
for line in lines:
|
||||
b = [None] * len(line)
|
||||
map = {0 : 0}
|
||||
(bi, cols, w) = (0, 0, wrap)
|
||||
(indent, indentc) = (-1, 0)
|
||||
|
||||
(i, n) = (0, len(line))
|
||||
while i <= n:
|
||||
d = None
|
||||
if i < n:
|
||||
d = line[i]
|
||||
i += 1
|
||||
if d == '\033':
|
||||
## Invisible stuff
|
||||
i -= 1
|
||||
colourseq = Backend.getcolour(line, i)
|
||||
b[bi : bi + len(colourseq)] = colourseq
|
||||
i += len(colourseq)
|
||||
bi += len(colourseq)
|
||||
elif (d is not None) and (d != ' '):
|
||||
## Fetch word
|
||||
if indent == -1:
|
||||
indent = i - 1
|
||||
for j in range(0, indent):
|
||||
if line[j] == ' ':
|
||||
indentc += 1
|
||||
b[bi] = d
|
||||
bi += 1
|
||||
if (not UCS.isCombining(d)) and (d != ''):
|
||||
cols += 1
|
||||
map[cols] = bi
|
||||
else:
|
||||
## Wrap?
|
||||
mm = 0
|
||||
bisub = 0
|
||||
iwrap = wrap - (0 if indent == 1 else indentc)
|
||||
|
||||
while ((w > wraplimit) and (cols > w + wrapexceed)) or (cols > iwrap):
|
||||
## wrap
|
||||
x = w;
|
||||
if mm + x not in map: # Too much whitespace?
|
||||
cols = 0
|
||||
break
|
||||
nbsp = b[map[mm + x]] == ' ' # nbsp
|
||||
m = map[mm + x]
|
||||
|
||||
if ('' in b[bisub : m]) and not nbsp: # sort hyphen
|
||||
hyphen = m - 1
|
||||
while b[hyphen] != '': # sort hyphen
|
||||
hyphen -= 1
|
||||
while map[mm + x] > hyphen: ## Only looking backward, if foreward is required the word is probabily not hyphenated correctly
|
||||
x -= 1
|
||||
x += 1
|
||||
m = map[mm + x]
|
||||
|
||||
mm += x - (0 if nbsp else 1) ## − 1 so we have space for a hythen
|
||||
|
||||
for bb in b[bisub : m]:
|
||||
buf += bb
|
||||
buf += '\n' if nbsp else '\0\n'
|
||||
cols -= x - (0 if nbsp else 1)
|
||||
bisub = m
|
||||
|
||||
w = iwrap
|
||||
if indent != -1:
|
||||
buf += line[:indent]
|
||||
|
||||
for j in range(bisub, bi):
|
||||
b[j - bisub] = b[j]
|
||||
bi -= bisub
|
||||
|
||||
if cols > w:
|
||||
buf += '\n'
|
||||
w = wrap
|
||||
if indent != -1:
|
||||
buf += line[:indent]
|
||||
w -= indentc
|
||||
for bb in b[:bi]:
|
||||
if bb is not None:
|
||||
buf += bb
|
||||
w -= cols
|
||||
cols = 0
|
||||
bi = 0
|
||||
if d is None:
|
||||
i += 1
|
||||
else:
|
||||
if w > 0:
|
||||
buf += ' '
|
||||
w -= 1
|
||||
else:
|
||||
buf += '\n'
|
||||
w = wrap
|
||||
if indent != -1:
|
||||
buf + line[:indent]
|
||||
w -= indentc
|
||||
buf += '\n'
|
||||
|
||||
rc = '\n'.join(line.rstrip() for line in buf[:-1].split('\n'));
|
||||
rc = rc.replace('', ''); # remove soft hyphens
|
||||
rc = rc.replace('\0', '%s%s%s' % (AUTO_PUSH, self.hyphen, AUTO_POP))
|
||||
return rc
|
||||
except Exception as err:
|
||||
import traceback
|
||||
errormessage = ''.join(traceback.format_exception(type(err), err, None))
|
||||
rc = '\n'.join(line.rstrip() for line in buf.split('\n'));
|
||||
rc = rc.replace('\0', '%s%s%s' % (AUTO_PUSH, self.hyphen, AUTO_POP))
|
||||
errormessage += '\n---- WRAPPING BUFFER ----\n\n' + rc
|
||||
try:
|
||||
if os.readlink('/proc/self/fd/2') != os.readlink('/proc/self/fd/1'):
|
||||
printerr(errormessage, end='')
|
||||
return message
|
||||
except:
|
||||
pass
|
||||
return message + '\n\n\033[0;1;31m---- EXCEPTION IN PONYSAY WHILE WRAPPING ----\033[0m\n\n' + errormessage
|
||||
|
||||
114
src/balloon.py
Normal file
114
src/balloon.py
Normal file
|
|
@ -0,0 +1,114 @@
|
|||
#!/usr/bin/env python3
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
'''
|
||||
ponysay - Ponysay, cowsay reimplementation for ponies
|
||||
Copyright (C) 2012, 2013 Erkin Batu Altunbaş et al.
|
||||
|
||||
This program is free software. It comes without any warranty, to
|
||||
the extent permitted by applicable law. You can redistribute it
|
||||
and/or modify it under the terms of the Do What The Fuck You Want
|
||||
To Public License, Version 2, as published by Sam Hocevar. See
|
||||
http://sam.zoy.org/wtfpl/COPYING for more details.
|
||||
'''
|
||||
from common import *
|
||||
|
||||
|
||||
|
||||
'''
|
||||
Balloon format class
|
||||
'''
|
||||
class Balloon():
|
||||
'''
|
||||
Constructor
|
||||
|
||||
@param link:str The \-directional balloon line character
|
||||
@param linkmirror:str The /-directional balloon line character
|
||||
@param ww:str See the info manual
|
||||
@param ee:str See the info manual
|
||||
@param nw:list<str> See the info manual
|
||||
@param nnw:list<str> See the info manual
|
||||
@param n:list<str> See the info manual
|
||||
@param nne:list<str> See the info manual
|
||||
@param ne:list<str> See the info manual
|
||||
@param nee:str See the info manual
|
||||
@param e:str See the info manual
|
||||
@param see:str See the info manual
|
||||
@param se:list<str> See the info manual
|
||||
@param sse:list<str> See the info manual
|
||||
@param s:list<str> See the info manual
|
||||
@param ssw:list<str> See the info manual
|
||||
@param sw:list<str> See the info manual
|
||||
@param sww:str See the info manual
|
||||
@param w:str See the info manual
|
||||
@param nww:str See the info manual
|
||||
'''
|
||||
def __init__(self, link, linkmirror, ww, ee, nw, nnw, n, nne, ne, nee, e, see, se, sse, s, ssw, sw, sww, w, nww):
|
||||
(self.link, self.linkmirror) = (link, linkmirror)
|
||||
(self.ww, self.ee) = (ww, ee)
|
||||
(self.nw, self.ne, self.se, self.sw) = (nw, ne, se, sw)
|
||||
(self.nnw, self.n, self.nne) = (nnw, n, nne)
|
||||
(self.nee, self.e, self.see) = (nee, e, see)
|
||||
(self.sse, self.s, self.ssw) = (sse, s, ssw)
|
||||
(self.sww, self.w, self.nww) = (sww, w, nww)
|
||||
|
||||
_ne = max(ne, key = UCS.dispLen)
|
||||
_nw = max(nw, key = UCS.dispLen)
|
||||
_se = max(se, key = UCS.dispLen)
|
||||
_sw = max(sw, key = UCS.dispLen)
|
||||
|
||||
minE = UCS.dispLen(max([_ne, nee, e, see, _se, ee], key = UCS.dispLen))
|
||||
minW = UCS.dispLen(max([_nw, nww, e, sww, _sw, ww], key = UCS.dispLen))
|
||||
minN = len(max([ne, nne, n, nnw, nw], key = len))
|
||||
minS = len(max([se, sse, s, ssw, sw], key = len))
|
||||
|
||||
self.minwidth = minE + minE
|
||||
self.minheight = minN + minS
|
||||
|
||||
|
||||
'''
|
||||
Generates a balloon with a message
|
||||
|
||||
@param minw:int The minimum number of columns of the balloon
|
||||
@param minh:int The minimum number of lines of the balloon
|
||||
@param lines:list<str> The text lines to display
|
||||
@param lencalc:int(str) Function used to compute the length of a text line
|
||||
@return :str The balloon as a formated string
|
||||
'''
|
||||
def get(self, minw, minh, lines, lencalc):
|
||||
h = self.minheight + len(lines)
|
||||
w = self.minwidth + lencalc(max(lines, key = lencalc))
|
||||
if w < minw: w = minw
|
||||
if h < minh: h = minh
|
||||
|
||||
if len(lines) > 1:
|
||||
(ws, es) = ({0 : self.nww, len(lines) - 1 : self.sww}, {0 : self.nee, len(lines) - 1 : self.see})
|
||||
for j in range(1, len(lines) - 1):
|
||||
ws[j] = self.w
|
||||
es[j] = self.e
|
||||
else:
|
||||
(ws, es) = ({0 : self.ww}, {0 : self.ee})
|
||||
|
||||
rc = []
|
||||
|
||||
for j in range(0, len(self.n)):
|
||||
outer = UCS.dispLen(self.nw[j]) + UCS.dispLen(self.ne[j])
|
||||
inner = UCS.dispLen(self.nnw[j]) + UCS.dispLen(self.nne[j])
|
||||
if outer + inner <= w:
|
||||
rc.append(self.nw[j] + self.nnw[j] + self.n[j] * (w - outer - inner) + self.nne[j] + self.ne[j])
|
||||
else:
|
||||
rc.append(self.nw[j] + self.n[j] * (w - outer) + self.ne[j])
|
||||
|
||||
for j in range(0, len(lines)):
|
||||
rc.append(ws[j] + lines[j] + ' ' * (w - lencalc(lines[j]) - UCS.dispLen(self.w) - UCS.dispLen(self.e)) + es[j])
|
||||
|
||||
for j in range(0, len(self.s)):
|
||||
outer = UCS.dispLen(self.sw[j]) + UCS.dispLen(self.se[j])
|
||||
inner = UCS.dispLen(self.ssw[j]) + UCS.dispLen(self.sse[j])
|
||||
if outer + inner <= w:
|
||||
rc.append(self.sw[j] + self.ssw[j] + self.s[j] * (w - outer - inner) + self.sse[j] + self.se[j])
|
||||
else:
|
||||
rc.append(self.sw[j] + self.s[j] * (w - outer) + self.se[j])
|
||||
|
||||
return '\n'.join(rc)
|
||||
|
||||
115
src/colourstack.py
Normal file
115
src/colourstack.py
Normal file
|
|
@ -0,0 +1,115 @@
|
|||
#!/usr/bin/env python3
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
'''
|
||||
ponysay - Ponysay, cowsay reimplementation for ponies
|
||||
Copyright (C) 2012, 2013 Erkin Batu Altunbaş et al.
|
||||
|
||||
This program is free software. It comes without any warranty, to
|
||||
the extent permitted by applicable law. You can redistribute it
|
||||
and/or modify it under the terms of the Do What The Fuck You Want
|
||||
To Public License, Version 2, as published by Sam Hocevar. See
|
||||
http://sam.zoy.org/wtfpl/COPYING for more details.
|
||||
'''
|
||||
from common import *
|
||||
|
||||
|
||||
|
||||
'''
|
||||
ANSI colour stack
|
||||
|
||||
This is used to make layers with independent coloursations
|
||||
'''
|
||||
class ColourStack():
|
||||
'''
|
||||
Constructor
|
||||
|
||||
@param autopush:str String that, when used, will create a new independently colourised layer
|
||||
@param autopop:str String that, when used, will end the current layer and continue of the previous layer
|
||||
'''
|
||||
def __init__(self, autopush, autopop):
|
||||
self.autopush = autopush
|
||||
self.autopop = autopop
|
||||
self.lenpush = len(autopush)
|
||||
self.lenpop = len(autopop)
|
||||
self.bufproto = ' ' * (self.lenpush if self.lenpush > self.lenpop else self.lenpop)
|
||||
self.stack = []
|
||||
self.push()
|
||||
self.seq = None
|
||||
|
||||
|
||||
'''
|
||||
Create a new independently colourised layer
|
||||
|
||||
@return :str String that should be inserted into your buffer
|
||||
'''
|
||||
def push(self):
|
||||
self.stack.insert(0, [self.bufproto, None, None, [False] * 9])
|
||||
if len(self.stack) == 1:
|
||||
return None
|
||||
return '\033[0m'
|
||||
|
||||
|
||||
'''
|
||||
End the current layer and continue of the previous layer
|
||||
|
||||
@return :str String that should be inserted into your buffer
|
||||
'''
|
||||
def pop(self):
|
||||
old = self.stack.pop(0)
|
||||
rc = '\033[0;'
|
||||
if len(self.stack) == 0: # last resort in case something made it pop too mush
|
||||
push()
|
||||
new = self.stack[0]
|
||||
if new[1] is not None: rc += new[1] + ';'
|
||||
if new[2] is not None: rc += new[2] + ';'
|
||||
for i in range(0, 9):
|
||||
if new[3][i]:
|
||||
rc += str(i + 1) + ';'
|
||||
return rc[:-1] + 'm'
|
||||
|
||||
|
||||
'''
|
||||
Use this, in sequence, for which character in your buffer that contains yor autopush and autopop
|
||||
string, the automatically get push and pop string to insert after each character
|
||||
|
||||
@param :chr One character in your buffer
|
||||
@return :str The text to insert after the input character
|
||||
'''
|
||||
def feed(self, char):
|
||||
if self.seq is not None:
|
||||
self.seq += char
|
||||
if (char == '~') or (('a' <= char) and (char <= 'z')) or (('A' <= char) and (char <= 'Z')):
|
||||
if (self.seq[0] == '[') and (self.seq[-1] == 'm'):
|
||||
self.seq = self.seq[1:-1].split(';')
|
||||
(i, n) = (0, len(self.seq))
|
||||
while i < n:
|
||||
part = self.seq[i]
|
||||
p = 0 if part == '' else int(part)
|
||||
i += 1
|
||||
if p == 0: self.stack[0][1:] = [None, None, [False] * 9]
|
||||
elif (1 <= p) and (p <= 9): self.stack[0][3][p - 1] = True
|
||||
elif (21 <= p) and (p <= 29): self.stack[0][3][p - 21] = False
|
||||
elif p == 39: self.stack[0][1] = None
|
||||
elif p == 49: self.stack[0][2] = None
|
||||
elif (30 <= p) and (p <= 37): self.stack[0][1] = part
|
||||
elif (90 <= p) and (p <= 97): self.stack[0][1] = part
|
||||
elif (40 <= p) and (p <= 47): self.stack[0][2] = part
|
||||
elif (100 <= p) and (p <= 107): self.stack[0][2] = part
|
||||
elif p == 38:
|
||||
self.stack[0][1] = '%s;%s;%s' % (part, self.seq[i], self.seq[i + 1])
|
||||
i += 2
|
||||
elif p == 48:
|
||||
self.stack[0][2] = '%s;%s;%s' % (part, self.seq[i], self.seq[i + 1])
|
||||
i += 2
|
||||
self.seq = None
|
||||
elif char == '\033':
|
||||
self.seq = ''
|
||||
buf = self.stack[0][0]
|
||||
buf = buf[1:] + char
|
||||
rc = ''
|
||||
if buf[-self.lenpush:] == self.autopush: rc = self.push()
|
||||
elif buf[-self.lenpop:] == self.autopop: rc = self.pop()
|
||||
self.stack[0][0] = buf
|
||||
return rc
|
||||
|
||||
74
src/common.py
Normal file
74
src/common.py
Normal file
|
|
@ -0,0 +1,74 @@
|
|||
#!/usr/bin/env python3
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
'''
|
||||
ponysay - Ponysay, cowsay reimplementation for ponies
|
||||
Copyright (C) 2012, 2013 Erkin Batu Altunbaş et al.
|
||||
|
||||
This program is free software. It comes without any warranty, to
|
||||
the extent permitted by applicable law. You can redistribute it
|
||||
and/or modify it under the terms of the Do What The Fuck You Want
|
||||
To Public License, Version 2, as published by Sam Hocevar. See
|
||||
http://sam.zoy.org/wtfpl/COPYING for more details.
|
||||
'''
|
||||
|
||||
import os
|
||||
import shutil
|
||||
import sys
|
||||
import random
|
||||
from subprocess import Popen, PIPE
|
||||
|
||||
|
||||
|
||||
'''
|
||||
The version of ponysay
|
||||
'''
|
||||
VERSION = 'dev' # this line should not be edited, it is fixed by the build system
|
||||
|
||||
|
||||
|
||||
'''
|
||||
Hack to enforce UTF-8 in output (in the future, if you see anypony not using utf-8 in
|
||||
programs by default, report them to Princess Celestia so she can banish them to the moon)
|
||||
|
||||
@param text:str The text to print (empty string is default)
|
||||
@param end:str The appendix to the text to print (line breaking is default)
|
||||
'''
|
||||
def print(text = '', end = '\n'):
|
||||
sys.stdout.buffer.write((str(text) + end).encode('utf-8'))
|
||||
|
||||
'''
|
||||
stderr equivalent to print()
|
||||
|
||||
@param text:str The text to print (empty string is default)
|
||||
@param end:str The appendix to the text to print (line breaking is default)
|
||||
'''
|
||||
def printerr(text = '', end = '\n'):
|
||||
sys.stderr.buffer.write((str(text) + end).encode('utf-8'))
|
||||
|
||||
fd3 = None
|
||||
'''
|
||||
/proc/self/fd/3 equivalent to print()
|
||||
|
||||
@param text:str The text to print (empty string is default)
|
||||
@param end:str The appendix to the text to print (line breaking is default)
|
||||
'''
|
||||
def printinfo(text = '', end = '\n'):
|
||||
global fd3
|
||||
if os.path.exists('/proc/self/fd/3') and os.path.isfile('/proc/self/fd/3'):
|
||||
if fd3 is None:
|
||||
fd3 = os.fdopen(3, 'w')
|
||||
if fd3 is not None:
|
||||
fd3.write(str(text) + end)
|
||||
|
||||
|
||||
'''
|
||||
Checks whether a text ends with a specific text, but has more
|
||||
|
||||
@param text:str The text to test
|
||||
@param ending:str The desired end of the text
|
||||
@return :bool The result of the test
|
||||
'''
|
||||
def endswith(text, ending):
|
||||
return text.endswith(ending) and not (text == ending)
|
||||
|
||||
1390
src/ponysay.py
Normal file
1390
src/ponysay.py
Normal file
File diff suppressed because it is too large
Load diff
216
src/spellocorrecter.py
Normal file
216
src/spellocorrecter.py
Normal file
|
|
@ -0,0 +1,216 @@
|
|||
#!/usr/bin/env python3
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
'''
|
||||
ponysay - Ponysay, cowsay reimplementation for ponies
|
||||
Copyright (C) 2012, 2013 Erkin Batu Altunbaş et al.
|
||||
|
||||
This program is free software. It comes without any warranty, to
|
||||
the extent permitted by applicable law. You can redistribute it
|
||||
and/or modify it under the terms of the Do What The Fuck You Want
|
||||
To Public License, Version 2, as published by Sam Hocevar. See
|
||||
http://sam.zoy.org/wtfpl/COPYING for more details.
|
||||
'''
|
||||
from common import *
|
||||
|
||||
|
||||
|
||||
'''
|
||||
Class used for correcting spellos and typos,
|
||||
|
||||
Note that this implementation will not find that correctly spelled word are correct faster than it corrects words.
|
||||
It is also limited to words of size 0 to 127 (inclusive)
|
||||
'''
|
||||
class SpelloCorrecter(): # Naïvely and quickly ported and adapted from optimised Java, may not be the nicest, or even fast, Python code
|
||||
'''
|
||||
Constructor
|
||||
|
||||
@param directories:list<str> List of directories that contains the file names with the correct spelling
|
||||
@param ending:str The file name ending of the correctly spelled file names, this is removed for the name
|
||||
'''
|
||||
def __init__(self, directories, ending):
|
||||
self.weights = {'k' : {'c' : 0.25, 'g' : 0.75, 'q' : 0.125},
|
||||
'c' : {'k' : 0.25, 'g' : 0.75, 's' : 0.5, 'z' : 0.5, 'q' : 0.125},
|
||||
's' : {'z' : 0.25, 'c' : 0.5},
|
||||
'z' : {'s' : 0.25, 'c' : 0.5},
|
||||
'g' : {'k' : 0.75, 'c' : 0.75, 'q' : 0.9},
|
||||
'o' : {'u' : 0.5},
|
||||
'u' : {'o' : 0.5, 'v' : 0.75, 'w' : 0.5},
|
||||
'b' : {'v' : 0.75},
|
||||
'v' : {'b' : 0.75, 'w' : 0.5, 'u' : 0.7},
|
||||
'w' : {'v' : 0.5, 'u' : 0.5},
|
||||
'q' : {'c' : 0.125, 'k' : 0.125, 'g' : 0.9}}
|
||||
|
||||
self.corrections = None
|
||||
self.dictionary = [None] * 513
|
||||
self.reusable = [0] * 512
|
||||
self.dictionaryEnd = 512
|
||||
self.closestDistance = 0
|
||||
|
||||
self.M = [None] * 128
|
||||
for y in range(0, 128):
|
||||
self.M[y] = [0] * 128
|
||||
self.M[y][0] = y
|
||||
m0 = self.M[0]
|
||||
x = 127
|
||||
while x > -1:
|
||||
m0[x] = x
|
||||
x -= 1
|
||||
|
||||
previous = ''
|
||||
self.dictionary[-1] = previous;
|
||||
|
||||
for directory in directories:
|
||||
for filename in os.listdir(directory):
|
||||
if (not endswith(filename, ending)) or (len(filename) - len(ending) > 127):
|
||||
continue
|
||||
proper = filename[:-len(ending)]
|
||||
|
||||
if self.dictionaryEnd == 0:
|
||||
self.dictionaryEnd = len(self.dictionary)
|
||||
self.reusable = [0] * self.dictionaryEnd + self.reusable
|
||||
self.dictionary = [None] * self.dictionaryEnd + self.dictionary
|
||||
|
||||
self.dictionaryEnd -= 1
|
||||
self.dictionary[self.dictionaryEnd] = proper
|
||||
|
||||
prevCommon = min(len(previous), len(proper))
|
||||
for i in range(0, prevCommon):
|
||||
if previous[i] != proper[i]:
|
||||
prevCommon = i
|
||||
break
|
||||
previous = proper
|
||||
self.reusable[self.dictionaryEnd] = prevCommon
|
||||
#part = self.dictionary[self.dictionaryEnd : len(self.dictionary) - 1]
|
||||
#part.sort()
|
||||
#self.dictionary[self.dictionaryEnd : len(self.dictionary) - 1] = part
|
||||
#
|
||||
#index = len(self.dictionary) - 1
|
||||
#while index >= self.dictionaryEnd:
|
||||
# proper = self.dictionary[index]
|
||||
# prevCommon = min(len(previous), len(proper))
|
||||
# for i in range(0, prevCommon):
|
||||
# if previous[i] != proper[i]:
|
||||
# prevCommon = i
|
||||
# break
|
||||
# previous = proper
|
||||
# self.reusable[self.dictionaryEnd] = prevCommon
|
||||
# index -= 1;
|
||||
|
||||
|
||||
'''
|
||||
Finds the closests correct spelled word
|
||||
|
||||
@param used:str The word to correct
|
||||
@return (words, distance):(list<string>, int) A list the closest spellings and the weighted distance
|
||||
'''
|
||||
def correct(self, used):
|
||||
if len(used) > 127:
|
||||
return ([used], 0)
|
||||
|
||||
self.__correct(used)
|
||||
return (self.corrections, self.closestDistance)
|
||||
|
||||
|
||||
'''
|
||||
Finds the closests correct spelled word
|
||||
|
||||
@param used:str The word to correct, it must satisfy all restrictions
|
||||
'''
|
||||
def __correct(self, used):
|
||||
self.closestDistance = 0x7FFFFFFF
|
||||
previous = self.dictionary[-1]
|
||||
prevLen = 0
|
||||
usedLen = len(used)
|
||||
|
||||
proper = None
|
||||
prevCommon = 0
|
||||
|
||||
d = len(self.dictionary) - 1
|
||||
while d > self.dictionaryEnd:
|
||||
d -= 1
|
||||
proper = self.dictionary[d]
|
||||
if abs(len(proper) - usedLen) <= self.closestDistance:
|
||||
if previous == self.dictionary[d + 1]:
|
||||
prevCommon = self.reusable[d];
|
||||
else:
|
||||
prevCommon = min(prevLen, len(proper))
|
||||
for i in range(0, prevCommon):
|
||||
if previous[i] != proper[i]:
|
||||
prevCommon = i
|
||||
break
|
||||
|
||||
skip = min(prevLen, len(proper))
|
||||
i = prevCommon
|
||||
while i < skip:
|
||||
for u in range(0, usedLen):
|
||||
if (used[u] == previous[i]) or (used[u] == proper[i]):
|
||||
skip = i
|
||||
break
|
||||
i += 1
|
||||
|
||||
common = min(skip, min(usedLen, len(proper)))
|
||||
for i in range(0, common):
|
||||
if used[i] != proper[i]:
|
||||
common = i
|
||||
break
|
||||
|
||||
distance = self.__distance(proper, skip, len(proper), used, common, usedLen)
|
||||
|
||||
if self.closestDistance > distance:
|
||||
self.closestDistance = distance
|
||||
self.corrections = [proper]
|
||||
elif self.closestDistance == distance:
|
||||
self.corrections.append(proper)
|
||||
|
||||
previous = proper;
|
||||
if distance >= 0x7FFFFF00:
|
||||
prevLen = distance & 255
|
||||
else:
|
||||
prevLen = len(proper)
|
||||
|
||||
|
||||
'''
|
||||
Calculate the distance between a correct word and a incorrect word
|
||||
|
||||
@param proper:str The correct word
|
||||
@param y0:int The offset for `proper`
|
||||
@param yn:int The length, before applying `y0`, of `proper`
|
||||
@param used:str The incorrect word
|
||||
@param x0:int The offset for `used`
|
||||
@param xn:int The length, before applying `x0`, of `used`
|
||||
@return :float The distance between the words
|
||||
'''
|
||||
def __distance(self, proper, y0, yn, used, x0, xn):
|
||||
my = self.M[y0]
|
||||
for y in range(y0, yn):
|
||||
best = 0x7FFFFFFF
|
||||
p = proper[y]
|
||||
myy = self.M[y + 1] # only one array bound check, and at most one + ☺
|
||||
x = x0
|
||||
while x < xn:
|
||||
change = my[x]
|
||||
u = used[x]
|
||||
if p == u:
|
||||
# commence black magick … twilight would be so disappointed
|
||||
x += 1
|
||||
myy[x] = change
|
||||
best = min(best, change)
|
||||
remove = myy[x]
|
||||
add = my[x + 1]
|
||||
|
||||
cw = 1
|
||||
if my[x] in self.weights:
|
||||
if p in self.weights[u]:
|
||||
cw = self.weights[u][p]
|
||||
x += 1
|
||||
|
||||
myy[x] = min(cw + change, 1 + min(remove, add))
|
||||
if best > myy[x]:
|
||||
best = myy[x]
|
||||
|
||||
if best > self.closestDistance:
|
||||
return 0x7FFFFF00 | y
|
||||
my = myy
|
||||
return my[xn]
|
||||
|
||||
62
src/ucs.py
Normal file
62
src/ucs.py
Normal file
|
|
@ -0,0 +1,62 @@
|
|||
#!/usr/bin/env python3
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
'''
|
||||
ponysay - Ponysay, cowsay reimplementation for ponies
|
||||
Copyright (C) 2012, 2013 Erkin Batu Altunbaş et al.
|
||||
|
||||
This program is free software. It comes without any warranty, to
|
||||
the extent permitted by applicable law. You can redistribute it
|
||||
and/or modify it under the terms of the Do What The Fuck You Want
|
||||
To Public License, Version 2, as published by Sam Hocevar. See
|
||||
http://sam.zoy.org/wtfpl/COPYING for more details.
|
||||
'''
|
||||
from common import *
|
||||
|
||||
|
||||
|
||||
'''
|
||||
UCS utility class
|
||||
'''
|
||||
class UCS():
|
||||
'''
|
||||
Checks whether a character is a combining character
|
||||
|
||||
@param char:chr The character to test
|
||||
@return :bool Whether the character is a combining character
|
||||
'''
|
||||
@staticmethod
|
||||
def isCombining(char):
|
||||
o = ord(char)
|
||||
if (0x0300 <= o) and (o <= 0x036F): return True
|
||||
if (0x20D0 <= o) and (o <= 0x20FF): return True
|
||||
if (0x1DC0 <= o) and (o <= 0x1DFF): return True
|
||||
if (0xFE20 <= o) and (o <= 0xFE2F): return True
|
||||
return False
|
||||
|
||||
|
||||
'''
|
||||
Gets the number of combining characters in a string
|
||||
|
||||
@param string:str A text to count combining characters in
|
||||
@return :int The number of combining characters in the string
|
||||
'''
|
||||
@staticmethod
|
||||
def countCombining(string):
|
||||
rc = 0
|
||||
for char in string:
|
||||
if UCS.isCombining(char):
|
||||
rc += 1
|
||||
return rc
|
||||
|
||||
|
||||
'''
|
||||
Gets length of a string not counting combining characters
|
||||
|
||||
@param string:str The text of which to determine the monospaced width
|
||||
@return The determine the monospaced width of the text, provided it does not have escape sequnces
|
||||
'''
|
||||
@staticmethod
|
||||
def dispLen(string):
|
||||
return len(string) - UCS.countCombining(string)
|
||||
|
||||
Loading…
Reference in a new issue