golden hour

/lib64/python2.7/site-packages/sepolgen

File/Folder	Size	Actions
__init__.py	0 B
__init__.pyc	142 B
__init__.pyo	142 B
access.py	12.33 KB
access.pyc	13.18 KB
access.pyo	13.18 KB
audit.py	23.64 KB
audit.pyc	22.33 KB
audit.pyo	22.33 KB
classperms.py	2.75 KB
classperms.pyc	3.16 KB
classperms.pyo	3.16 KB
defaults.py	2.69 KB
defaults.pyc	2.87 KB
defaults.pyo	2.87 KB
interfaces.py	16.21 KB
interfaces.pyc	15.86 KB
interfaces.pyo	15.86 KB
lex.py	32.86 KB
lex.pyc	19.24 KB
lex.pyo	19.24 KB
matching.py	8.45 KB
matching.pyc	7.4 KB
matching.pyo	7.4 KB
module.py	7.12 KB
module.pyc	8.4 KB
module.pyo	8.4 KB
objectmodel.py	6.37 KB
objectmodel.pyc	4.64 KB
objectmodel.pyo	4.64 KB
output.py	5.01 KB
output.pyc	4.51 KB
output.pyo	4.51 KB
policygen.py	16.31 KB
policygen.pyc	15.25 KB
policygen.pyo	15.18 KB
refparser.py	30.2 KB
refparser.pyc	36.27 KB
refparser.pyo	36.27 KB
refpolicy.py	27.31 KB
refpolicy.pyc	46.45 KB
refpolicy.pyo	46.45 KB
sepolgeni18n.py	912 B
sepolgeni18n.pyc	410 B
sepolgeni18n.pyo	410 B
util.py	5.41 KB
util.pyc	7.87 KB
util.pyo	7.87 KB
yacc.py	80.04 KB
yacc.pyc	41.4 KB
yacc.pyo	41.4 KB

Edit: util.py

# Authors: Karl MacMillan <kmacmillan@mentalrootkit.com>
#
# Copyright (C) 2006 Red Hat 
# see file 'COPYING' for use and warranty information
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License as
# published by the Free Software Foundation; version 2 only
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#
import locale
import sys

PY3 = sys.version_info[0] == 3

if PY3:
    bytes_type=bytes
    string_type=str
else:
    bytes_type=str
    string_type=unicode

class ConsoleProgressBar:
    def __init__(self, out, steps=100, indicator='#'):
        self.blocks = 0
        self.current = 0
        self.steps = steps
        self.indicator = indicator
        self.out = out
        self.done = False

def start(self, message=None):
        self.done = False
        if message:
            self.out.write('\n%s:\n' % message)
        self.out.write('%--10---20---30---40---50---60---70---80---90--100\n')

def step(self, n=1):
        self.current += n

old = self.blocks
        self.blocks = int(round(self.current / float(self.steps) * 100) / 2)

if self.blocks > 50:
            self.blocks = 50

new = self.blocks - old

self.out.write(self.indicator * new)
        self.out.flush()

if self.blocks == 50 and not self.done:
            self.done = True
            self.out.write("\n")

def set_to_list(s):
    l = []
    l.extend(s)
    return l

def first(s, sorted=False):
    """
    Return the first element of a set.

It sometimes useful to return the first element from a set but,
    because sets are not indexable, this is rather hard. This function
    will return the first element from a set. If sorted is True, then
    the set will first be sorted (making this an expensive operation).
    Otherwise a random element will be returned (as sets are not ordered).
    """
    if not len(s):
        raise IndexError("empty containter")
    
    if sorted:
        l = set_to_list(s)
        l.sort()
        return l[0]
    else:
        for x in s:
            return x

def encode_input(text):
    import locale
    """Encode given text via preferred system encoding"""
    # locale will often find out the correct encoding
    encoding = locale.getpreferredencoding()
    try:
        encoded_text = text.encode(encoding)
    except UnicodeError:
    # if it fails to find correct encoding then ascii is used
    # which may lead to UnicodeError if `text` contains non ascii signs
    # utf-8 is our guess to fix the situation
        encoded_text = text.encode('utf-8')
    return encoded_text

def decode_input(text):
    import locale
    """Decode given text via preferred system encoding"""
    # locale will often find out the correct encoding
    encoding = locale.getpreferredencoding()
    try:
        decoded_text = text.decode(encoding)
    except UnicodeError:
    # if it fails to find correct encoding then ascii is used
    # which may lead to UnicodeError if `text` contains non ascii signs
    # utf-8 is our guess to fix the situation
        decoded_text = text.decode('utf-8')
    return decoded_text

class Comparison():
    """Class used when implementing rich comparison.

Inherit from this class if you want to have a rich
    comparison withing the class, afterwards implement
    _compare function within your class."""

def _compare(self, other, method):
        raise NotImplemented

def __eq__(self, other):
        return self._compare(other, lambda a, b: a == b)

def __lt__(self, other):
        return self._compare(other, lambda a, b: a < b)

def __le__(self, other):
        return self._compare(other, lambda a, b: a <= b)

def __ge__(self, other):
        return self._compare(other, lambda a, b: a >= b)

def __gt__(self, other):
        return self._compare(other, lambda a, b: a > b)

def __ne__(self, other):
        return self._compare(other, lambda a, b: a != b)

if sys.version_info < (2,7):
    # cmp_to_key function is missing in python2.6
    def cmp_to_key(mycmp):
        'Convert a cmp= function into a key= function'
        class K:
            def __init__(self, obj, *args):
                self.obj = obj
            def __lt__(self, other):
                return mycmp(self.obj, other.obj) < 0
            def __gt__(self, other):
                return mycmp(self.obj, other.obj) > 0
            def __eq__(self, other):
                return mycmp(self.obj, other.obj) == 0
            def __le__(self, other):
                return mycmp(self.obj, other.obj) <= 0
            def __ge__(self, other):
                return mycmp(self.obj, other.obj) >= 0
            def __ne__(self, other):
                return mycmp(self.obj, other.obj) != 0
        return K
else:
    from functools import cmp_to_key

def cmp(first, second):
    return (first > second) - (second > first)

if __name__ == "__main__":
    import sys
    import time
    p = ConsoleProgressBar(sys.stdout, steps=999)
    p.start("computing pi")
    for i in range(999):
        p.step()
        time.sleep(0.001)