CGI Examples
------------
-Here are some example CGI programs. For a larger example, see
-../../Tools/faqwiz/.
+Here are some example CGI programs.
cgi0.sh -- A shell script to test your server is configured for CGI
cgi1.py -- A Python script to test your server is configured for CGI
mdContext = md5()
while 1:
- data = sys.stdin.read(16)
+ data = sys.stdin.read(16).encode()
if not data:
break
mdContext.update(data)
from tkinter import *
+
class Option:
varclass = StringVar # May be overridden
def set(self, e=None): # Should be overridden
pass
+
class BooleanOption(Option):
varclass = BooleanVar
command=self.set)
self.button.pack(side=RIGHT)
+
class EnumOption(Option):
def addoption(self):
value=v,
command=self.set)
+
class StringOption(Option):
def addoption(self):
self.entry.pack(side=RIGHT, fill=X, expand=1)
self.entry.bind('<Return>', self.set)
+
class ReadonlyOption(Option):
def addoption(self):
anchor=E)
self.label.pack(side=RIGHT)
+
class Dialog:
def __init__(self, master):
cl = self.classes[c]
except KeyError:
cl = 'unknown'
- if type(cl) == TupleType:
+ if type(cl) is tuple:
cl = self.enumoption
elif cl == 'boolean':
cl = self.booleanoption
enumoption = EnumOption
readonlyoption = ReadonlyOption
+
class PackDialog(Dialog):
def __init__(self, widget):
class stringoption(remotepackoption, StringOption): pass
class readonlyoption(remotepackoption, ReadonlyOption): pass
+
class WidgetDialog(Dialog):
def __init__(self, widget):
'Slider': _bistate,
}
+
class RemoteWidgetDialog(WidgetDialog):
def __init__(self, master, app, widget):
class stringoption(remotewidgetoption, StringOption): pass
class readonlyoption(remotewidgetoption, ReadonlyOption): pass
+
def test():
import sys
root = Tk()
list.app = app # Pass it on to handler
def opendialogs(e):
- import string
list = e.widget
sel = list.curselection()
for i in sel:
item = list.get(i)
- widget = string.split(item)[0]
+ widget = item.split()[0]
RemoteWidgetDialog(list, list.app, widget)
if widget == '.': continue
try:
#! /usr/bin/env python
from tkinter import *
-from Canvas import Oval, Group, CanvasText
-# Fix a bug in Canvas.Group as distributed in Python 1.4. The
-# distributed bind() method is broken. This is what should be used:
+# Since Canvas.Group is no longer present, the following class reproduces
+# a subset of the old Group class that is used by this app.
+
+class Group:
+ def __init__(self, canvas, tag=None):
+ if tag is None:
+ tag = 'Group%d' % id(self)
+
+ self.tag = self.id = tag
+ self.canvas = canvas
+ self.canvas.dtag(self.tag)
+
+ def __str__(self):
+ return self.tag
+
+ def _do(self, cmd, *args):
+ return self.canvas.tk.call(self.canvas._w, cmd, self.tag, *args)
+
+ def addtag_withtag(self, tagOrId):
+ self._do('addtag', 'withtag', tagOrId)
+
+ def bind(self, sequence=None, command=None, add=None):
+ return self.canvas.tag_bind(self.id, sequence, command, add)
+
+ def move(self, x_amount, y_amount):
+ self._do('move', x_amount, y_amount)
+
+ def dtag(self, tagToDelete=None):
+ self._do('dtag', tagToDelete)
+
+ def tkraise(self, aboveThis=None):
+ self._do('raise', aboveThis)
-class Group(Group):
- def bind(self, sequence=None, command=None):
- return self.canvas.tag_bind(self.id, sequence, command)
class Object:
All instance attributes are public since the derived class may
need them.
-
"""
def __init__(self, canvas, x=0, y=0, fill='red', text='object'):
return str(self.group)
def createitems(self, fill, text):
- self.__oval = Oval(self.canvas,
- self.x-20, self.y-10, self.x+20, self.y+10,
- fill=fill, width=3)
+ self.__oval = self.canvas.create_oval(self.x - 20, self.y - 10,
+ self.x + 20, self.y + 20, fill=fill, width=3)
self.group.addtag_withtag(self.__oval)
- self.__text = CanvasText(self.canvas,
- self.x, self.y, text=text)
+ self.__text = self.canvas.create_text(self.x, self.y, text=text)
self.group.addtag_withtag(self.__text)
def moveby(self, dx, dy):
class Bottom(Object):
-
"""An object to serve as the bottom of a pile."""
def createitems(self, *args):
- self.__oval = Oval(self.canvas,
- self.x-20, self.y-10, self.x+20, self.y+10,
- fill='gray', outline='')
+ self.__oval = self.canvas.create_oval(self.x - 20, self.y - 10,
+ self.x + 20, self.y + 10, fill='gray', outline='')
self.group.addtag_withtag(self.__oval)
class Pile:
-
"""A group of graphical objects."""
def __init__(self, canvas, x, y, tag=None):
# 2. Fill the top part with the bitmap and message.
- msg = Message(top, width='3i', text=text,
- font='-Adobe-Times-Medium-R-Normal-*-180-*')
+ msg = Message(top, width='3i', text=text)
msg.pack(side=RIGHT, expand=1, fill=BOTH, padx='3m', pady='3m')
if bitmap:
bm = Label(top, bitmap=bitmap)
# Main program
def main():
- import sys, string
+ import sys
# First argument is number of electrons, default 30
if sys.argv[1:]:
- n = string.atoi(sys.argv[1])
+ n = int(sys.argv[1])
else:
n = 30
# Main program
def main():
- import sys, string
+ import sys
# First argument is number of pegs, default 4
if sys.argv[1:]:
- n = string.atoi(sys.argv[1])
+ n = int(sys.argv[1])
else:
n = 4
# List a remote app's widget tree (names and classes only)
import sys
-import string
from tkinter import *
def listnodes(list, app, widget, level):
klass = list.send(app, 'winfo', 'class', widget)
-## i = string.rindex(widget, '.')
-## list.insert(END, '%s%s (%s)' % ((level-1)*'. ', widget[i:], klass))
list.insert(END, '%s (%s)' % (widget, klass))
children = list.tk.splitlist(
list.send(app, 'winfo', 'children', widget))
# Widget to display a man page
+import os
import re
+import sys
+
from tkinter import *
-from tkinter import _tkinter
+from tkinter.font import Font
from tkinter.scrolledtext import ScrolledText
-# XXX These fonts may have to be changed to match your system
-BOLDFONT = '*-Courier-Bold-R-Normal-*-120-*'
-ITALICFONT = '*-Courier-Medium-O-Normal-*-120-*'
-
# XXX Recognizing footers is system dependent
# (This one works for IRIX 5.2 and Solaris 2.2)
footerprog = re.compile(
emptyprog = re.compile('^[ \t]*\n')
ulprog = re.compile('^[ \t]*[Xv!_][Xv!_ \t]*\n')
-# Basic Man Page class -- does not disable editing
+
class EditableManPage(ScrolledText):
+ """Basic Man Page class -- does not disable editing."""
- # Initialize instance
def __init__(self, master=None, **cnf):
- # Initialize base class
ScrolledText.__init__(self, master, **cnf)
+ bold = Font(font=self['font']).copy()
+ bold.config(weight='bold')
+ italic = Font(font=self['font']).copy()
+ italic.config(slant='italic')
+
# Define tags for formatting styles
self.tag_config('X', underline=1)
- self.tag_config('!', font=BOLDFONT)
- self.tag_config('_', font=ITALICFONT)
+ self.tag_config('!', font=bold)
+ self.tag_config('_', font=italic)
# Set state to idle
self.fp = None
self.lineno = 0
- # Test whether we are busy parsing a file
def busy(self):
+ """Test whether we are busy parsing a file."""
return self.fp != None
- # Ensure we're not busy
def kill(self):
+ """Ensure we're not busy."""
if self.busy():
self._endparser()
- # Parse a file, in the background
def asyncparsefile(self, fp):
+ """Parse a file, in the background."""
self._startparser(fp)
- self.tk.createfilehandler(fp, _tkinter.READABLE,
+ self.tk.createfilehandler(fp, READABLE,
self._filehandler)
- parsefile = asyncparsefile # Alias
+ parsefile = asyncparsefile # Alias
- # I/O handler used by background parsing
def _filehandler(self, fp, mask):
+ """I/O handler used by background parsing."""
nextline = self.fp.readline()
if not nextline:
self._endparser()
return
self._parseline(nextline)
- # Parse a file, now (cannot be aborted)
def syncparsefile(self, fp):
- from select import select
- def avail(fp=fp, tout=0.0, select=select):
- return select([fp], [], [], tout)[0]
- height = self.getint(self['height'])
+ """Parse a file, now (cannot be aborted)."""
self._startparser(fp)
- while 1:
+ while True:
nextline = fp.readline()
if not nextline:
break
self._parseline(nextline)
self._endparser()
- # Initialize parsing from a particular file -- must not be busy
def _startparser(self, fp):
+ """Initialize parsing from a particular file -- must not be busy."""
if self.busy():
raise RuntimeError('startparser: still busy')
fp.fileno() # Test for file-ness
self.delete('1.0', END)
self['state'] = savestate
- # End parsing -- must be busy, need not be at EOF
def _endparser(self):
+ """End parsing -- must be busy, need not be at EOF."""
if not self.busy():
raise RuntimeError('endparser: not busy')
if self.buffer:
self._parseline('')
try:
self.tk.deletefilehandler(self.fp)
- except TclError as msg:
+ except TclError:
pass
self.fp.close()
self.fp = None
del self.ok, self.empty, self.buffer
- # Parse a single line
def _parseline(self, nextline):
+ """Parse a single line."""
if not self.buffer:
# Save this line -- we need one line read-ahead
self.buffer = nextline
return
- if emptyprog.match(self.buffer) >= 0:
+ if emptyprog.match(self.buffer):
# Buffered line was empty -- set a flag
self.empty = 1
self.buffer = nextline
return
textline = self.buffer
- if ulprog.match(nextline) >= 0:
+ if ulprog.match(nextline):
# Next line is properties for buffered line
propline = nextline
self.buffer = None
self.ok = 1
self.empty = 0
return
- if footerprog.match(textline) >= 0:
+ if footerprog.match(textline):
# Footer -- start skipping until next non-blank line
self.ok = 0
self.empty = 0
self.lineno = self.lineno + 1
self['state'] = savestate
- # Insert a string at the end, with at most one property (tag)
def _insert_prop(self, str, prop = ' '):
+ """Insert a string at the end, with at most one property (tag)."""
here = self.index(AtInsert())
self.insert(AtInsert(), str)
if TkVersion <= 4.0:
if prop != ' ':
self.tag_add(prop, here, AtInsert())
-# Readonly Man Page class -- disables editing, otherwise the same
+
class ReadonlyManPage(EditableManPage):
+ """Readonly Man Page class -- disables editing, otherwise the same."""
- # Initialize instance
def __init__(self, master=None, **cnf):
cnf['state'] = DISABLED
EditableManPage.__init__(self, master, **cnf)
# Alias
ManPage = ReadonlyManPage
-# Test program.
# usage: ManPage [manpage]; or ManPage [-f] file
# -f means that the file is nroff -man output run through ul -i
-def test():
- import os
- import sys
+def main():
# XXX This directory may be different on your system
- MANDIR = '/usr/local/man/mann'
+ MANDIR = ''
DEFAULTPAGE = 'Tcl'
formatted = 0
if sys.argv[1:] and sys.argv[1] == '-f':
if formatted:
fp = open(name, 'r')
else:
- fp = os.popen('nroff -man %s | ul -i' % name, 'r')
+ fp = os.popen('nroff -man -c %s | ul -i' % name, 'r')
manpage.parsefile(fp)
root.mainloop()
-# Run the test program when called as a script
if __name__ == '__main__':
- test()
+ main()
# Scan MH folder, display results in window
import os
-import sys
import re
+import sys
import getopt
-import string
-import mhlib
-
+import mailbox
from tkinter import *
from dialog import dialog
-mailbox = os.environ['HOME'] + '/Mail'
+MBOXPATH = os.environ['HOME'] + '/Mail'
def main():
global root, tk, top, mid, bot
# Initialize MH
- mh = mhlib.MH()
- mhf = mh.openfolder(folder)
+ mh = mailbox.MH(MBOXPATH)
+ mhf = mh.get_folder(folder)
# Build widget hierarchy
return
i = sel[0]
folder = folderbox.get(i)
- mhf = mh.openfolder(folder)
+ mhf = mh.get_folder(folder)
rescan()
def open_message(e=None):
tk.call('update', 'idletasks')
i = sel[0]
line = scanbox.get(i)
- if scanparser.match(line) >= 0:
- num = string.atoi(scanparser.group(1))
- m = mhf.openmessage(num)
+ m = scanparser.match(line)
+ if m:
+ num = int(m.group(1))
+ m = mhf.get_message(num)
if viewer: viewer.destroy()
- from MimeViewer import MimeViewer
+ from mimeviewer import MimeViewer
viewer = MimeViewer(bot, '+%s/%d' % (folder, num), m)
viewer.pack()
viewer.show()
todo = []
for i in sel:
line = scanbox.get(i)
- if scanparser.match(line) >= 0:
- todo.append(string.atoi(scanparser.group(1)))
- mhf.removemessages(todo)
+ m = scanparser.match(line)
+ if m:
+ toremove = int(m.group(1))
+ todo.append(toremove)
+ mhf.remove(toremove)
rescan()
fixfocus(min(todo), itop)
todo = []
for i in sel:
line = scanbox.get(i)
- if scanparser.match(line) >= 0:
- todo.append(string.atoi(scanparser.group(1)))
+ m = scanparser.match(line)
+ if m:
+ todo.append(int(m.group(1)))
if lastrefile != refileto or not tofolder:
lastrefile = refileto
tofolder = None
- tofolder = mh.openfolder(lastrefile)
+ tofolder = mh.get_folder(lastrefile)
mhf.refilemessages(todo, tofolder)
rescan()
fixfocus(min(todo), itop)
n = scanbox.size()
for i in range(n):
line = scanbox.get(repr(i))
- if scanparser.match(line) >= 0:
- num = string.atoi(scanparser.group(1))
+ m = scanparser.match(line)
+ if m:
+ num = int(m.group(1))
if num >= near:
break
else:
i = 'end'
- scanbox.select_from(i)
scanbox.yview(itop)
def setfolders():
folderbox.delete(0, 'end')
- for fn in mh.listallfolders():
+ for fn in mh.list_folders():
folderbox.insert('end', fn)
def rescan():
scanbox.insert('end', line)
def scanfolder(folder = 'inbox', sequence = 'all'):
- return [line[:-1] for line in os.popen('scan +%s %s' % (folder, sequence), 'r').readlines()]
+ return [line[:-1] for line in
+ os.popen('scan +%s %s' % (folder, sequence), 'r').readlines()]
main()
-#! /usr/bin/env python
+#! /usr/bin/env python3
# View a single MIME multipart message.
# Display each part as a box.
-import string
-from types import *
+import os
+import sys
+import getopt
+import mailbox
from tkinter import *
from tkinter.scrolledtext import ScrolledText
+MBOXPATH = os.environ['HOME'] + '/Mail'
+
+class Error(Exception):
+ pass
+
+def getcurrent(self):
+ """Return the current message. Raise Error when there is none."""
+ seqs = self.get_sequences()
+ try:
+ return max(seqs['cur'])
+ except (ValueError, KeyError):
+ raise Error("no cur message")
+
+
class MimeViewer:
def __init__(self, parent, title, msg):
self.title = title
{'text': title,
'command': self.toggle})
self.button.pack({'anchor': 'w'})
- headertext = msg.getheadertext(
- lambda x: x != 'received' and x[:5] != 'x400-')
+ headertext = []
+ for item in msg.items():
+ headertext.append("%s: %s" % item)
+ headertext = '\n'.join(headertext)
height = countlines(headertext, 4)
if height:
self.htext = ScrolledText(self.frame,
'ipady': 2,
'fill': 'x',
'after': self.button}
- body = msg.getbody()
- if type(body) == StringType:
+ body = msg.get_payload()
+ if type(body) == str:
self.pad = None
height = countlines(body, 10)
if height:
i = 0
n = 0
while n < limit:
- i = string.find(str, '\n', i)
+ i = str.find('\n', i)
if i < 0: break
n = n+1
i = i+1
return n
def main():
- import sys
- import getopt
- import mhlib
opts, args = getopt.getopt(sys.argv[1:], '')
for o, a in opts:
pass
if arg[:1] == '+':
folder = arg[1:]
else:
- message = string.atoi(arg)
+ message = int(arg)
- mh = mhlib.MH()
- f = mh.openfolder(folder)
- if not message:
- message = f.getcurrent()
- m = f.openmessage(message)
+ mh = mailbox.MH(MBOXPATH)
+ f = mh.get_folder(folder)
+ if message is None:
+ message = getcurrent(f)
+ m = mailbox.MHMessage(f.get(message))
root = Tk()
tk = root.tk
tk.mainloop()
-if __name__ == '__main__': main()
+if __name__ == '__main__':
+ main()
s.pack(side=RIGHT, fill=Y)
t = Text(f, relief=RAISED, borderwidth=2, yscrollcommand=s.set, setgrid=1)
t.pack(side=LEFT, fill=BOTH, expand=1)
-t.tag_config('bold', font='-Adobe-Courier-Bold-R-Normal-*-120-*')
+t.tag_config('bold')
s['command'] = t.yview
root.title('Tk Remote Controller')
import os
import sys
-import string
from tkinter import *
from tkinter.scrolledtext import ScrolledText
from tkinter.dialog import Dialog
except KeyError:
shell = '/bin/sh'
shell = shell + ' -i'
- args = string.split(shell)
+ args = shell.split()
shell = args[0]
ScrolledText.__init__(self, master, **cnf)
self.outputhandler)
def outputhandler(self, file, mask):
- data = os.read(file, BUFSIZE)
+ data = os.read(file, BUFSIZE).decode()
if not data:
self.tk.deletefilehandler(file)
pid, sts = os.waitpid(self.pid, 0)
self.insert(END, "\n")
line = self.get(self.pos, "end - 1 char")
self.pos = self.index(END)
- os.write(self.tochild, line)
+ os.write(self.tochild, line.encode())
return "break"
def sendeof(self, *args):
return pid, c2pread, p2cwrite
def test():
- shell = string.join(sys.argv[1:])
+ shell = ' '.join(sys.argv[1: ])
root = Tk()
root.minsize(1, 1)
if shell:
# Imports
-import math
import random
from tkinter import *
-from Canvas import Rectangle, CanvasText, Group, Window
-
-
-# Fix a bug in Canvas.Group as distributed in Python 1.4. The
-# distributed bind() method is broken. Rather than asking you to fix
-# the source, we fix it here by deriving a subclass:
-
-class Group(Group):
- def bind(self, sequence=None, command=None):
- return self.canvas.tag_bind(self.id, sequence, command)
+from canvasevents import Group
# Constants determining the size and lay-out of cards and stacks. We
self.face_shown = 0
self.x = self.y = 0
+ self.canvas = canvas
self.group = Group(canvas)
text = "%s %s" % (VALNAMES[value], suit)
- self.__text = CanvasText(canvas, CARDWIDTH//2, 0,
- anchor=N, fill=self.color, text=text)
+ self.__text = canvas.create_text(CARDWIDTH // 2, 0, anchor=N,
+ fill=self.color, text=text)
self.group.addtag_withtag(self.__text)
- self.__rect = Rectangle(canvas, 0, 0, CARDWIDTH, CARDHEIGHT,
- outline='black', fill='white')
+ self.__rect = canvas.create_rectangle(0, 0, CARDWIDTH, CARDHEIGHT,
+ outline='black', fill='white')
self.group.addtag_withtag(self.__rect)
- self.__back = Rectangle(canvas, MARGIN, MARGIN,
- CARDWIDTH-MARGIN, CARDHEIGHT-MARGIN,
- outline='black', fill='blue')
+ self.__back = canvas.create_rectangle(MARGIN, MARGIN,
+ CARDWIDTH - MARGIN,
+ CARDHEIGHT - MARGIN,
+ outline='black', fill='blue')
self.group.addtag_withtag(self.__back)
def __repr__(self):
def showface(self):
"""Turn the card's face up."""
self.tkraise()
- self.__rect.tkraise()
- self.__text.tkraise()
+ self.canvas.tag_raise(self.__rect)
+ self.canvas.tag_raise(self.__text)
self.face_shown = 1
def showback(self):
"""Turn the card's face down."""
self.tkraise()
- self.__rect.tkraise()
- self.__back.tkraise()
+ self.canvas.tag_raise(self.__rect)
+ self.canvas.tag_raise(self.__back)
self.face_shown = 0
"""
def makebottom(self):
- bottom = Rectangle(self.game.canvas,
- self.x, self.y,
- self.x+CARDWIDTH, self.y+CARDHEIGHT,
- outline='black', fill=BACKGROUND)
+ bottom = self.game.canvas.create_rectangle(self.x, self.y,
+ self.x + CARDWIDTH, self.y + CARDHEIGHT, outline='black',
+ fill=BACKGROUND)
self.group.addtag_withtag(bottom)
def fill(self):
def randperm(n):
"""Function returning a random permutation of range(n)."""
- r = range(n)
+ r = list(range(n))
x = []
while r:
i = random.choice(r)
class SuitStack(OpenStack):
def makebottom(self):
- bottom = Rectangle(self.game.canvas,
- self.x, self.y,
- self.x+CARDWIDTH, self.y+CARDHEIGHT,
- outline='black', fill='')
+ bottom = self.game.canvas.create_rectangle(self.x, self.y,
+ self.x + CARDWIDTH, self.y + CARDHEIGHT, outline='black', fill='')
def userclickhandler(self):
pass
background=BACKGROUND,
activebackground="green",
command=self.deal)
- Window(self.canvas, MARGIN, 3*YSPACING + 20,
- window=self.dealbutton, anchor=SW)
+ self.canvas.create_window(MARGIN, 3 * YSPACING + 20,
+ window=self.dealbutton, anchor=SW)
x = MARGIN
y = MARGIN
"""
-
from tkinter import *
-from Canvas import Line, Rectangle
import random
class Array:
+ class Cancelled(BaseException):
+ pass
+
def __init__(self, master, data=None):
self.master = master
self.frame = Frame(self.master)
self.canvas.pack()
self.report = Label(self.frame)
self.report.pack()
- self.left = Line(self.canvas, 0, 0, 0, 0)
- self.right = Line(self.canvas, 0, 0, 0, 0)
- self.pivot = Line(self.canvas, 0, 0, 0, 0)
+ self.left = self.canvas.create_line(0, 0, 0, 0)
+ self.right = self.canvas.create_line(0, 0, 0, 0)
+ self.pivot = self.canvas.create_line(0, 0, 0, 0)
self.items = []
self.size = self.maxvalue = 0
if data:
if self.in_mainloop:
self.master.quit()
- Cancelled = "Array.Cancelled" # Exception
-
def wait(self, msecs):
if self.speed == "fastest":
msecs = 0
for i in range(self.size):
item = self.items[i]
if first <= i < last:
- item.item.config(fill='red')
+ self.canvas.itemconfig(item, fill='red')
else:
- item.item.config(fill='orange')
+ self.canvas.itemconfig(item, fill='orange')
self.hide_left_right_pivot()
def hide_partition(self):
for i in range(self.size):
item = self.items[i]
- item.item.config(fill='red')
+ self.canvas.itemconfig(item, fill='red')
self.hide_left_right_pivot()
def show_left(self, left):
return
x1, y1, x2, y2 = self.items[left].position()
## top, bot = HIRO
- self.left.coords([(x1-2, 0), (x1-2, 9999)])
+ self.canvas.coords(self.left, (x1 - 2, 0, x1 - 2, 9999))
self.master.update()
def show_right(self, right):
self.hide_right()
return
x1, y1, x2, y2 = self.items[right].position()
- self.right.coords(((x2+2, 0), (x2+2, 9999)))
+ self.canvas.coords(self.right, (x2 + 2, 0, x2 + 2, 9999))
self.master.update()
def hide_left_right_pivot(self):
self.hide_pivot()
def hide_left(self):
- self.left.coords(((0, 0), (0, 0)))
+ self.canvas.coords(self.left, (0, 0, 0, 0))
def hide_right(self):
- self.right.coords(((0, 0), (0, 0)))
+ self.canvas.coords(self.right, (0, 0, 0, 0))
def show_pivot(self, pivot):
x1, y1, x2, y2 = self.items[pivot].position()
- self.pivot.coords(((0, y1-2), (9999, y1-2)))
+ self.canvas.coords(self.pivot, (0, y1 - 2, 9999, y1 - 2))
def hide_pivot(self):
- self.pivot.coords(((0, 0), (0, 0)))
+ self.canvas.coords(self.pivot, (0, 0, 0, 0))
def swap(self, i, j):
if i == j: return
self.array = array
self.index = index
self.value = value
+ self.canvas = array.canvas
x1, y1, x2, y2 = self.position()
- self.item = Rectangle(array.canvas, x1, y1, x2, y2,
- fill='red', outline='black', width=1)
- self.item.bind('<Button-1>', self.mouse_down)
- self.item.bind('<Button1-Motion>', self.mouse_move)
- self.item.bind('<ButtonRelease-1>', self.mouse_up)
+ self.item_id = array.canvas.create_rectangle(x1, y1, x2, y2,
+ fill='red', outline='black', width=1)
+ self.canvas.tag_bind(self.item_id, '<Button-1>', self.mouse_down)
+ self.canvas.tag_bind(self.item_id, '<Button1-Motion>', self.mouse_move)
+ self.canvas.tag_bind(self.item_id, '<ButtonRelease-1>', self.mouse_up)
def delete(self):
- item = self.item
+ item_id = self.item_id
self.array = None
- self.item = None
- item.delete()
+ self.item_id = None
+ self.canvas.delete(item_id)
def mouse_down(self, event):
self.lastx = event.x
self.lasty = event.y
self.origx = event.x
self.origy = event.y
- self.item.tkraise()
+ self.canvas.tag_raise(self.item_id)
def mouse_move(self, event):
- self.item.move(event.x - self.lastx, event.y - self.lasty)
+ self.canvas.move(self.item_id,
+ event.x - self.lastx, event.y - self.lasty)
self.lastx = event.x
self.lasty = event.y
self.array.items[here], self.array.items[i] = other, self
self.index = i
x1, y1, x2, y2 = self.position()
- self.item.coords(((x1, y1), (x2, y2)))
+ self.canvas.coords(self.item_id, (x1, y1, x2, y2))
other.setindex(here)
def setindex(self, index):
self.index = index
newpts = self.position()
trajectory = interpolate(oldpts, newpts, nsteps)
- self.item.tkraise()
+ self.canvas.tag_raise(self.item_id)
for pts in trajectory:
- self.item.coords((pts[:2], pts[2:]))
+ self.canvas.coords(self.item_id, pts)
self.array.wait(50)
def swapwith(self, other):
self.index, other.index = other.index, self.index
mynewpts = self.position()
othernewpts = other.position()
- myfill = self.item['fill']
- otherfill = other.item['fill']
- self.item.config(fill='green')
- other.item.config(fill='yellow')
+ myfill = self.canvas.itemcget(self.item_id, 'fill')
+ otherfill = self.canvas.itemcget(other.item_id, 'fill')
+ self.canvas.itemconfig(self.item_id, fill='green')
+ self.canvas.itemconfig(other.item_id, fill='yellow')
self.array.master.update()
if self.array.speed == "single-step":
- self.item.coords((mynewpts[:2], mynewpts[2:]))
- other.item.coords((othernewpts[:2], othernewpts[2:]))
+ self.canvas.coords(self.item_id, mynewpts)
+ self.canvas.coords(other.item_id, othernewpts)
self.array.master.update()
- self.item.config(fill=myfill)
- other.item.config(fill=otherfill)
+ self.canvas.itemconfig(self.item_id, fill=myfill)
+ self.canvas.itemconfig(other.item_id, fill=otherfill)
self.array.wait(0)
return
mytrajectory = interpolate(myoldpts, mynewpts, nsteps)
othertrajectory = interpolate(otheroldpts, othernewpts, nsteps)
if self.value > other.value:
- self.item.tkraise()
- other.item.tkraise()
+ self.canvas.tag_raise(self.item_id)
+ self.canvas.tag_raise(other.item_id)
else:
- other.item.tkraise()
- self.item.tkraise()
+ self.canvas.tag_raise(other.item_id)
+ self.canvas.tag_raise(self.item_id)
try:
for i in range(len(mytrajectory)):
mypts = mytrajectory[i]
otherpts = othertrajectory[i]
- self.item.coords((mypts[:2], mypts[2:]))
- other.item.coords((otherpts[:2], otherpts[2:]))
+ self.canvas.coords(self.item_id, mypts)
+ self.canvas.coords(other.item_id, otherpts)
self.array.wait(50)
finally:
mypts = mytrajectory[-1]
otherpts = othertrajectory[-1]
- self.item.coords((mypts[:2], mypts[2:]))
- other.item.coords((otherpts[:2], otherpts[2:]))
- self.item.config(fill=myfill)
- other.item.config(fill=otherfill)
+ self.canvas.coords(self.item_id, mypts)
+ self.canvas.coords(other.item_id, otherpts)
+ self.canvas.itemconfig(self.item_id, fill=myfill)
+ self.canvas.itemconfig(other.item_id, fill=otherfill)
def compareto(self, other):
- myfill = self.item['fill']
- otherfill = other.item['fill']
- outcome = cmp(self.value, other.value)
- if outcome < 0:
+ myfill = self.canvas.itemcget(self.item_id, 'fill')
+ otherfill = self.canvas.itemcget(other.item_id, 'fill')
+ if self.value < other.value:
myflash = 'white'
otherflash = 'black'
- elif outcome > 0:
+ outcome = -1
+ elif self.value > other.value:
myflash = 'black'
otherflash = 'white'
+ outcome = 1
else:
myflash = otherflash = 'grey'
+ outcome = 0
try:
- self.item.config(fill=myflash)
- other.item.config(fill=otherflash)
+ self.canvas.itemconfig(self.item_id, fill=myflash)
+ self.canvas.itemconfig(other.item_id, fill=otherflash)
self.array.wait(500)
finally:
- self.item.config(fill=myfill)
- other.item.config(fill=otherfill)
+ self.canvas.itemconfig(self.item_id, fill=myfill)
+ self.canvas.itemconfig(other.item_id, fill=otherfill)
return outcome
def position(self):
j = j-1
continue
array.message("Choosing pivot")
- j, i, k = first, (first+last)//2, last-1
+ j, i, k = first, (first+last) // 2, last-1
if array.compare(k, i) < 0:
array.swap(k, i)
if array.compare(k, j) < 0:
self.v_size = MyIntVar(self.master, self)
self.v_size.set(size)
- sizes = [1, 2, 3, 4] + range(5, 55, 5)
+ sizes = [1, 2, 3, 4] + list(range(5, 55, 5))
if self.size not in sizes:
sizes.append(self.size)
sizes.sort()
import os
import re
import sys
-import cgi
+import html
from xml.parsers import expat
LEFT, CENTER, RIGHT = "LEFT", "CENTER", "RIGHT"
if hasattr(cell, 'xml'):
cellxml = cell.xml()
else:
- cellxml = '<value>%s</value>' % cgi.escape(cell)
+ cellxml = '<value>%s</value>' % html.escape(cell)
out.append('<cell row="%s" col="%s">\n %s\n</cell>' %
(y, x, cellxml))
out.append('</spreadsheet>')
f.close()
def load(self, filename):
- f = open(filename, 'r')
+ f = open(filename, 'rb')
SheetParser(self).parsefile(f)
f.close()
return s % (
align2xml[self.alignment],
self.fmt,
- cgi.escape(self.text))
+ html.escape(self.text))
class FormulaCell(BaseCell):
if TkVersion < 4.0:
raise ImportError("This version of svkill requires Tk 4.0 or later")
-from string import splitfields
-from string import split
import subprocess
import os
]
def kill(self, selected):
c = self.format_list[self.format.get()][2]
- pid = split(selected)[c]
+ pid = selected.split()[c]
os.system('kill -9 ' + pid)
self.do_update()
def do_update(self):
format = self.format_list[self.format.get()][1]
view = self.view_list[self.view.get()][1]
s = subprocess.getoutput('ps %s %s' % (view, format))
- list = splitfields(s, '\n')
+ list = s.split('\n')
self.header.set(list[0] + ' ')
del list[0]
self.frame.list.delete(0, AtEnd())
self.header = StringVar(self)
self.frame.label = Label(
self.frame, relief=FLAT, anchor=NW, borderwidth=0,
- font='*-Courier-Bold-R-Normal-*-120-*',
textvariable=self.header)
self.frame.label.pack(fill=Y, anchor=W)
self.frame.vscroll = Scrollbar(self.frame, orient=VERTICAL)
self.frame.list = Listbox(
self.frame,
relief=SUNKEN,
- font='*-Courier-Medium-R-Normal-*-120-*',
width=40, height=10,
selectbackground='#eed5b7',
selectborderwidth=0,
# Tk man page browser -- currently only shows the Tcl/Tk man pages
-import sys
import os
-import string
import re
+import sys
from tkinter import *
-from ManPage import ManPage
-MANNDIRLIST = ['/depot/sundry/man/mann','/usr/local/man/mann']
-MAN3DIRLIST = ['/depot/sundry/man/man3','/usr/local/man/man3']
+from manpage import ManPage
+
+MANNDIRLIST = ['/usr/local/man/mann', '/usr/share/man/mann']
+MAN3DIRLIST = ['/usr/local/man/man3', '/usr/share/man/man3']
foundmanndir = 0
for dir in MANNDIRLIST:
def show_page(self, name):
file = '%s/%s.?' % (self.chaptervar.get(), name)
- fp = os.popen('nroff -man %s | ul -i' % file, 'r')
+ fp = os.popen('nroff -man -c %s | ul -i' % file, 'r')
self.text.kill()
self.title['text'] = name
self.text.parsefile(fp)
print('Regex error:', msg)
return
here = self.text.index(AtInsert())
- lineno = string.atoi(here[:string.find(here, '.')])
+ lineno = int(here[:here.find('.')])
end = self.text.index(AtEnd())
- endlineno = string.atoi(end[:string.find(end, '.')])
+ endlineno = int(end[:end.find('.')])
wraplineno = lineno
found = 0
while 1:
line = self.text.get('%d.0 linestart' % lineno,
'%d.0 lineend' % lineno)
i = prog.search(line)
- if i >= 0:
+ if i:
found = 1
- n = max(1, len(prog.group(0)))
+ n = max(1, len(i.group(0)))
try:
self.text.tag_remove('sel',
AtSelFirst(),
except TclError:
pass
self.text.tag_add('sel',
- '%d.%d' % (lineno, i),
- '%d.%d' % (lineno, i+n))
+ '%d.%d' % (lineno, i.start()),
+ '%d.%d' % (lineno, i.start()+n))
self.text.mark_set(AtInsert(),
- '%d.%d' % (lineno, i))
+ '%d.%d' % (lineno, i.start()))
self.text.yview_pickplace(AtInsert())
break
if not found:
import os
import sys
-tk = _tkinter.create(os.environ['DISPLAY'], 'wish', 'Tk', 1)
+tk = _tkinter.create(os.environ['DISPLAY'], 'wish', 'Tk', 1, 1)
tk.call('update')
cmd = ''
-while 1:
- if cmd: prompt = ''
- else: prompt = '% '
+while True:
+ if cmd:
+ prompt = ''
+ else:
+ prompt = '% '
try:
sys.stdout.write(prompt)
sys.stdout.flush()
line = sys.stdin.readline()
+ if not line:
+ break
except EOFError:
break
- cmd = cmd + (line + '\n')
+ cmd += line
if tk.getboolean(tk.call('info', 'complete', cmd)):
tk.record(line)
try:
from tkinter import *
-import string
# This program shows how to use a simple type-in box
from tkinter import *
-import string
# This program shows how to make a typein box shadow a program variable.
# because it's being looked at by the entry widget, changing
# the variable changes the entry widget display automatically.
# the strange get/set operators are clunky, true...
- str = string.upper(self.contents.get())
+ str = self.contents.get().upper()
self.contents.set(str)
def print_contents(self, event):
from tkinter import *
-import string
-
class Pong(Frame):
def createWidgets(self):
# the "current" tag is applied to the object the cursor is over.
# this happens automatically.
self.draw.itemconfig(CURRENT, fill="red")
- print(self.draw.coords(CURRENT))
+ print(list(self.draw.coords(CURRENT)))
def mouseLeave(self, event):
# the "current" tag is applied to the object the cursor is over.
Python applications should normally find no need to invoke these functions, and
should use :mod:`gettext` instead. A known exception to this rule are
-applications that link use additional C libraries which internally invoke
+applications that link with additional C libraries which internally invoke
:cfunc:`gettext` or :func:`dcgettext`. For these applications, it may be
necessary to bind the text domain, so that the libraries can properly locate
their message catalogs.
>>> a.send([1, 'hello', None])
>>> b.recv()
[1, 'hello', None]
- >>> b.send_bytes('thank you')
+ >>> b.send_bytes(b'thank you')
>>> a.recv_bytes()
- 'thank you'
+ b'thank you'
>>> import array
>>> arr1 = array.array('i', range(5))
>>> arr2 = array.array('i', [0] * 10)
undefined.
``(?:...)``
- A non-grouping version of regular parentheses. Matches whatever regular
+ A non-capturing version of regular parentheses. Matches whatever regular
expression is inside the parentheses, but the substring matched by the group
*cannot* be retrieved after performing a match or referenced later in the
pattern.
Loop over the format_string and return an iterable of tuples
(*literal_text*, *field_name*, *format_spec*, *conversion*). This is used
- by :meth:`vformat` to break the string in to either literal text, or
+ by :meth:`vformat` to break the string into either literal text, or
replacement fields.
The values in the tuple conceptually represent a span of literal text
warnings.simplefilter('default', ImportWarning)
+Default Warning Filters
+~~~~~~~~~~~~~~~~~~~~~~~
+
+By default, Python installs several warning filters, which can be overridden by
+the command-line options passed to :option:`-W` and calls to
+:func:`filterwarnings`.
+
+* :exc:`PendingDeprecationWarning`, and :exc:`ImportWarning` are ignored.
+
+* :exc:`BytesWarning` is ignored unless the :option:`-b` option is given once or
+ twice; in this case this warning is either printed (``-b``) or turned into an
+ exception (``-bb``).
+
+
.. _warning-suppress:
Temporarily Suppressing Warnings
library/nntplib,272,:lines,:lines
library/nntplib,272,:lines,"['xref', 'from', ':lines', ':bytes', 'references', 'date', 'message-id', 'subject']"
library/nntplib,272,:bytes,"['xref', 'from', ':lines', ':bytes', 'references', 'date', 'message-id', 'subject']"
-library/pickle,567,:memory,"conn = sqlite3.connect("":memory:"")"
-library/profile,293,:lineno,"(sort by filename:lineno),"
-library/socket,261,::,"(10, 1, 6, '', ('2001:888:2000:d::a2', 80, 0, 0))]"
+library/pickle,,:memory,"conn = sqlite3.connect("":memory:"")"
+library/profile,,:lineno,"(sort by filename:lineno),"
+library/socket,,::,"(10, 1, 6, '', ('2001:888:2000:d::a2', 80, 0, 0))]"
library/stdtypes,1026,:end,s[start:end]
library/stdtypes,1195,:end,s[start:end]
-library/urllib.request,64,:close,Connection:close
-library/urllib.request,901,:password,"""joe:password@python.org"""
-library/urllib.request,1064,:lang,"xmlns=""http://www.w3.org/1999/xhtml"" xml:lang=""en"" lang=""en"">\n\n<head>\n"
+library/urllib.request,,:close,Connection:close
+library/urllib.request,,:password,"""joe:password@python.org"""
+library/urllib.request,,:lang,"xmlns=""http://www.w3.org/1999/xhtml"" xml:lang=""en"" lang=""en"">\n\n<head>\n"
library/xmlrpc.client,103,:pass,http://user:pass@host:port/path
library/xmlrpc.client,103,:port,http://user:pass@host:port/path
library/xmlrpc.client,103,:pass,user:pass
sys.stdout.write("\nSSLError is %s\n" % x.args[1])
except socket.error as x:
if support.verbose:
- sys.stdout.write("\nsocket.error is %s\n" % x[1])
+ sys.stdout.write("\nsocket.error is %s\n" % x.args[1])
else:
self.fail("Use of invalid cert should have failed!")
finally:
Permissions History
-------------------
+- David Malcolm was given commit access on Oct 27 2010 by GFB,
+ at recommendation by Antoine Pitrou and Raymond Hettinger.
+
- Tal Einat was given commit access on Oct 4 2010 by MvL,
for improving IDLE.
enum decoding_state {
STATE_INIT,
STATE_RAW,
- STATE_NORMAL, /* have a codec associated with input */
+ STATE_NORMAL /* have a codec associated with input */
};
/* Tokenizer state */
if dbfile != self.__databasefile:
colordb = ColorDB.get_colordb(dbfile)
if not self.__master:
- from Tkinter import Tk
+ from tkinter import Tk
self.__master = Tk()
if not self.__pw:
self.__pw, self.__sb = \
\f
# test stuff
if __name__ == '__main__':
- from Tkinter import *
+ from tkinter import *
class Tester:
def __init__(self):
#
# By Bill Janssen.
+import re
+import os
+import ssl
import sys
+import tempfile
-def fetch_server_certificate (host, port):
- import re, tempfile, os, ssl
+def fetch_server_certificate (host, port):
def subproc(cmd):
from subprocess import Popen, PIPE, STDOUT
return status, output
def strip_to_x509_cert(certfile_contents, outfile=None):
- m = re.search(r"^([-]+BEGIN CERTIFICATE[-]+[\r]*\n"
- r".*[\r]*^[-]+END CERTIFICATE[-]+)$",
+ m = re.search(br"^([-]+BEGIN CERTIFICATE[-]+[\r]*\n"
+ br".*[\r]*^[-]+END CERTIFICATE[-]+)$",
certfile_contents, re.MULTILINE | re.DOTALL)
if not m:
return None
else:
tn = tempfile.mktemp()
- fp = open(tn, "w")
- fp.write(m.group(1) + "\n")
+ fp = open(tn, "wb")
+ fp.write(m.group(1) + b"\n")
fp.close()
try:
tn2 = (outfile or tempfile.mktemp())
(host, port))
return certtext
+
if __name__ == "__main__":
if len(sys.argv) < 2:
sys.stderr.write(
sys.exit(1)
for arg in sys.argv[1:]:
host, port = arg.split(":")
- sys.stdout.write(fetch_server_certificate(host, int(port)))
+ sys.stdout.buffer.write(fetch_server_certificate(host, int(port)))
sys.exit(0)
projects / python / commitdiff