Paratessares Time (Python recipe) by Stephen Chappell

ActiveState Code (http://code.activestate.com/recipes/576636/)

#==============================================================================#
#  paratime.py                                                                 #
#==============================================================================#

"""Module for paratessares time conversions.

This module provides several functions that
covert earth seconds into paratessares time."""

################################################################################

__version__ = "$Revision: 3 $"
__date__ = "14 January 2009"
__author__ = "Stephen Chappell <Noctis.Skytower@gmail.com>"
__credits__ = """\
S. Schaub, for teaching me about interpreted languages.
D. Wooster, for teaching me about simulations and C#.
B. Gates, for allowing timers to be included with C#."""

################################################################################

import time as _time
import _thread
import sys as _sys

################################################################################

EPOCH_DELTA = 946684800
MICREV_IN_DAY = 1000000
MILREV_IN_DAY = 1000

SECOND_IN_DAY = 86400
DAY_IN_WEEK = 7
WEEK_IN_MONTH = 4
MONTH_IN_SEASON = 3
SEASON_IN_YEAR = 4

SECOND_IN_WEEK = SECOND_IN_DAY * DAY_IN_WEEK
SECOND_IN_MONTH = SECOND_IN_WEEK * WEEK_IN_MONTH
SECOND_IN_SEASON = SECOND_IN_MONTH * MONTH_IN_SEASON
SECOND_IN_YEAR = SECOND_IN_SEASON * SEASON_IN_YEAR

################################################################################

def seconds():
    "Return seconds since the epoch."
    return _time.time() - EPOCH_DELTA

def micrev(seconds):
    "Convert from seconds to micrev."
    x = seconds % SECOND_IN_DAY * MICREV_IN_DAY / SECOND_IN_DAY % MILREV_IN_DAY
    return int(x)

def milrev(seconds):
    "Convert from seconds to milrev."
    x = seconds % SECOND_IN_DAY * MILREV_IN_DAY / SECOND_IN_DAY
    return int(x)

def day(seconds):
    "Convert from seconds to days."
    x = seconds / SECOND_IN_DAY % DAY_IN_WEEK
    return int(x)

def week(seconds):
    "Convert from seconds to weeks."
    x = seconds / SECOND_IN_WEEK % WEEK_IN_MONTH
    return int(x)

def month(seconds):
    "Convert from seconds to months."
    x = seconds / SECOND_IN_MONTH % MONTH_IN_SEASON
    return int(x)

def season(seconds):
    "Convert from seconds to seasons."
    x = seconds / SECOND_IN_SEASON % SEASON_IN_YEAR
    return int(x)

def year(seconds):
    "Convert from seconds to years."
    x = seconds / SECOND_IN_YEAR
    return int(x)
    
################################################################################

UNITS = year, season, month, week, day, milrev, micrev

def text(seconds, spec='{0}.{1}.{2}.{3}.{4}.{5:03}.{6:03}', unit=UNITS):
    "Convert from seconds to text."
    return spec.format(*[func(seconds) for func in unit])

################################################################################

class Micrev_Timer:

    "Micrev_Timer(function, *args, **kwargs) -> Micrev_Timer"

    def __init__(self, function, *args, **kwargs):
        "Initialize the Micrev_Timer object."
        self.__function = function
        self.__args = args
        self.__kwargs = kwargs
        self.__thread = False
        self.__lock = _thread.allocate_lock()

    def start(self):
        "Start the Micrev_Timer object."
        with self.__lock:
            self.__active = True
            if not self.__thread:
                self.__thread = True
                _thread.start_new_thread(self.__run, ())

    def stop(self):
        "Stop the Micrev_Timer object."
        with self.__lock:
            self.__active = False

    def __run(self):
        "Private class method."
        start = _time.clock()
        timer = 0
        while True:
            timer += 1
            sleep = start + timer * 0.0864 - _time.clock()
            assert sleep >= 0, 'Function Was Too Slow'
            _time.sleep(sleep)
            with self.__lock:
                if not self.__active:
                    self.__thread = False
                    break
            self.__function(*self.__args, **self.__kwargs)

################################################################################

class Quantum_Timer:

    "Quantum_Timer(function, *args, **kwargs) -> Quantum_Timer"

    def __init__(self, function, *args, **kwargs):
        "Initialize the Quantum_Timer object."
        self.__function = function
        self.__args = args
        self.__kwargs = kwargs
        self.__thread = False
        self.__lock = _thread.allocate_lock()

    def start(self):
        "Start the Quantum_Timer object."
        with self.__lock:
            self.__active = True
            if not self.__thread:
                self.__thread = True
                _thread.start_new_thread(self.__run, ())

    def stop(self):
        "Stop the Quantum_Timer object."
        with self.__lock:
            self.__active = False

    def __run(self):
        "Private class method."
        while True:
            time = _time.clock()
            plus = time + 0.0864
            over = plus % 0.0864
            diff = plus - time - over
            _time.sleep(diff)
            with self.__lock:
                if not self.__active:
                    self.__thread = False
                    break
            self.__function(*self.__args, **self.__kwargs)

################################################################################

if __name__ == '__main__':
    _sys.stdout.write('Content-Type: text/plain\n\n')
    _sys.stdout.write(open(_sys.argv[0]).read())

#==============================================================================#
#  test_paratime.py                                                            #
#==============================================================================#

import paratime
import time
import datetime
import inspect
import unittest
from test import support

class ConstantTest(unittest.TestCase):

    def test_existance(self):
        # See if all required constants exist and do not equal zero.
        constants = ['EPOCH_DELTA', 'MICREV_IN_DAY', 'MILREV_IN_DAY',
                     'SECOND_IN_DAY', 'DAY_IN_WEEK', 'WEEK_IN_MONTH',
                     'MONTH_IN_SEASON', 'SEASON_IN_YEAR', 'SECOND_IN_WEEK',
                     'SECOND_IN_MONTH', 'SECOND_IN_SEASON', 'SECOND_IN_YEAR']
        for name in constants:
            self.assert_(hasattr(paratime, name), 'AttributeError: ' + name)
            CONSTANT = getattr(paratime, name)
            self.assert_(isinstance(CONSTANT, int), 'TypeError: ' + name)
            self.assert_(CONSTANT != 0, 'ValueError: ' + name)

    def test_epoch(self):
        # Ensure that EPOCH_DELTA is correct for this system.
        delta = paratime.EPOCH_DELTA
        epoch = time.gmtime(0)[:3]
        edate = datetime.date(*epoch)
        pdate = datetime.date(2000, 1, 1)
        days = (pdate - edate).days
        seconds = days * 24 * 60 * 60
        self.assert_(delta == seconds, 'ValueError: EPOCH_DELTA')

    def test_division(self):
        # Check that the daily divisions have not changed.
        micrev = paratime.MICREV_IN_DAY
        milrev = paratime.MILREV_IN_DAY
        second = paratime.SECOND_IN_DAY
        self.assert_(micrev == 10 ** 6, 'ValueError: MICREV_IN_DAY')
        self.assert_(milrev == 10 ** 3, 'ValueError: MILREV_IN_DAY')
        self.assert_(second == 24 * 60 * 60, 'ValueError: SECOND_IN_DAY')

    def test_year(self):
        # Use various checksums to verify the design of a year.
        d = paratime.DAY_IN_WEEK
        w = paratime.WEEK_IN_MONTH
        m = paratime.MONTH_IN_SEASON
        s = paratime.SEASON_IN_YEAR
        self.assert_(d ^ w ^ m ^ s == 4, 'ValueError: XOR')
        self.assert_(d + w + m + s == 18, 'ValueError: Addition')
        self.assert_(d * w * m * s == 336, 'ValueError: Multiplication')
        self.assert_(hash((d, w, m, s)) == 1672362005, 'ValueError: Hash')

    def test_second(self):
        # Test that the dynmaic constants were created correctly.
        week = paratime.SECOND_IN_WEEK
        month = paratime.SECOND_IN_MONTH
        season = paratime.SECOND_IN_SEASON
        year = paratime.SECOND_IN_YEAR
        self.assert_(week == 604800, 'ValueError: SECOND_IN_WEEK')
        self.assert_(month == 2419200, 'ValueError: SECOND_IN_MONTH')
        self.assert_(season == 7257600, 'ValueError: SECOND_IN_SEASON')
        self.assert_(year == 29030400, 'ValueError: SECOND_IN_YEAR')

    def test_unit(self):
        # Examine the constant UNITS for proper compostion.
        functions = ['year', 'season', 'month', 'week', 'day',
                     'milrev', 'micrev']
        self.assert_(hasattr(paratime, 'UNITS'), 'AttributeError: UNITS')
        istuple = isinstance(getattr(paratime, 'UNITS'), tuple)
        self.assert_(istuple, 'TypeError: UNITS')
        units = tuple(getattr(paratime, name) for name in functions)
        self.assert_(paratime.UNITS == units, 'ValueError: UNITS')

class FunctionTest(unittest.TestCase):

    def test_existance(self):
        # Make sure that all required functions exist.
        functions = ['seconds', 'micrev', 'milrev',
                     'day', 'week', 'month', 'season', 'year',
                     'text']
        for name in functions:
            self.assert_(hasattr(paratime, name), 'AttributeError: ' + name)
            isfunction = inspect.isfunction(getattr(paratime, name))
            self.assert_(isfunction, 'TypeError: ' + name)

    def test_zero(self):
        # Test that argument 0.0 always returns 0.0 from functions.
        functions = ['micrev', 'milrev',
                     'day', 'week', 'month', 'season', 'year']
        for name in functions:
            func = getattr(paratime, name)
            self.assert_(func(0.0) == 0.0, 'ArithmeticError: ' + name)

    def test_year(self):
        # Find out if proper mathamatical divisions exist in a year.
        functions = ['day', 'week', 'month', 'season']
        for name in functions:
            func = getattr(paratime, name)
            constant = 'SECOND_IN_' + name.upper()
            CONSTANT = getattr(paratime, constant)
            self.assert_(func(CONSTANT) == 1, 'ArithmeticError: ' + name)
            self.assert_(func(CONSTANT - 1) == 0, 'ArithmeticError: ' + name)

    def test_rev(self):
        # Check that partioning of the day is computed correctly.
        micrev = paratime.micrev
        milrev = paratime.milrev
        test_mic = lambda s: int(s * 1000000 / 86400 % 1000)
        test_mil = lambda s: int(s * 1000 / 86400 % 1000)
        for s in range(int(24 * 60 * 60 * 1.01)):
            self.assert_(micrev(s) == test_mic(s), 'ArithmeticError: micrev')
            self.assert_(milrev(s) == test_mil(s), 'ArithmeticError: milrev')

class TextTest(unittest.TestCase):

    def setUp(self):
        # Create some variables to help with the upcoming tests.
        self.T = paratime.text
        self.S = [10344926.962133339, 94639768.804546028, 265532741.01112196,
                  16253695.553989811, 108469967.14143418, 268212543.20094055,
                  56911478.644419812, 135376331.24554729, 300908237.98332906,
                  63510559.911042809, 137084486.30913293, 373636131.91095936,
                  72101267.095945552, 140265693.15057722, 380887195.47359467,
                  78426890.295372367, 146538409.07728666, 404198696.61584091,
                  83581780.421440393, 197104443.98377159, 405806804.27733558,
                  85208640.256408677, 217453332.36529338, 410940507.48093152,
                  88576536.868952677, 232335476.22987685, 411771351.90179437,
                  90854227.747951403, 263271517.23457572, 412037865.73197347]

    def test_seconds(self):
        # Ensure that the default settings work properly.
        keys = ['0.1.1.1.0.732.950', '3.1.0.0.3.367.694', '9.0.1.3.0.295.613',
                '0.2.0.2.6.121.476', '3.2.2.3.2.439.434', '9.0.2.3.3.311.842',
                '1.3.2.2.0.697.669', '4.2.1.3.5.855.685', '10.1.1.1.3.734.235',
                '2.0.2.1.0.075.924', '4.2.2.2.4.625.998', '12.3.1.1.5.492.267',
                '2.1.2.3.1.505.406', '4.3.0.3.6.445.522', '13.0.1.1.5.416.614',
                '2.2.2.1.4.718.637', '5.0.0.2.2.046.401', '13.3.2.0.2.225.655',
                '2.3.1.2.1.381.717', '6.3.0.1.6.301.434', '13.3.2.2.6.838.012',
                '2.3.2.0.6.211.114', '7.1.2.3.3.820.976', '14.0.1.3.3.255.873',
                '3.0.0.2.3.191.398', '8.0.0.0.1.068.011', '14.0.2.0.5.872.128',
                '3.0.1.2.1.553.561', '9.0.0.3.2.124.042', '14.0.2.1.1.956.779']
        for seconds, results in zip(self.S, keys):
            self.assert_(self.T(seconds) == results, 'ValueError: Default')

    def test_spec(self):
        # Check that various format specifications do not cause errors.
        form = ['Year = {0}', 'Season = {1}', 'Month = {2}', 'Week = {3}',
                'Day = {4}', 'Milrev = {5:03}', 'Micrev = {6:03}',
                'Season {1} of Year {0}', 'Month {2} of Season {1}',
                'Week {3} of Month {2}', 'Day {4} of Week {3}',
                'The time is {5}:{6}.', 'This is year {0}.']
        keys = ['0 1 1 1 0 732 950 10 11 11 01 732:950 0',
                '3 1 0 0 3 367 694 13 01 00 30 367:694 3',
                '9 0 1 3 0 295 613 09 10 31 03 295:613 9',
                '0 2 0 2 6 121 476 20 02 20 62 121:476 0',
                '3 2 2 3 2 439 434 23 22 32 23 439:434 3',
                '9 0 2 3 3 311 842 09 20 32 33 311:842 9',
                '1 3 2 2 0 697 669 31 23 22 02 697:669 1',
                '4 2 1 3 5 855 685 24 12 31 53 855:685 4',
                '10 1 1 1 3 734 235 110 11 11 31 734:235 10',
                '2 0 2 1 0 075 924 02 20 12 01 75:924 2',
                '4 2 2 2 4 625 998 24 22 22 42 625:998 4',
                '12 3 1 1 5 492 267 312 13 11 51 492:267 12',
                '2 1 2 3 1 505 406 12 21 32 13 505:406 2',
                '4 3 0 3 6 445 522 34 03 30 63 445:522 4',
                '13 0 1 1 5 416 614 013 10 11 51 416:614 13',
                '2 2 2 1 4 718 637 22 22 12 41 718:637 2',
                '5 0 0 2 2 046 401 05 00 20 22 46:401 5',
                '13 3 2 0 2 225 655 313 23 02 20 225:655 13',
                '2 3 1 2 1 381 717 32 13 21 12 381:717 2',
                '6 3 0 1 6 301 434 36 03 10 61 301:434 6',
                '13 3 2 2 6 838 012 313 23 22 62 838:12 13',
                '2 3 2 0 6 211 114 32 23 02 60 211:114 2',
                '7 1 2 3 3 820 976 17 21 32 33 820:976 7',
                '14 0 1 3 3 255 873 014 10 31 33 255:873 14',
                '3 0 0 2 3 191 398 03 00 20 32 191:398 3',
                '8 0 0 0 1 068 011 08 00 00 10 68:11 8',
                '14 0 2 0 5 872 128 014 20 02 50 872:128 14',
                '3 0 1 2 1 553 561 03 10 21 12 553:561 3',
                '9 0 0 3 2 124 042 09 00 30 23 124:42 9',
                '14 0 2 1 1 956 779 014 20 12 11 956:779 14']
        table = str.maketrans('', '', ' .=DMSTWYacefhiklmnorstvy')
        clean = lambda S: S.translate(table)
        for seconds, results in zip(self.S, keys):
            for spec, result in zip(form, results.split()):
                purged = clean(self.T(seconds, spec))
                self.assert_(purged == result, 'ValueError: Format')

    def test_unit(self):
        # Try running through several custom unit combinations.
        days = lambda x: int(x / 86400)
        hours = lambda x: int(x / 3600) % 24
        minutes = lambda x: int(x / 60) % 60
        seconds = lambda x: int(x) % 60
        args = [('D{0}', [days]),
                ('H{0}', [hours]),
                ('M{0}', [minutes]),
                ('S{0}', [seconds]),
                ('{0}:{1:02}:{2:02}:{3:02}', [days, hours, minutes, seconds])]
        keys = ['119 17 35 26 119173526', '1095 8 49 28 1095084928',
                '3073 7 5 41 3073070541', '188 2 54 55 188025455',
                '1255 10 32 47 1255103247', '3104 7 29 3 3104072903',
                '658 16 44 38 658164438', '1566 20 32 11 1566203211',
                '3482 17 37 17 3482173717', '735 1 49 19 735014919',
                '1586 15 1 26 1586150126', '4324 11 48 51 4324114851',
                '834 12 7 47 834120747', '1623 10 41 33 1623104133',
                '4408 9 59 55 4408095955', '907 17 14 50 907171450',
                '1696 1 6 49 1696010649', '4678 5 24 56 4678052456',
                '967 9 9 40 967090940', '2281 7 14 3 2281071403',
                '4696 20 6 44 4696200644', '986 5 4 0 986050400',
                '2516 19 42 12 2516194212', '4756 6 8 27 4756060827',
                '1025 4 35 36 1025043536', '2689 1 37 56 2689013756',
                '4765 20 55 51 4765205551', '1051 13 17 7 1051131707',
                '3047 2 58 37 3047025837', '4768 22 57 45 4768225745']
        prefix = ['D', 'H', 'M', 'S', '']
        finish = lambda S: ':'.join((S[:-6], S[-6:-4], S[-4:-2], S[-2:]))
        for seconds, results in zip(self.S, keys):
            for unit, plus, result in zip(args, prefix, results.split()):
                ans = self.T(seconds, *unit)
                key = (plus + result) if plus else finish(result)
                self.assert_(ans == key, 'ValueError: Functions')

class TimerTest(unittest.TestCase):

    def test_fast(self):
        # Check that quick functions can be run without failing.
        MT = self.timer(self.increment, 0.0625)
        MT.start()
        time.sleep(0.5)
        MT.stop()
        time.sleep(0.25)
        self.assert_(self.fast(), 'ValueError: Count')

    def test_slow(self):
        # Verify the behavior of the timer's thread under load.
        MT = self.timer(self.increment, 0.125)
        with support.captured_output('stderr') as stderr:
            MT.start()
            time.sleep(0.5)
            MT.stop()
            time.sleep(0.25)
        self.assert_(self.slow(), 'ValueError: Count')
        self.assert_(self.test(stderr.getvalue()), 'IOError: Thread')

    def increment(self, seconds):
        # Keep track of how many times the thread runs.
        time.sleep(seconds)
        self.count += 1

class MicrevTest(TimerTest):

    def setUp(self):
        # Create variables specifically for testing Micrev_Timer.
        self.count = 0
        self.timer = paratime.Micrev_Timer
        self.fast = lambda: self.count == 5
        self.slow = lambda: self.count == 1
        self.test = lambda S: 'Function Was Too Slow' in S

class QuantumTest(TimerTest):

    def setUp(self):
        # Create variables specifically for testing Quantum_Timer.
        self.count = 0
        self.timer = paratime.Quantum_Timer
        self.fast = lambda: 5 <= self.count <= 6
        self.slow = lambda: self.count == 3
        self.test = lambda S: len(S) == 0

def test_main():
    support.run_unittest(ConstantTest,
                         FunctionTest, TextTest,
                         MicrevTest, QuantumTest)

if __name__ == '__main__':
    test_main()

#==============================================================================#
#  Clock.pyw                                                                   #
#==============================================================================#

import tkinter
import paratime

def main():
    root = tkinter.Tk()
    root.resizable(False, False)
    root.title('Time in Tessaressunago')
    time = tkinter.StringVar()
    text = tkinter.Label(textvariable=time, font=('helvetica', 16, 'bold'))
    text.grid(padx=5, pady=5)
    thread = paratime.Quantum_Timer(update, time)
    thread.start()
    root.mainloop()

def update(time):
    s = paratime.seconds()
    t = paratime.text(s)
    p = 1000000000 * 1.01 ** (s / paratime.SECOND_IN_YEAR)
    time.set('Time = {0}\nNational = {1}'.format(t, fix(p)))

def fix(number, sep=','):
    number = str(int(number))
    string = ''
    while number:
        string = number[-1] + string
        number = number[:-1]
        if number and not (len(string) + 1) % 4:
            string = sep + string
    return string

if __name__ == '__main__':
    main()

#==============================================================================#
#  BACKUP 3.0.py                                                               #
#==============================================================================#

from getpass import getuser
from paratime import seconds, text
import os

###############################################################################

GET = os.path.join('C:\\Documents and Settings', getuser(), 'My Documents')
SET = os.path.join('G:\\BACKUP', text(seconds()))

JUNK_FILE = 'Thumbs.db', 'Desktop.ini'
JUNK_EXT = 'pyc', 'pyo'

###############################################################################

def main():
    prune_junk()
    prune_dirs()
    backup_dirs(GET, SET)
    show_prompt()

def show_prompt():
    if WARNINGS:
        print('====================')
        print('Warnings Will Follow')
        input('====================')
        for warning in WARNINGS:
            print('ERROR: ', warning)
    print('==================')
    print('Backup Is Complete')
    input('==================')

###############################################################################

JUNK_FILE = [name.lower() for name in JUNK_FILE]
JUNK_EXT = ['.' + name.lower() for name in JUNK_EXT]

def prune_junk():
    for root, dirs, files in os.walk(GET):
        for name in files:
            path = name.lower()
            if path in JUNK_FILE or os.path.splitext(path)[1] in JUNK_EXT:
                path = os.path.join(root, name)
                os.remove(path)
                print('REMOVE:', path)

def prune_dirs():
    for root, dirs, files in os.walk(GET, False):
        for name in dirs:
            path = os.path.join(root, name)
            if empty(path):
                os.rmdir(path)
                print('RMDIR: ', path)

def empty(path):
    for name in os.listdir(path):
        path_name = os.path.join(path, name)
        if os.path.isdir(path_name) and not empty(path_name):
            return False
        elif os.path.isfile(path_name):
            return False
        return True

###############################################################################

WARNINGS = []

def backup_dirs(source, destination):
    contents = os.listdir(source)
    os.mkdir(destination)
    print('MKDIR: ', destination)
    for name in contents:
        source_name = os.path.join(source, name)
        destination_name = os.path.join(destination, name)
        try:
            if os.path.isdir(source_name):
                backup_dirs(source_name, destination_name)
            elif os.path.isfile(source_name):
                backup_file(source_name, destination_name)
        except:
            WARNINGS.append(source_name)

def backup_file(source, destination):
    sour = open(source, 'rb')
    dest = open(destination, 'wb')
    print('OPEN:  ', destination)
    buff = sour.read(1 << 20)
    while buff:
        dest.write(buff)
        buff = sour.read(1 << 20)
    sour.close()
    dest.close()

###############################################################################

if __name__ == '__main__':
    main()