File python-htmltmpl-1.22-performance.patch of Package python-htmltmpl

Index: htmltmpl.py
===================================================================
RCS file: /cvsroot/htmltmpl/htmltmpl/htmltmpl.py,v
retrieving revision 1.16
diff -a -u -r1.16 htmltmpl.py
--- htmltmpl.py	17 Dec 2001 07:21:04 -0000	1.16
+++ htmltmpl.py	3 Jul 2003 11:11:56 -0000
@@ -76,6 +76,12 @@
 LOCK_SH = 2
 LOCK_UN = 3
 
+def DEB(str):
+ """ Print debugging message to stderr.
+ @hidden
+ """
+ print >> sys.stderr, str
+
 ##############################################
 # CLASS: TemplateManager #
 ##############################################
@@ -166,7 +172,7 @@
 if precompile and not LOCKTYPE:
 raise TemplateError, "Template precompilation is not "\
 "available on this platform."
- self.DEB("INIT DONE")
+ self._debug and DEB("INIT DONE")
 
 def prepare(self, file):
 """ Preprocess, parse, tokenize and compile the template.
@@ -212,17 +218,17 @@
 compile_params = (self._include, self._max_include,
 self._comments, self._gettext)
 if precompiled.is_uptodate(compile_params):
- self.DEB("PRECOMPILED: UPTODATE")
+ self._debug and DEB("PRECOMPILED: UPTODATE")
 compiled = precompiled
 else:
- self.DEB("PRECOMPILED: NOT UPTODATE")
+ self._debug and DEB("PRECOMPILED: NOT UPTODATE")
 compiled = self.update(precompiled)
 else:
- self.DEB("PRECOMPILED: NOT PRECOMPILED")
+ self._debug and DEB("PRECOMPILED: NOT PRECOMPILED")
 compiled = self.compile(file)
 self.save_precompiled(compiled)
 else:
- self.DEB("PRECOMPILATION DISABLED")
+ self._debug and DEB("PRECOMPILATION DISABLED")
 compiled = self.compile(file)
 return compiled
 
@@ -244,7 +250,7 @@
 TemplateCompiler. The instance must represent a template
 compiled from a file on disk.
 """
- self.DEB("UPDATE")
+ self._debug and DEB("UPDATE")
 updated = self.compile(template.file())
 if self._precompile:
 self.save_precompiled(updated)
@@ -254,12 +260,6 @@
 # PRIVATE METHODS #
 ############################################## 
 
- def DEB(self, str):
- """ Print debugging message to stderr if debugging is enabled. 
- @hidden
- """
- if self._debug: print >> sys.stderr, str
-
 def lock_file(self, file, lock):
 """ Provide platform independent file locking.
 @hidden
@@ -316,7 +316,7 @@
 @hidden
 """
 filename = file + "c" # "template.tmplc"
- self.DEB("LOADING PRECOMPILED")
+ self._debug and DEB("LOADING PRECOMPILED")
 try:
 remove_bad = 0
 file = None
@@ -390,7 +390,7 @@
 remove_bad = 1
 raise
 else:
- self.DEB("SAVING PRECOMPILED")
+ self._debug and DEB("SAVING PRECOMPILED")
 finally:
 if file:
 self.lock_file(file, LOCK_UN)
@@ -439,7 +439,7 @@
 should be automatically looked up in enclosing scopes.
 
 Automatic global lookup is disabled by default. Global lookup
- can be overriden on a per-variable basis by the
+ can be overridden on a per-variable basis by the
 GLOBAL parameter of a TMPL_VAR
 statement.
 
@@ -499,7 +499,7 @@
 raise TemplateError, "Value of toplevel variable '%s' must "\
 "be either a scalar or a list." % var
 self._vars[var] = value
- self.DEB("VALUE SET: " + str(var))
+ self._debug and DEB("VALUE SET: " + str(var))
 
 def reset(self, keep_data=0):
 """ Reset the template data.
@@ -521,7 +521,7 @@
 self._current_pos = 0
 if not keep_data:
 self._vars.clear()
- self.DEB("RESET")
+ self._debug and DEB("RESET")
 
 def process(self, template, part=None):
 """ Process a compiled template. Return the result as string.
