#!/usr/bin/env python
# -*- coding: Latin-1 -*-
"""
PySourceColor.py
----------------------------------------------------------------------------
A python source to colorized html/css/xhtml converter.
Hacked by M.E.Farmer Jr. 2004, 2005
Python license
----------------------------------------------------------------------------
- HTML markup does not create w3c valid html, but it works on every
browser i've tried so far.(I.E.,Mozilla/Firefox,Opera,Konqueror,wxHTML).
- CSS markup is w3c validated html 4.01 strict,
but will not render correctly on all browsers.
- XHTML markup is w3c validated xhtml 1.0 strict,
like html 4.01, will not render correctly on all browsers.
----------------------------------------------------------------------------
Features:
-Three types of markup:
html (default)
css/html 4.01 strict
xhtml 1.0 strict
-Can tokenize and colorize:
12 types of strings
2 comment types
numbers
operators
brackets
math operators
class / name
def / name
decorator / name
keywords
arguments class/def/decorator
linenumbers
names
text
-Eight colorschemes built-in:
null
mono
lite (default)
dark
dark2
idle
viewcvs
pythonwin
-Header and footer
set to '' for builtin header / footer.
give path to a file containing the html
you want added as header or footer.
-Arbitrary text and html
html markup converts all to raw (TEXT token)
#@# for raw -> send raw text.
#$# for span -> inline html and text.
#%# for div -> block level html and text.
-Linenumbers
Supports all styles. New token is called LINE.
Defaults to NAME if not defined.
Style options
-ALL markups support these text styles:
b = bold
i = italic
u = underline
-CSS and XHTML has limited support for borders:
HTML markup functions will ignore these.
Optional: Border color in RGB hex
Defaults to the text forecolor.
#rrggbb = border color
Border size:
l = thick
m = medium
t = thin
Border type:
- = dashed
. = dotted
s = solid
d = double
g = groove
r = ridge
n = inset
o = outset
You can specify multiple sides,
they will all use the same style.
Optional: Default is full border.
v = bottom
< = left
> = right
^ = top
NOTE: Specify the styles you want.
The markups will ignore unsupported styles
Also note not all browsers can show these options
-All tokens default to NAME if not defined
so the only absolutely critical ones to define are:
NAME, ERRORTOKEN, PAGEBACKGROUND
----------------------------------------------------------------------------
Example usage:
----------------------------------------------------------------------------
# import
import PySourceColor as psc
psc.convert('c:/Python22/PySourceColor.py', colors=psc.idle, show=1)
----------------------------------------------------------------------------
# from module import *
from PySourceColor import *
convert('c:/Python22/Lib', colors=lite, markup="css",
header='#$#<b>This is a simpe heading</b><hr/>')
----------------------------------------------------------------------------
# How to use a custom colorscheme, and most of the 'features'
from PySourceColor import *
new = {
ERRORTOKEN: ('bui','#FF8080',''),
DECORATOR_NAME: ('s','#AACBBC',''),
DECORATOR: ('n','#333333',''),
NAME: ('t.<v','#1133AA','#DDFF22'),
NUMBER: ('','#236676','#FF5555'),
OPERATOR: ('b','#454567','#BBBB11'),
MATH_OPERATOR: ('','#935623','#423afb'),
BRACKETS: ('b','#ac34bf','#6457a5'),
COMMENT: ('t-#0022FF','#545366','#AABBFF'),
DOUBLECOMMENT: ('<l#553455','#553455','#FF00FF'),
CLASS_NAME: ('m^v-','#000000','#FFFFFF'),
DEF_NAME: ('l=<v','#897845','#000022'),
KEYWORD: ('.b','#345345','#FFFF22'),
SINGLEQUOTE: ('mn','#223344','#AADDCC'),
SINGLEQUOTE_R: ('','#344522',''),
SINGLEQUOTE_U: ('','#234234',''),
DOUBLEQUOTE: ('m#0022FF','#334421',''),
DOUBLEQUOTE_R: ('','#345345',''),
DOUBLEQUOTE_U: ('','#678673',''),
TRIPLESINGLEQUOTE: ('tv','#FFFFFF','#000000'),
TRIPLESINGLEQUOTE_R: ('tbu','#443256','#DDFFDA'),
TRIPLESINGLEQUOTE_U: ('','#423454','#DDFFDA'),
TRIPLEDOUBLEQUOTE: ('li#236fd3b<>','#000000','#FFFFFF'),
TRIPLEDOUBLEQUOTE_R: ('tub','#000000','#FFFFFF'),
TRIPLEDOUBLEQUOTE_U: ('-', '#CCAABB','#FFFAFF'),
LINE: ('ib-','#ff66aa','#7733FF'),]
TEXT: ('','#546634',''),
PAGEBACKGROUND: '#FFFAAA',
}
if __name__ == '__main__':
import sys
convert(sys.argv[1], './xhtml.html', colors=new, markup='xhtml', show=1,
linenumbers=1)
convert(sys.argv[1], './html.html', colors=new, markup='html', show=1,
linenumbers=1)
----------------------------------------------------------------------------
"""
__all__ = ['ERRORTOKEN','DECORATOR_NAME', 'DECORATOR', 'ARGS','TOKEN_NAMES',
'NAME', 'NUMBER', 'OPERATOR', 'COMMENT', 'MATH_OPERATOR',
'DOUBLECOMMENT', 'CLASS_NAME', 'DEF_NAME', 'KEYWORD', 'BRACKETS',
'SINGLEQUOTE','SINGLEQUOTE_R','SINGLEQUOTE_U','DOUBLEQUOTE',
'DOUBLEQUOTE_R', 'DOUBLEQUOTE_U', 'TRIPLESINGLEQUOTE', 'TEXT',
'TRIPLESINGLEQUOTE_R', 'TRIPLESINGLEQUOTE_U', 'TRIPLEDOUBLEQUOTE',
'TRIPLEDOUBLEQUOTE_R', 'TRIPLEDOUBLEQUOTE_U', 'PAGEBACKGROUND', 'LINE',
'null', 'mono', 'lite', 'dark','dark2', 'pythonwin','idle',
'viewcvs', 'Usage', 'cli', 'str2stdout', 'path2stdout', 'Parser',
'str2file', 'str2html', 'str2css', 'str2markup', 'path2file',
'path2html', 'convert', 'walkdir', 'defaultColors', 'showpage',
'pageconvert','tagreplace']
__title__ = 'PySourceColor'
__version__ = "2.0"
__date__ = '15 February 2005'
__author__ = "M.E.Farmer Jr."
__credits__ = '''This was originally based on a python recipe
submitted by Jürgen Hermann to ASPN. Now based on the voices in my head.
M.E.Farmer 2004, 2005
Python license
'''
import os
import sys
import time
import glob
import getopt
import keyword
import token
import tokenize
import cStringIO
import traceback
import webbrowser
# Do not edit
NAME = token.NAME
NUMBER = token.NUMBER
COMMENT = tokenize.COMMENT
OPERATOR = token.OP
ERRORTOKEN = token.ERRORTOKEN
ARGS = token.NT_OFFSET + 1
DOUBLECOMMENT = token.NT_OFFSET + 2
CLASS_NAME = token.NT_OFFSET + 3
DEF_NAME = token.NT_OFFSET + 4
KEYWORD = token.NT_OFFSET + 5
SINGLEQUOTE = token.NT_OFFSET + 6
SINGLEQUOTE_R = token.NT_OFFSET + 7
SINGLEQUOTE_U = token.NT_OFFSET + 8
DOUBLEQUOTE = token.NT_OFFSET + 9
DOUBLEQUOTE_R = token.NT_OFFSET + 10
DOUBLEQUOTE_U = token.NT_OFFSET + 11
TRIPLESINGLEQUOTE = token.NT_OFFSET + 12
TRIPLESINGLEQUOTE_R = token.NT_OFFSET + 13
TRIPLESINGLEQUOTE_U = token.NT_OFFSET + 14
TRIPLEDOUBLEQUOTE = token.NT_OFFSET + 15
TRIPLEDOUBLEQUOTE_R = token.NT_OFFSET + 16
TRIPLEDOUBLEQUOTE_U = token.NT_OFFSET + 17
PAGEBACKGROUND = token.NT_OFFSET + 18
DECORATOR = token.NT_OFFSET + 19
DECORATOR_NAME = token.NT_OFFSET + 20
BRACKETS = token.NT_OFFSET + 21
MATH_OPERATOR = token.NT_OFFSET + 22
LINE = token.NT_OFFSET + 23
TEXT = token.NT_OFFSET + 24
# markup classname lookup
MARKUPDICT = {
ERRORTOKEN: 'py_err',
DECORATOR_NAME: 'py_decn',
DECORATOR: 'py_dec',
ARGS: 'py_args',
NAME: 'py_name',
NUMBER: 'py_num',
OPERATOR: 'py_op',
COMMENT: 'py_com',
DOUBLECOMMENT: 'py_dcom',
CLASS_NAME: 'py_clsn',
DEF_NAME: 'py_defn',
KEYWORD: 'py_key',
SINGLEQUOTE: 'py_sq',
SINGLEQUOTE_R: 'py_sqr',
SINGLEQUOTE_U: 'py_squ',
DOUBLEQUOTE: 'py_dq',
DOUBLEQUOTE_R: 'py_dqr',
DOUBLEQUOTE_U: 'py_dqu',
TRIPLESINGLEQUOTE: 'py_tsq',
TRIPLESINGLEQUOTE_R: 'py_tsqr',
TRIPLESINGLEQUOTE_U: 'py_tsqu',
TRIPLEDOUBLEQUOTE: 'py_tdq',
TRIPLEDOUBLEQUOTE_R: 'py_tdqr',
TRIPLEDOUBLEQUOTE_U: 'py_tdqu',
BRACKETS: 'py_bra',
MATH_OPERATOR: 'py_mop',
LINE: 'py_line',
TEXT: 'py_text',
}
# might help users that want to create custom schemes
TOKEN_NAMES= {
'ERRORTOKEN':ERRORTOKEN,
'DECORATOR_NAME':DECORATOR_NAME,
'DECORATOR':DECORATOR,
'ARGS':ARGS,
'NAME':NAME,
'NUMBER':NUMBER,
'OPERATOR':OPERATOR,
'COMMENT':COMMENT,
'DOUBLECOMMENT':DOUBLECOMMENT,
'CLASS_NAME':CLASS_NAME,
'DEF_NAME':DEF_NAME,
'KEYWORD':KEYWORD,
'SINGLEQUOTE':SINGLEQUOTE,
'SINGLEQUOTE_R':SINGLEQUOTE_R,
'SINGLEQUOTE_U':SINGLEQUOTE_U,
'DOUBLEQUOTE':DOUBLEQUOTE,
'DOUBLEQUOTE_R':DOUBLEQUOTE_R,
'DOUBLEQUOTE_U':DOUBLEQUOTE_U,
'TRIPLESINGLEQUOTE':TRIPLESINGLEQUOTE,
'TRIPLESINGLEQUOTE_R':TRIPLESINGLEQUOTE_R,
'TRIPLESINGLEQUOTE_U':TRIPLESINGLEQUOTE_U,
'TRIPLEDOUBLEQUOTE':TRIPLEDOUBLEQUOTE,
'TRIPLEDOUBLEQUOTE_R':TRIPLEDOUBLEQUOTE_R,
'TRIPLEDOUBLEQUOTE_U':TRIPLEDOUBLEQUOTE_U,
'BRACKETS':BRACKETS,
'MATH_OPERATOR':MATH_OPERATOR,
'LINE':LINE,
'TEXT':TEXT,
'PAGEBACKGROUND':PAGEBACKGROUND,
}
######################################################################
# Edit colors and styles to taste
# Create your own scheme, just copy one below , rename and edit.
# Custom styles must at least define NAME, ERRORTOKEN, PAGEBACKGROUND,
# all missing elements will default to NAME.
# See module docstring for details on style attributes.
######################################################################
# Copy null and use it as a starter colorscheme.
null = {# tokentype: ('tags border_color', 'textforecolor', 'textbackcolor')
ERRORTOKEN: ('','#000000',''),# Error token
DECORATOR_NAME: ('','#000000',''),# Decorator name
DECORATOR: ('','#000000',''),# @ symbol
ARGS: ('','#000000',''),# class,def,deco arguments
NAME: ('','#000000',''),# All other text
NUMBER: ('','#000000',''),# 0->10
OPERATOR: ('','#000000',''),# ':','`',';',',','.','='
MATH_OPERATOR: ('','#000000',''),# '+','-','==','!=','*',etc
BRACKETS: ('','#000000',''),# '[',']','(',')','{','}'
COMMENT: ('','#000000',''),# Single comment
DOUBLECOMMENT: ('','#000000',''),## Double comment
CLASS_NAME: ('','#000000',''),# Class name
DEF_NAME: ('','#000000',''),# Def name
KEYWORD: ('','#000000',''),# Python keywords
SINGLEQUOTE: ('','#000000',''),# 'SINGLEQUOTE'
SINGLEQUOTE_R: ('','#000000',''),# r'SINGLEQUOTE'
SINGLEQUOTE_U: ('','#000000',''),# u'SINGLEQUOTE'
DOUBLEQUOTE: ('','#000000',''),# "DOUBLEQUOTE"
DOUBLEQUOTE_R: ('','#000000',''),# r"DOUBLEQUOTE"
DOUBLEQUOTE_U: ('','#000000',''),# u"DOUBLEQUOTE"
TRIPLESINGLEQUOTE: ('','#000000',''),# '''TRIPLESINGLEQUOTE'''
TRIPLESINGLEQUOTE_R: ('','#000000',''),# r'''TRIPLESINGLEQUOTE'''
TRIPLESINGLEQUOTE_U: ('','#000000',''),# u'''TRIPLESINGLEQUOTE'''
TRIPLEDOUBLEQUOTE: ('','#000000',''),# """TRIPLEDOUBLEQUOTE"""
TRIPLEDOUBLEQUOTE_R: ('','#000000',''),# r"""TRIPLEDOUBLEQUOTE"""
TRIPLEDOUBLEQUOTE_U: ('','#000000',''),# u"""TRIPLEDOUBLEQUOTE"""
TEXT: ('','#000000',''),# non python text
LINE: ('>ti#555555','#000000',''),# Linenumbers
PAGEBACKGROUND: '#FFFFFF'# set the page background
}
mono = {
ERRORTOKEN: ('s#FF0000','#FF8080',''),
DECORATOR_NAME: ('bu','#000000',''),
DECORATOR: ('b','#000000',''),
ARGS: ('b','#000000',''),
NAME: ('','#000000',''),
NUMBER: ('b','#000000',''),
OPERATOR: ('b','#000000',''),
MATH_OPERATOR: ('b','#000000',''),
BRACKETS: ('b','#000000',''),
COMMENT: ('i','#000000',''),
DOUBLECOMMENT: ('b','#000000',''),
CLASS_NAME: ('bu','#000000',''),
DEF_NAME: ('b','#000000',''),
KEYWORD: ('b','#000000',''),
SINGLEQUOTE: ('','#000000',''),
SINGLEQUOTE_R: ('','#000000',''),
SINGLEQUOTE_U: ('','#000000',''),
DOUBLEQUOTE: ('','#000000',''),
DOUBLEQUOTE_R: ('','#000000',''),
DOUBLEQUOTE_U: ('','#000000',''),
TRIPLESINGLEQUOTE: ('','#000000',''),
TRIPLESINGLEQUOTE_R: ('','#000000',''),
TRIPLESINGLEQUOTE_U: ('','#000000',''),
TRIPLEDOUBLEQUOTE: ('i','#000000',''),
TRIPLEDOUBLEQUOTE_R: ('i','#000000',''),
TRIPLEDOUBLEQUOTE_U: ('i','#000000',''),
TEXT: ('','#000000',''),
LINE: ('>ti#555555','#000000',''),
PAGEBACKGROUND: '#FFFFFF'
}
dark = {
ERRORTOKEN: ('s#FF0000','#FF8080',''),
DECORATOR_NAME: ('b','#FFBBAA',''),
DECORATOR: ('b','#CC5511',''),
ARGS: ('b','#CCCCEE',''),
NAME: ('','#DDDDDD',''),
NUMBER: ('','#FF0000',''),
OPERATOR: ('b','#FAF785',''),
MATH_OPERATOR: ('b','#FAF785',''),
BRACKETS: ('b','#FAF785',''),
COMMENT: ('','#45FCA0',''),
DOUBLECOMMENT: ('i','#A7C7A9',''),
CLASS_NAME: ('b','#B666FD',''),
DEF_NAME: ('b','#EBAE5C',''),
KEYWORD: ('b','#8680FF',''),
SINGLEQUOTE: ('','#F8BAFE',''),
SINGLEQUOTE_R: ('','#F8BAFE',''),
SINGLEQUOTE_U: ('','#F8BAFE',''),
DOUBLEQUOTE: ('','#FF80C0',''),
DOUBLEQUOTE_R: ('','#FF80C0',''),
DOUBLEQUOTE_U: ('','#FF80C0',''),
TRIPLESINGLEQUOTE: ('','#FF9595',''),
TRIPLESINGLEQUOTE_R: ('','#FF9595',''),
TRIPLESINGLEQUOTE_U: ('','#FF9595',''),
TRIPLEDOUBLEQUOTE: ('','#B3FFFF',''),
TRIPLEDOUBLEQUOTE_R: ('','#B3FFFF',''),
TRIPLEDOUBLEQUOTE_U: ('','#B3FFFF',''),
TEXT: ('','#FFFFFF',''),
LINE: ('>mi#555555','#bbccbb','#333333'),
PAGEBACKGROUND: '#000000'
}
dark2 = {
ERRORTOKEN: ('','#FF0000',''),
DECORATOR_NAME: ('b','#FFBBAA',''),
DECORATOR: ('b','#CC5511',''),
ARGS: ('b','#EEEEEE',''),
NAME: ('','#C0C0C0',''),
NUMBER: ('b','#00FF00',''),
OPERATOR: ('b','#FF090F',''),
MATH_OPERATOR: ('b','#F07040',''),
BRACKETS: ('b','#FFB90F',''),
COMMENT: ('i','#D0D000','#522000'),#622000
DOUBLECOMMENT: ('i','#D0D000','#522000'),
CLASS_NAME: ('b','#EE4080',''),
DEF_NAME: ('b','#FF8040',''),
KEYWORD: ('b','#4726E1',''),
SINGLEQUOTE: ('','#8080C0',''),
SINGLEQUOTE_R: ('','#8080C0',''),
SINGLEQUOTE_U: ('','#8080C0',''),
DOUBLEQUOTE: ('','#ADB9F1',''),
DOUBLEQUOTE_R: ('','#ADB9F1',''),
DOUBLEQUOTE_U: ('','#ADB9F1',''),
TRIPLESINGLEQUOTE: ('','#00C1C1',''),
TRIPLESINGLEQUOTE_R: ('','#00C1C1',''),
TRIPLESINGLEQUOTE_U: ('','#00C1C1',''),
TRIPLEDOUBLEQUOTE: ('','#33E3E3',''),
TRIPLEDOUBLEQUOTE_R: ('','#33E3E3',''),
TRIPLEDOUBLEQUOTE_U: ('','#33E3E3',''),
TEXT: ('','#C0C0C0',''),
LINE: ('>mi#555555','#bbccbb','#333333'),
PAGEBACKGROUND: '#000000'
}
lite = {
ERRORTOKEN: ('s#FF0000','#FF8080',''),
DECORATOR_NAME: ('b','#BB4422',''),
DECORATOR: ('b','#3333AF',''),
ARGS: ('b','#000000',''),
NAME: ('','#333333',''),
NUMBER: ('b','#DD2200',''),
OPERATOR: ('b','#000000',''),
MATH_OPERATOR: ('b','#000000',''),
BRACKETS: ('b','#000000',''),
COMMENT: ('','#007F00',''),
DOUBLECOMMENT: ('','#608060',''),
CLASS_NAME: ('b','#0000FF',''),
DEF_NAME: ('b','#9C7A00',''),#f09030
KEYWORD: ('b','#0000AF',''),
SINGLEQUOTE: ('','#600080',''),
SINGLEQUOTE_R: ('','#600080',''),
SINGLEQUOTE_U: ('','#600080',''),
DOUBLEQUOTE: ('','#A0008A',''),
DOUBLEQUOTE_R: ('','#A0008A',''),
DOUBLEQUOTE_U: ('','#A0008A',''),
TRIPLESINGLEQUOTE: ('','#337799',''),
TRIPLESINGLEQUOTE_R: ('','#337799',''),
TRIPLESINGLEQUOTE_U: ('','#337799',''),
TRIPLEDOUBLEQUOTE: ('','#1166AA',''),
TRIPLEDOUBLEQUOTE_R: ('','#1166AA',''),
TRIPLEDOUBLEQUOTE_U: ('','#1166AA',''),
TEXT: ('','#000000',''),
LINE: ('>ti#555555','#000000',''),
PAGEBACKGROUND: '#FFFFFF'
}
idle = {
ERRORTOKEN: ('s#FF0000','#FF8080',''),
DECORATOR_NAME: ('','#900090',''),
DECORATOR: ('','#FF7700',''),
NAME: ('','#000000',''),
NUMBER: ('','#000000',''),
OPERATOR: ('','#000000',''),
MATH_OPERATOR: ('','#000000',''),
BRACKETS: ('','#000000',''),
COMMENT: ('','#DD0000',''),
DOUBLECOMMENT: ('','#DD0000',''),
CLASS_NAME: ('','#0000FF',''),
DEF_NAME: ('','#0000FF',''),
KEYWORD: ('','#FF7700',''),
SINGLEQUOTE: ('','#00AA00',''),
SINGLEQUOTE_R: ('','#00AA00',''),
SINGLEQUOTE_U: ('','#00AA00',''),
DOUBLEQUOTE: ('','#00AA00',''),
DOUBLEQUOTE_R: ('','#00AA00',''),
DOUBLEQUOTE_U: ('','#00AA00',''),
TRIPLESINGLEQUOTE: ('','#00AA00',''),
TRIPLESINGLEQUOTE_R: ('','#00AA00',''),
TRIPLESINGLEQUOTE_U: ('','#00AA00',''),
TRIPLEDOUBLEQUOTE: ('','#00AA00',''),
TRIPLEDOUBLEQUOTE_R: ('','#00AA00',''),
TRIPLEDOUBLEQUOTE_U: ('','#00AA00',''),
TEXT: ('','#000000',''),
LINE: ('>ti#555555','#000000',''),
PAGEBACKGROUND: '#FFFFFF'
}
pythonwin = {
ERRORTOKEN: ('s#FF0000','#FF8080',''),
DECORATOR_NAME: ('b','#DD0080',''),
DECORATOR: ('b','#000080',''),
ARGS: ('','#000000',''),
NAME: ('','#303030',''),
NUMBER: ('','#008080',''),
OPERATOR: ('','#000000',''),
MATH_OPERATOR: ('','#000000',''),
BRACKETS: ('','#000000',''),
COMMENT: ('','#007F00',''),
DOUBLECOMMENT: ('','#7F7F7F',''),
CLASS_NAME: ('b','#0000FF',''),
DEF_NAME: ('b','#007F7F',''),
KEYWORD: ('b','#000080',''),
SINGLEQUOTE: ('','#808000',''),
SINGLEQUOTE_R: ('','#808000',''),
SINGLEQUOTE_U: ('','#808000',''),
DOUBLEQUOTE: ('','#808000',''),
DOUBLEQUOTE_R: ('','#808000',''),
DOUBLEQUOTE_U: ('','#808000',''),
TRIPLESINGLEQUOTE: ('','#808000',''),
TRIPLESINGLEQUOTE_R: ('','#808000',''),
TRIPLESINGLEQUOTE_U: ('','#808000',''),
TRIPLEDOUBLEQUOTE: ('','#808000',''),
TRIPLEDOUBLEQUOTE_R: ('','#808000',''),
TRIPLEDOUBLEQUOTE_U: ('','#808000',''),
TEXT: ('','#303030',''),
LINE: ('>ti#555555','#000000',''),
PAGEBACKGROUND: '#FFFFFF'
}
viewcvs = {
ERRORTOKEN: ('s#FF0000','#FF8080',''),
DECORATOR_NAME: ('','#000000',''),
DECORATOR: ('','#000000',''),
ARGS: ('','#000000',''),
NAME: ('','#000000',''),
NUMBER: ('','#000000',''),
OPERATOR: ('','#000000',''),
MATH_OPERATOR: ('','#000000',''),
BRACKETS: ('','#000000',''),
COMMENT: ('i','#b22222',''),
DOUBLECOMMENT: ('i','#b22222',''),
CLASS_NAME: ('','#000000',''),
DEF_NAME: ('b','#0000ff',''),
KEYWORD: ('b','#a020f0',''),
SINGLEQUOTE: ('b','#bc8f8f',''),
SINGLEQUOTE_R: ('b','#bc8f8f',''),
SINGLEQUOTE_U: ('b','#bc8f8f',''),
DOUBLEQUOTE: ('b','#bc8f8f',''),
DOUBLEQUOTE_R: ('b','#bc8f8f',''),
DOUBLEQUOTE_U: ('b','#bc8f8f',''),
TRIPLESINGLEQUOTE: ('b','#bc8f8f',''),
TRIPLESINGLEQUOTE_R: ('b','#bc8f8f',''),
TRIPLESINGLEQUOTE_U: ('b','#bc8f8f',''),
TRIPLEDOUBLEQUOTE: ('b','#bc8f8f',''),
TRIPLEDOUBLEQUOTE_R: ('b','#bc8f8f',''),
TRIPLEDOUBLEQUOTE_U: ('b','#bc8f8f',''),
TEXT: ('','#000000',''),
LINE: ('>ti#555555','#000000',''),
PAGEBACKGROUND: '#FFFFFF'
}
defaultColors = lite
def Usage():
"""
-----------------------------------------------------------------------------
PySourceColor.py ver: %s
-----------------------------------------------------------------------------
Module summary:
This module is designed to colorize python source code.
Input--->python source
Output-->colorized (html, html4.01/css, xhtml1.0)
Standalone:
This module will work from the command line with options.
This module will work with redirected stdio.
Imported:
This module can be imported and used directly in your code.
-----------------------------------------------------------------------------
Command line options:
-h, --help
Optional-> Display this help message.
-t, --test
Optional-> Will ignore all others flags but --profile
test all schemes and markup combinations
-p, --profile
Optional-> Works only with --test or -t
runs profile.py and makes the test work in quiet mode.
-i, --in, --input
Optional-> If you give input on stdin.
Use any of these for the current dir (.,cwd)
Input can be file or dir.
Input from stdin use one of the following (-,stdin)
If stdin is used as input stdout is output unless specified.
-o, --out, --output
Optional-> output dir for the colorized source.
default: output dir is the input dir.
To output html to stdout use one of the following (-,stdout)
Stdout can be used without stdin if you give a file as input.
-c, --color
Optional-> null, mono, dark, dark2, lite, idle, pythonwin, viewcvs
default: dark
-s, --show
Optional-> Show page after creation.
default: no show
-m, --markup
Optional-> html, css, xhtml
css, xhtml also support external stylesheets (-e,--external)
default: HTML
-e, --external
Optional-> use with css, xhtml
Writes an style sheet instead of embedding it in the page
saves it as pystyle.css in the same directory.
html markup will silently ignore this flag.
-H, --header
Opional-> add a page header to the top of the output
-H
Builtin header (name,date,hrule)
--header
You must specify a filename.
The header file must be valid html
and must handle its own font colors.
ex. --header c:/tmp/header.txt
-F, --footer
Opional-> add a page footer to the bottom of the output
-F
Builtin footer (hrule,name,date)
--footer
You must specify a filename.
The footer file must be valid html
and must handle its own font colors.
ex. --footer c:/tmp/footer.txt
-l, --linenumbers
Optional-> default is no linenumbers
Adds line numbers to the start of each line in the code.
--convertpage
Given a webpage that has code embedded in tags it will
convert embedded code to colorized html.
(see pageconvert for details)
-----------------------------------------------------------------------------
Option usage:
# Test and show pages
python PySourceColor.py -t -s
# Test and only show profile results
python PySourceColor.py -t -p
# Colorize all .py,.pyw files in cwdir you can also use: (.,cwd)
python PySourceColor.py -i .
# Using long options w/ =
python PySourceColor.py --in=c:/myDir/my.py --color=lite --show
# Using short options w/out =
python PySourceColor.py -i c:/myDir/ -c idle -m css -e
# Using any mix
python PySourceColor.py --in . -o=c:/myDir --show
# Place a custom header on your files
python PySourceColor.py -i . -o c:/tmp -m xhtml --header c:/header.txt
-----------------------------------------------------------------------------
Stdio usage:
# Stdio using no options
python PySourceColor.py < c:/MyFile.py >> c:/tmp/MyFile.html
# Using stdin alone automatically uses stdout for output: (stdin,-)
python PySourceColor.py -i- < c:/MyFile.py >> c:/tmp/myfile.html
# Stdout can also be written to directly from a file instead of stdin
python PySourceColor.py -i c:/MyFile.py -m css -o- >> c:/tmp/myfile.html
# Stdin can be used as input , but output can still be specified
python PySourceColor.py -i- -o c:/pydoc.py.html -s < c:/Python22/my.py
_____________________________________________________________________________
"""
print Usage.__doc__% (__version__)
sys.exit(1)
###################################################### Command line interface
def cli():
"""Handle command line args and redirections"""
try:
# try to get command line args
opts, args = getopt.getopt(sys.argv[1:],
"hseqtplHFi:o:c:m:h:f:",["help", "show", "quiet",
"test", "external", "linenumbers", "convertpage", "profile",
"input=", "output=", "color=", "markup=","header=", "footer="])
except getopt.GetoptError:
# on error print help information and exit:
Usage()
# init some names
input = None
output = None
colorscheme = None
markup = 'html'
header = None
footer = None
linenumbers = 0
show = 0
quiet = 0
test = 0
profile = 0
convertpage = 0
form = None
# if we have args then process them
for o, a in opts:
if o in ["-h", "--help"]:
Usage()
sys.exit()
if o in ["-o", "--output", "--out"]:
output = a
if o in ["-i", "--input", "--in"]:
input = a
if input in [".", "cwd"]:
input = os.getcwd()
if o in ["-s", "--show"]:
show = 1
if o in ["-q", "--quiet"]:
quiet = 1
if o in ["-t", "--test"]:
test = 1
if o in ["--convertpage"]:
convertpage = 1
if o in ["-p", "--profile"]:
profile = 1
if o in ["-e", "--external"]:
form = 'external'
if o in ["-m", "--markup"]:
markup = str(a)
if o in ["-l", "--linenumbers"]:
linenumbers = 1
if o in ["--header"]:
header = str(a)
elif o == "-H":
header = ''
if o in ["--footer"]:
footer = str(a)
elif o == "-F":
footer = ''
if o in ["-c", "--color"]:
try:
colorscheme = globals().get(a.lower())
except:
traceback.print_exc()
Usage()
if test:
if profile:
import profile
profile.run('_test(show=%s, quiet=%s)'%(show,quiet))
else:
# Parse this script in every possible colorscheme and markup
_test(show,quiet)
elif input in [None, "-", "stdin"] or output in ["-", "stdout"]:
# determine if we are going to use stdio
if input not in [None, "-", "stdin"]:
if os.path.isfile(input) :
path2stdout(input, colors=colorscheme, markup=markup,
linenumbers=linenumbers, header=header,
footer=footer, form=form)
else:
raise PathError, 'File does not exists!'
else:
try:
if sys.stdin.isatty():
raise InputError, 'Please check input!'
else:
if output in [None,"-","stdout"]:
str2stdout(sys.stdin.read(), colors=colorscheme,
markup=markup, header=header,
footer=footer, linenumbers=linenumbers,
form=form)
else:
str2file(sys.stdin.read(), outfile=output, show=show,
markup=markup, header=header, footer=footer,
linenumbers=linenumbers, form=form)
except:
traceback.print_exc()
Usage()
else:
if os.path.exists(input):
if convertpage:
# if there was at least an input given we can proceed
pageconvert(input, out=output, colors=colorscheme,
show=show, markup=markup,linenumbers=linenumbers)
else:
# if there was at least an input given we can proceed
convert(source=input, outdir=output, colors=colorscheme,
show=show, markup=markup, quiet=quiet, header=header,
footer=footer, linenumbers=linenumbers, form=form)
else:
raise PathError, 'File does not exists!'
Usage()
######################################################### Simple markup tests
def _test(show=0, quiet=0):
"""Test the parser and most of the functions.
There are 19 test total(eight colorschemes in three diffrent markups,
and a str2file test. Most functions are tested by this.
"""
fi = sys.argv[0]
if not fi.endswith('.exe'):# Do not test if frozen as an archive
# this is a collection of test, most things are covered.
path2file(fi, '/tmp/null.html', null, show=show, quiet=quiet)
path2file(fi, '/tmp/null_css.html', null, show=show,
markup='css', quiet=quiet)
path2file(fi, '/tmp/mono.html', mono, show=show, quiet=quiet)
path2file(fi, '/tmp/mono_css.html', mono, show=show,
markup='css', quiet=quiet)
path2file(fi, '/tmp/lite.html', lite, show=show, quiet=quiet)
path2file(fi, '/tmp/lite_css.html', lite, show=show,
markup='css', quiet=quiet, header='', footer='',
linenumbers=1)
path2file(fi, '/tmp/lite_xhtml.html', lite, show=show,
markup='xhtml', quiet=quiet)
path2file(fi, '/tmp/dark.html', dark, show=show, quiet=quiet)
path2file(fi, '/tmp/dark_css.html', dark, show=show,
markup='css', quiet=quiet, linenumbers=1)
path2file(fi, '/tmp/dark2.html', dark2, show=show, quiet=quiet)
path2file(fi, '/tmp/dark2_css.html', dark2, show=show,
markup='css', quiet=quiet)
path2file(fi, '/tmp/dark2_xhtml.html', dark2, show=show,
markup='xhtml', quiet=quiet, header='', footer='',
linenumbers=1, form='external')
path2file(fi, '/tmp/idle.html', idle, show=show, quiet=quiet)
path2file(fi, '/tmp/idle_css.html', idle, show=show,
markup='css', quiet=quiet)
path2file(fi, '/tmp/viewcvs.html', viewcvs, show=show,
quiet=quiet, linenumbers=1)
path2file(fi, '/tmp/viewcvs_css.html', viewcvs, show=show,
markup='css', linenumbers=1, quiet=quiet)
path2file(fi, '/tmp/pythonwin.html', pythonwin, show=show,
quiet=quiet)
path2file(fi, '/tmp/pythonwin_css.html', pythonwin, show=show,
markup='css', quiet=quiet)
teststr=r'''"""This is a test of decorators and other things"""
# This should be line 421...
@whatever(arg,arg2)
@A @B(arghh) @C
def LlamaSaysNi(arg='Ni!',arg2="RALPH"):
"""This docstring is deeply disturbed by all the llama references"""
print '%s The Wonder Llama says %s'% (arg2,arg)
# So I was like duh!, and he was like ya know?!,
# and so we were both like huh...wtf!? RTFM!! LOL!!;)
@staticmethod## Double comments are KewL.
def LlamasRLumpy():
"""This docstring is too sexy to be here.
"""
u"""
=============================
A Møøse once bit my sister...
=============================
"""
## Relax, this won't hurt a bit, just a simple, painless procedure,
## hold still while I get the anesthetizing hammer.
m = {'three':'1','won':'2','too':'3'}
o = r'fishy\fishy\fishy/fish\oh/where/is\my/little\..'
python = uR"""
No realli! She was Karving her initials øn the møøse with the sharpened end
of an interspace tøøthbrush given her by Svenge - her brother-in-law -an Oslo
dentist and star of many Norwegian møvies: "The Høt Hands of an Oslo
Dentist", "Fillings of Passion", "The Huge Mølars of Horst Nordfink"..."""
RU"""142 MEXICAN WHOOPING LLAMAS"""#<-Can you fit 142 llamas in a red box?
n = u' HERMSGERVØRDENBRØTBØRDA ' + """ YUTTE """
t = """SAMALLNIATNUOMNAIRODAUCE"""+"DENIARTYLLAICEPS04"
## We apologise for the fault in the
## comments. Those responsible have been
## sacked.
y = '14 NORTH CHILEAN GUANACOS \
(CLOSELY RELATED TO THE LLAMA)'
rules = [0,1,2,3,4,5]
print y'''
htmlPath = os.path.abspath('/tmp/strtest.html')
str2file(teststr, htmlPath, colors=dark, markup='xhtml',
linenumbers=420, show=show)
_printinfo(" wrote %s" % htmlPath, quiet)
else:
Usage()
return
####################################################### User funtctions
def str2stdout(sourcestring, colors=None, title='', markup='html',
header=None, footer=None,
linenumbers=0, form=None):
"""Converts a code(string) to colorized HTML. Writes to stdout.
form='code',or'snip' (for "<pre>yourcode</pre>" only)
colors=null,mono,lite,dark,dark2,idle,or pythonwin
"""
Parser(sourcestring, colors=colors, title=title, markup=markup,
header=header, footer=footer,
linenumbers=linenumbers).format(form)
def path2stdout(sourcepath, title='', colors=None, markup='html',
header=None, footer=None,
linenumbers=0, form=None):
"""Converts code(file) to colorized HTML. Writes to stdout.
form='code',or'snip' (for "<pre>yourcode</pre>" only)
colors=null,mono,lite,dark,dark2,idle,or pythonwin
"""
sourcestring = open(sourcepath).read()
Parser(sourcestring, colors=colors, title=sourcepath,
markup=markup, header=header, footer=footer,
linenumbers=linenumbers).format(form)
def str2html(sourcestring, colors=None, title='',
markup='html', header=None, footer=None,
linenumbers=0, form=None):
"""Converts a code(string) to colorized HTML. Returns an HTML string.
form='code',or'snip' (for "<pre>yourcode</pre>" only)
colors=null,mono,lite,dark,dark2,idle,or pythonwin
"""
stringIO = cStringIO.StringIO()
Parser(sourcestring, colors=colors, title=title, out=stringIO,
markup=markup, header=header, footer=footer,
linenumbers=linenumbers).format(form)
stringIO.seek(0)
return stringIO.read()
def str2css(sourcestring, colors=None, title='',
markup='css', header=None, footer=None,
linenumbers=0, form=None):
"""Converts a code string to colorized CSS/HTML. Returns CSS/HTML string
If form != None then this will return (stylesheet_str, code_str)
colors=null,mono,lite,dark,dark2,idle,or pythonwin
"""
if markup.lower() not in ['css' ,'xhtml']:
markup = 'css'
stringIO = cStringIO.StringIO()
parse = Parser(sourcestring, colors=colors, title=title,
out=stringIO, markup=markup,
header=header, footer=footer,
linenumbers=linenumbers)
parse.format(form)
stringIO.seek(0)
if form != None:
return parse._sendCSSStyle(external=1), stringIO.read()
else:
return None, stringIO.read()
def str2markup(sourcestring, colors=None, title = '',
markup='xhtml', header=None, footer=None,
linenumbers=0, form=None):
""" Convert code strings into ([stylesheet or None], colorized string) """
if markup.lower() == 'html':
return None, str2html(sourcestring, colors=colors, title=title,
header=header, footer=footer, markup=markup,
linenumbers=linenumbers, form=form)
else:
return str2css(sourcestring, colors=colors, title=title,
header=header, footer=footer, markup=markup,
linenumbers=linenumbers, form=form)
def str2file(sourcestring, outfile, colors=None, title='',
markup='html', header=None, footer=None,
linenumbers=0, show=0, dosheet=1, form=None):
"""Converts a code string to a file.
makes no attempt at correcting bad pathnames
"""
css , html = str2markup(sourcestring, colors=colors, title='',
markup=markup, header=header, footer=footer,
linenumbers=linenumbers, form=form)
# write html
f = open(outfile,'wt')
f.writelines(html)
f.close()
#write css
if css != None and dosheet:
dir = os.path.dirname(outfile)
outfile = os.path.join(dir,'pystyle.css')
f = open(outfile,'wt')
f.writelines(css)
f.close()
if show:
showpage(outfile)
def path2html(sourcepath, colors=None, markup='html',
header=None, footer=None,
linenumbers=0, form=None):
"""Converts code(file) to colorized HTML. Returns an HTML string.
form='code',or'snip' (for "<pre>yourcode</pre>" only)
colors=null,mono,lite,dark,dark2,idle,or pythonwin
"""
stringIO = cStringIO.StringIO()
sourcestring = open(sourcepath).read()
Parser(sourcestring, colors, title=sourcepath, out=stringIO,
markup=markup, header=header, footer=footer,
linenumbers=linenumbers).format(form)
stringIO.seek(0)
return stringIO.read()
def convert(source, outdir=None, colors=None,
show=0, markup='html', quiet=0,
header=None, footer=None, linenumbers=0, form=None):
"""Takes a file or dir as input and places the html in the outdir.
If outdir is none it defaults to the input dir
"""
count=0
# If it is a filename then path2file
if not os.path.isdir(source):
if os.path.isfile(source):
count+=1
path2file(source, outdir, colors, show, markup,
quiet, form, header, footer, linenumbers, count)
else:
raise PathError, 'File does not exist!'
# If we pass in a dir we need to walkdir for files.
# Then we need to colorize them with path2file
else:
fileList = walkdir(source)
if fileList != None:
# make sure outdir is a dir
if outdir != None:
if os.path.splitext(outdir)[1] != '':
outdir = os.path.split(outdir)[0]
for item in fileList:
count+=1
path2file(item, outdir, colors, show, markup,
quiet, form, header, footer, linenumbers, count)
_printinfo('Completed colorizing %s files.'%str(count), quiet)
else:
_printinfo("No files to convert in dir.", quiet)
def path2file(sourcePath, out=None, colors=None, show=0,
markup='html', quiet=0, form=None,
header=None, footer=None, linenumbers=