code-b80224c1f4e3/roundup/cgi/ZTUtils/.cvsignore0000644000000000000000000000001411057455652017464 0ustar 00000000000000*.pyc *.pyo code-b80224c1f4e3/roundup/cgi/ZTUtils/Batch.py0000644000000000000000000000773311057455652017076 0ustar 00000000000000############################################################################## # # Copyright (c) 2001 Zope Corporation and Contributors. All Rights Reserved. # # This software is subject to the provisions of the Zope Public License, # Version 2.0 (ZPL). A copy of the ZPL should accompany this distribution. # THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED # WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED # WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS # FOR A PARTICULAR PURPOSE # ############################################################################## __doc__='''Batch class, for iterating over a sequence in batches $Id: Batch.py,v 1.3 2004-02-11 23:55:09 richard Exp $''' __docformat__ = 'restructuredtext' __version__='$Revision: 1.3 $'[11:-2] class LazyPrevBatch: def __of__(self, parent): return Batch(parent._sequence, parent._size, parent.first - parent._size + parent.overlap, 0, parent.orphan, parent.overlap) class LazyNextBatch: def __of__(self, parent): try: parent._sequence[parent.end] except IndexError: return None return Batch(parent._sequence, parent._size, parent.end - parent.overlap, 0, parent.orphan, parent.overlap) class LazySequenceLength: def __of__(self, parent): parent.sequence_length = l = len(parent._sequence) return l class Batch: """Create a sequence batch""" __allow_access_to_unprotected_subobjects__ = 1 previous = LazyPrevBatch() next = LazyNextBatch() sequence_length = LazySequenceLength() def __init__(self, sequence, size, start=0, end=0, orphan=0, overlap=0): '''Encapsulate "sequence" in batches of "size". Arguments: "start" and "end" are 0-based indexes into the sequence. If the next batch would contain no more than "orphan" elements, it is combined with the current batch. "overlap" is the number of elements shared by adjacent batches. If "size" is not specified, it is computed from "start" and "end". Failing that, it is 7. Attributes: Note that the "start" attribute, unlike the argument, is a 1-based index (I know, lame). "first" is the 0-based index. "length" is the actual number of elements in the batch. "sequence_length" is the length of the original, unbatched, sequence ''' start = start + 1 start,end,sz = opt(start,end,size,orphan,sequence) self._sequence = sequence self.size = sz self._size = size self.start = start self.end = end self.orphan = orphan self.overlap = overlap self.first = max(start - 1, 0) self.length = self.end - self.first if self.first == 0: self.previous = None def __getitem__(self, index): if index < 0: if index + self.end < self.first: raise IndexError, index return self._sequence[index + self.end] if index >= self.length: raise IndexError, index return self._sequence[index + self.first] def __len__(self): return self.length def opt(start,end,size,orphan,sequence): if size < 1: if start > 0 and end > 0 and end >= start: size=end+1-start else: size=7 if start > 0: try: sequence[start-1] except IndexError: start=len(sequence) if end > 0: if end < start: end=start else: end=start+size-1 try: sequence[end+orphan-1] except IndexError: end=len(sequence) elif end > 0: try: sequence[end-1] except IndexError: end=len(sequence) start=end+1-size if start - 1 < orphan: start=1 else: start=1 end=start+size-1 try: sequence[end+orphan-1] except IndexError: end=len(sequence) return start,end,size code-b80224c1f4e3/roundup/cgi/ZTUtils/Iterator.py0000644000000000000000000001235611057455652017643 0ustar 00000000000000############################################################################## # # Copyright (c) 2001 Zope Corporation and Contributors. All Rights Reserved. # # This software is subject to the provisions of the Zope Public License, # Version 2.0 (ZPL). A copy of the ZPL should accompany this distribution. # THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED # WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED # WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS # FOR A PARTICULAR PURPOSE # ############################################################################## __doc__='''Iterator class Unlike the builtin iterators of Python 2.2+, these classes are designed to maintain information about the state of an iteration. The Iterator() function accepts either a sequence or a Python iterator. The next() method fetches the next item, and returns true if it succeeds. $Id: Iterator.py,v 1.4 2005-02-16 22:07:33 richard Exp $''' __docformat__ = 'restructuredtext' __version__='$Revision: 1.4 $'[11:-2] import string class Iterator: '''Simple Iterator class''' __allow_access_to_unprotected_subobjects__ = 1 nextIndex = 0 def __init__(self, seq): self.seq = iter(seq) # force seq to be an iterator self._inner = iterInner self._prep_next = iterInner.prep_next def __getattr__(self, name): try: inner = getattr(self._inner, 'it_' + name) except AttributeError: raise AttributeError, name return inner(self) def next(self): if not (hasattr(self, '_next') or self._prep_next(self)): return 0 self.index = i = self.nextIndex self.nextIndex = i+1 self._advance(self) return 1 def _advance(self, it): self.item = self._next del self._next del self.end self._advance = self._inner.advance self.start = 1 def number(self): return self.nextIndex def even(self): return not self.index % 2 def odd(self): return self.index % 2 def letter(self, base=ord('a'), radix=26): index = self.index s = '' while 1: index, off = divmod(index, radix) s = chr(base + off) + s if not index: return s def Letter(self): return self.letter(base=ord('A')) def Roman(self, rnvalues=( (1000,'M'),(900,'CM'),(500,'D'),(400,'CD'), (100,'C'),(90,'XC'),(50,'L'),(40,'XL'), (10,'X'),(9,'IX'),(5,'V'),(4,'IV'),(1,'I')) ): n = self.index + 1 s = '' for v, r in rnvalues: rct, n = divmod(n, v) s = s + r * rct return s def roman(self, lower=string.lower): return lower(self.Roman()) def first(self, name=None): if self.start: return 1 return not self.same_part(name, self._last, self.item) def last(self, name=None): if self.end: return 1 return not self.same_part(name, self.item, self._next) def same_part(self, name, ob1, ob2): if name is None: return ob1 == ob2 no = [] return getattr(ob1, name, no) == getattr(ob2, name, no) is not no def __iter__(self): return IterIter(self) class InnerBase: '''Base Inner class for Iterators''' # Prep sets up ._next and .end def prep_next(self, it): it.next = self.no_next it.end = 1 return 0 # Advance knocks them down def advance(self, it): it._last = it.item it.item = it._next del it._next del it.end it.start = 0 def no_next(self, it): return 0 def it_end(self, it): if hasattr(it, '_next'): return 0 return not self.prep_next(it) class SeqInner(InnerBase): '''Inner class for sequence Iterators''' def _supports(self, ob): try: ob[0] except (TypeError, AttributeError): return 0 except: pass return 1 def prep_next(self, it): i = it.nextIndex try: it._next = it.seq[i] except IndexError: it._prep_next = self.no_next it.end = 1 return 0 it.end = 0 return 1 def it_length(self, it): it.length = l = len(it.seq) return l try: StopIteration=StopIteration except NameError: StopIteration="StopIteration" class IterInner(InnerBase): '''Iterator inner class for Python iterators''' def _supports(self, ob): try: if hasattr(ob, 'next') and (ob is iter(ob)): return 1 except: return 0 def prep_next(self, it): try: it._next = it.seq.next() except StopIteration: it._prep_next = self.no_next it.end = 1 return 0 it.end = 0 return 1 class IterIter: def __init__(self, it): self.it = it self.skip = it.nextIndex > 0 and not it.end def next(self): it = self.it if self.skip: self.skip = 0 return it.item if it.next(): return it.item raise StopIteration seqInner = SeqInner() iterInner = IterInner() code-b80224c1f4e3/roundup/cgi/ZTUtils/__init__.py0000644000000000000000000000166311057455652017610 0ustar 00000000000000############################################################################## # # Copyright (c) 2001 Zope Corporation and Contributors. All Rights Reserved. # # This software is subject to the provisions of the Zope Public License, # Version 2.0 (ZPL). A copy of the ZPL should accompany this distribution. # THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED # WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED # WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS # FOR A PARTICULAR PURPOSE # ############################################################################## __doc__='''Package of template utility classes and functions. Modified for Roundup 0.5 release: - removed Zope imports $Id: __init__.py,v 1.3 2004-02-11 23:55:09 richard Exp $''' __docformat__ = 'restructuredtext' __version__='$Revision: 1.3 $'[11:-2] from Batch import Batch from Iterator import Iterator