@@ -549,7 +549,7 @@
 If this parameter is not specified, then the whole template
 is processed, or all remaining parts are processed.
 """
- self.DEB("APP INPUT:")
+ self._debug and DEB("APP INPUT:")
 if self._debug: pprint.pprint(self._vars, sys.stderr)
 if part != None and (part == 0 or part < self._current_part):
 raise TemplateError, "process() - invalid part number"
@@ -574,7 +574,7 @@
 
 tokens = template.tokens()
 len_tokens = len(tokens)
- out = "" # buffer for processed output
+ out = [] # buffer for processed output
 
 # Recover position at which we ended after processing of last part.
 i = self._current_pos
@@ -601,12 +601,12 @@
 skip_params = 1
 
 # If output of current block is not disabled then append
- # the substitued and escaped variable to the output.
+ # the substituted and escaped variable to the output.
 if DISABLE_OUTPUT not in output_control:
 value = str(self.find_value(var, loop_name, loop_pass,
 loop_total, globalp))
- out += self.escape(value, escape)
- self.DEB("VAR: " + str(var))
+ out.append(self.escape(value, escape))
+ self._debug and DEB("VAR: " + str(var))
 
 elif token == "<TMPL_LOOP":
 var = tokens[i + PARAM_NAME]
@@ -629,10 +629,10 @@
 if passtotal == 0:
 # This loop is empty.
 output_control.append(DISABLE_OUTPUT)
- self.DEB("LOOP: DISABLE: " + str(var))
+ self._debug and DEB("LOOP: DISABLE: " + str(var))
 else:
 output_control.append(ENABLE_OUTPUT)
- self.DEB("LOOP: FIRST PASS: %s TOTAL: %d"\
+ self._debug and DEB("LOOP: FIRST PASS: %s TOTAL: %d"\
 % (var, passtotal))
 
 elif token == "<TMPL_IF":
@@ -644,10 +644,10 @@
 if self.find_value(var, loop_name, loop_pass,
 loop_total, globalp):
 output_control.append(ENABLE_OUTPUT)
- self.DEB("IF: ENABLE: " + str(var))
+ self._debug and DEB("IF: ENABLE: " + str(var))
 else:
 output_control.append(DISABLE_OUTPUT)
- self.DEB("IF: DISABLE: " + str(var))
+ self._debug and DEB("IF: DISABLE: " + str(var))
 
 elif token == "<TMPL_UNLESS":
 var = tokens[i + PARAM_NAME]
@@ -658,10 +658,10 @@
 if self.find_value(var, loop_name, loop_pass,
 loop_total, globalp):
 output_control.append(DISABLE_OUTPUT)
- self.DEB("UNLESS: DISABLE: " + str(var))
+ self._debug and DEB("UNLESS: DISABLE: " + str(var))
 else:
 output_control.append(ENABLE_OUTPUT)
- self.DEB("UNLESS: ENABLE: " + str(var))
+ self._debug and DEB("UNLESS: ENABLE: " + str(var))
 
 elif token == "</TMPL_LOOP":
 skip_params = 1
@@ -679,26 +679,26 @@
 loop_start.pop()
 loop_total.pop()
 output_control.pop()
- self.DEB("LOOP: END")
+ self._debug and DEB("LOOP: END")
 else:
- # Jump to the beggining of this loop block 
+ # Jump to the beginning of this loop block 
 # to process next pass of the loop.
 i = loop_start[-1]
- self.DEB("LOOP: NEXT PASS")
+ self._debug and DEB("LOOP: NEXT PASS")
 
 elif token == "</TMPL_IF":
 skip_params = 1
 if not output_control:
 raise TemplateError, "Unmatched </TMPL_IF>."
 output_control.pop()
- self.DEB("IF: END")
+ self._debug and DEB("IF: END")
 
 elif token == "</TMPL_UNLESS":
 skip_params = 1
 if not output_control:
 raise TemplateError, "Unmatched </TMPL_UNLESS>."
 output_control.pop()
- self.DEB("UNLESS: END")
+ self._debug and DEB("UNLESS: END")
 
 elif token == "<TMPL_ELSE":
 skip_params = 1
@@ -707,23 +707,23 @@
 if output_control[-1] == DISABLE_OUTPUT:
 # Condition was false, activate the ELSE block.
 output_control[-1] = ENABLE_OUTPUT
- self.DEB("ELSE: ENABLE")
+ self._debug and DEB("ELSE: ENABLE")
 elif output_control[-1] == ENABLE_OUTPUT:
 # Condition was true, deactivate the ELSE block.
 output_control[-1] = DISABLE_OUTPUT
- self.DEB("ELSE: DISABLE")
+ self._debug and DEB("ELSE: DISABLE")
 else:
 raise TemplateError, "BUG: ELSE: INVALID FLAG"
 
 elif token == "<TMPL_BOUNDARY":
 if part and part == self._current_part:
- self.DEB("BOUNDARY ON")
+ self._debug and DEB("BOUNDARY ON")
 self._current_part += 1
 self._current_pos = i + 1 + PARAMS_NUMBER
 break
 else:
 skip_params = 1
- self.DEB("BOUNDARY OFF")
+ self._debug and DEB("BOUNDARY OFF")
 self._current_part += 1
 
 elif token == "<TMPL_INCLUDE":
@@ -731,22 +731,22 @@
 # when it was not replaced by the parser.
 skip_params = 1
 filename = tokens[i + PARAM_NAME]
- out += """
+ out.append("""
 
 
 HTMLTMPL WARNING: 
 Cannot include template: %s
 
 
- """ % filename
- self.DEB("CANNOT INCLUDE WARNING")
+ """ % filename)
+ self._debug and DEB("CANNOT INCLUDE WARNING")
 
 elif token == "<TMPL_GETTEXT":
 skip_params = 1
 if DISABLE_OUTPUT not in output_control:
 text = tokens[i + PARAM_GETTEXT_STRING]
- out += gettext.gettext(text)
- self.DEB("GETTEXT: " + text)
+ out.append(gettext.gettext(text))
+ self._debug and DEB("GETTEXT: " + text)
 
 else:
 # Unknown processing directive.
@@ -756,7 +756,7 @@
 # Raw textual template data.
 # If output of current block is not disabled, then 
 # append template data to the output buffer.
- out += token
+ out.append(token)
 
 i += 1
 # end of the big while loop
@@ -764,18 +764,12 @@
 # Check whether all opening statements were closed.
 if loop_name: raise TemplateError, "Missing </TMPL_LOOP>."
 if output_control: raise TemplateError, "Missing </TMPL_IF> or </TMPL_UNLESS>"
- return out
+ return "".join(out)
 
 ##############################################
 # PRIVATE METHODS #
 ##############################################
 
- def DEB(self, str):
- """ Print debugging message to stderr if debugging is enabled.
- @hidden
- """
- if self._debug: print >> sys.stderr, str
-
 def find_value(self, var, loop_name, loop_pass, loop_total,
 global_override=None):
 """ Search the self._vars data structure to find variable var
@@ -783,11 +777,11 @@
 is currently being processed. If the variable is an ordinary
 variable, then return it.
 
- If the variable is an identificator of a loop, then 
+ If the variable is an identifier of a loop, then 
 return the total number of times this loop will
 be executed.
 
- Return an empty string, if the variable is not
+ Return an empty string if the variable is not
 found at all.
 
 @hidden
@@ -808,7 +802,7 @@
 self.is_ordinary_var(scope[var]):
 globals.append(scope[var])
 
- # Descent deeper into the hierarchy.
+ # Descend deeper into the hierarchy.
 if scope.has_key(loop_name[i]) and scope[loop_name[i]]:
 scope = scope[loop_name[i]][loop_pass[i]]
 else:
@@ -843,7 +837,7 @@
 
 @hidden
 """
- self.DEB("MAGIC: '%s', PASS: %d, TOTAL: %d"\
+ self._debug and DEB("MAGIC: '%s', PASS: %d, TOTAL: %d"\
 % (var, loop_pass, loop_total))
 if var == "__FIRST__":
 if loop_pass == 0:
@@ -889,7 +883,7 @@
 raise TemplateError, "Magic variable __EVERY__x: "\
 "Pass number cannot be zero."
 elif (loop_pass + 1) % every == 0:
- self.DEB("MAGIC: EVERY: " + str(every))
+ self._debug and DEB("MAGIC: EVERY: " + str(every))
 return 1
 else:
 return 0
@@ -934,7 +928,7 @@
 class. The compiled form is used as input for the TemplateProcessor
 which uses it to actually process the template.
 
- This class should be used direcly only when you need to compile
+ This class should be used directly only when you need to compile
 a template from a string. If your template is in a file, then you
 should use the TemplateManager class which provides
 a higher level interface to this class and also can save the
@@ -979,10 +973,10 @@
 
 @param file Filename of the template.
 See the prepare() method of the TemplateManager
- class for exaplanation of this parameter.
+ class for explanation of this parameter.
 """
 
- self.DEB("COMPILING FROM FILE: " + file)
+ self._debug and DEB("COMPILING FROM FILE: " + file)
 self._include_path = os.path.join(os.path.dirname(file), INCLUDE_DIR)
 tokens = self.parse(self.read(file))
 compile_params = (self._include, self._max_include, self._comments,
@@ -1004,7 +998,7 @@
 
 @param data String containing the template data. 
 """
- self.DEB("COMPILING FROM STRING")
+ self._debug and DEB("COMPILING FROM STRING")
 self._include = 0
 tokens = self.parse(data)
 compile_params = (self._include, self._max_include, self._comments,
@@ -1015,19 +1009,13 @@
 ##############################################
 # PRIVATE METHODS #
 ##############################################
- 
- def DEB(self, str):
- """ Print debugging message to stderr if debugging is enabled.
- @hidden
- """
- if self._debug: print >> sys.stderr, str
 
 def read(self, filename):
 """ Read content of file and return it. Raise an error if a problem
 occurs.
 @hidden
 """
- self.DEB("READING: " + filename)
+ self._debug and DEB("READING: " + filename)
 try:
 f = None
 try:
@@ -1049,11 +1037,11 @@
 @hidden
 """
 if self._comments:
- self.DEB("PREPROCESS: COMMENTS")
+ self._debug and DEB("PREPROCESS: COMMENTS")
 template_data = self.remove_comments(template_data)
 tokens = self.tokenize(template_data)
 if self._include:
- self.DEB("PREPROCESS: INCLUDES")
+ self._debug and DEB("PREPROCESS: INCLUDES")
 self.include_templates(tokens)
 return tokens
 
@@ -1092,7 +1080,7 @@
 # Do not include the template.
 # Protection against infinite recursive includes.
 skip_params = 1
- self.DEB("INCLUDE: LIMIT REACHED: " + filename)
+ self._debug and DEB("INCLUDE: LIMIT REACHED: " + filename)
 else:
 # Include the template.
 skip_params = 0
@@ -1106,7 +1094,7 @@
 # token and its parameters.
 tokens[i:i+PARAMS_NUMBER+1] = include_tokens
 i = i + len(include_tokens)
- self.DEB("INCLUDED: " + filename)
+ self._debug and DEB("INCLUDED: " + filename)
 continue # Do not increment 'i' below.
 i += 1
 # end of the main while loop
@@ -1122,7 +1110,7 @@
 
 @hidden
 """
- self.DEB("TOKENIZING TEMPLATE")
+ self._debug and DEB("TOKENIZING TEMPLATE")
 # NOTE: The TWO double quotes in character class in the regexp below
 # are there only to prevent confusion of syntax highlighter in Emacs.
 pattern = r"""
@@ -1152,7 +1140,7 @@
 else:
 # "Normal" template data.
 if self._gettext:
- self.DEB("PARSING GETTEXT STRINGS")
+ self._debug and DEB("PARSING GETTEXT STRINGS")
 self.gettext_tokens(tokens, statement)
 else:
 tokens.append(statement)
@@ -1226,7 +1214,7 @@
 """ Append a gettext token and gettext string to the tokens array.
 @hidden
 """
- self.DEB("GETTEXT PARSER: TOKEN: " + str)
+ self._debug and DEB("GETTEXT PARSER: TOKEN: " + str)
 tokens.append("<TMPL_GETTEXT")
 tokens.append(str)
 tokens.append(None)
@@ -1234,7 +1222,7 @@
 
 def strip_brackets(self, statement):
 """ Strip HTML brackets (with optional HTML comments) from the
- beggining and from the end of a statement.
+ beginning and from the end of a statement.
 @hidden
 """
 if statement.startswith("<!-- TMPL_") or \
@@ -1249,12 +1237,12 @@
 """
 directive = params[0]
 del params[0]
- self.DEB("TOKENIZER: DIRECTIVE: " + directive)
+ self._debug and DEB("TOKENIZER: DIRECTIVE: " + directive)
 return "<" + directive
 
 def find_name(self, params):
 """ Extract identifier from a statement. The identifier can be
- specified both implicitely or explicitely as a 'NAME' parameter.
+ specified both implicitly or explicitly as a 'NAME' parameter.
 @hidden
 """
 if len(params) > 0 and '=' not in params[0]:
@@ -1264,7 +1252,7 @@
 else:
 # explicit identifier as a 'NAME' parameter
 name = self.find_param("NAME", params)
- self.DEB("TOKENIZER: NAME: " + str(name))
+ self._debug and DEB("TOKENIZER: NAME: " + str(name))
 return name
 
 def find_param(self, param, params):
@@ -1282,10 +1270,12 @@
 else:
 # The value is without double quotes.
 ret_value = value
- self.DEB("TOKENIZER: PARAM: '%s' => '%s'" % (param, ret_value))
+ self._debug and DEB("TOKENIZER: PARAM: '%s' => '%s'"\
+ % (param, ret_value))
 return ret_value
 else:
- self.DEB("TOKENIZER: PARAM: '%s' => NOT DEFINED" % param)
+ self._debug and DEB("TOKENIZER: PARAM: '%s' => NOT DEFINED"\
+ % param)
 return None
 
 
@@ -1322,16 +1312,16 @@
 self._include_mtimes = {}
 
 if not file:
- self.DEB("TEMPLATE WAS COMPILED FROM A STRING")
+ self._debug and DEB("TEMPLATE WAS COMPILED FROM A STRING")
 return
 
- # Save modifitcation time of the main template file. 
+ # Save modification time of the main template file. 
 if os.path.isfile(file):
 self._mtime = os.path.getmtime(file)
 else:
 raise TemplateError, "Template: file does not exist: '%s'" % file
 
- # Save modificaton times of all included template files.
+ # Save modification times of all included template files.
 for inc_file in include_files:
 if os.path.isfile(inc_file):
 self._include_mtimes[inc_file] = os.path.getmtime(inc_file)
@@ -1339,7 +1329,7 @@
 raise TemplateError, "Template: file does not exist: '%s'"\
 % inc_file
 
- self.DEB("NEW TEMPLATE CREATED")
+ self._debug and DEB("NEW TEMPLATE CREATED")
 
 def is_uptodate(self, compile_params=None):
 """ Check whether the compiled template is uptodate.
@@ -1359,15 +1349,15 @@
 internal use by the TemplateManager.
 """
 if not self._file:
- self.DEB("TEMPLATE COMPILED FROM A STRING")
+ self._debug and DEB("TEMPLATE COMPILED FROM A STRING")
 return 0
 
 if self._version != __version__:
- self.DEB("TEMPLATE: VERSION NOT UPTODATE")
+ self._debug and DEB("TEMPLATE: VERSION NOT UPTODATE")
 return 0
 
 if compile_params != None and compile_params != self._compile_params:
- self.DEB("TEMPLATE: DIFFERENT COMPILATION PARAMS")
+ self._debug and DEB("TEMPLATE: DIFFERENT COMPILATION PARAMS")
 return 0
 
 # Check modification times of the main template and all included
@@ -1377,7 +1367,7 @@
 # Main template file.
 if not (os.path.isfile(self._file) and \
 self._mtime == os.path.getmtime(self._file)):
- self.DEB("TEMPLATE: NOT UPTODATE: " + self._file)
+ self._debug and DEB("TEMPLATE: NOT UPTODATE: " + self._file)
 return 0 
 
 # Included templates.
@@ -1385,10 +1375,10 @@
 if not (os.path.isfile(inc_file) and \
 self._include_mtimes[inc_file] == \
 os.path.getmtime(inc_file)):
- self.DEB("TEMPLATE: NOT UPTODATE: " + inc_file)
+ self._debug and DEB("TEMPLATE: NOT UPTODATE: " + inc_file)
 return 0
 else:
- self.DEB("TEMPLATE: UPTODATE")
+ self._debug and DEB("TEMPLATE: UPTODATE")
 return 1 
 
 def tokens(self):
@@ -1431,13 +1421,6 @@
 self.__dict__ = dict
 
 
- def DEB(self, str):
- """ Print debugging message to stderr.
- @hidden
- """
- if self._debug: print >> sys.stderr, str
-
-
 ##############################################
 # EXCEPTIONS #
 ##############################################
@@ -1452,7 +1435,7 @@
 All potential IOError exceptions are handled by the module and are
 converted to TemplateError exceptions. That means you should catch the
 TemplateError exception if there is a possibility that for example
- the template file will not be accesssible.
+ the template file will not be accessible.
 
 The exception can be raised by constructors or by any method of any
 class.