Longest common substring

import logging
from loopstatus import loopstatus

logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s %(levelname)-8s L%(lineno)d %(message)s',
    datefmt='%H:%M:%S',
    )

def longest_common_string(A,B):
    status = loopstatus()
    try:
        L = 1
        RB = range(len(B))
        for i in range(len(A)):
            a = A[i:i+L]
            if status():
                logging.info('character %d of %d',i,len(A))
            for j in RB:
                if a == B[j:j+L]:
                    while A[i+L] == B[j+L]:
                        a += A[i+L]
                        L += 1
                        print(a,i)
    except IndexError:
        pass
    return L

'''
    import logging
    from loopstatus import loopstatus

    logging.basicConfig(
        level=logging.INFO,
        format='%(asctime)s %(levelname)-8s L%(lineno)d %(message)s',
        datefmt='%H:%M:%S',
        )

    status = loopstatus()
    ...
    if status():
        logging.info('%dnth occurence',status.Value)
'''

import signal

class loopstatus(object):

    def __init__(self,base=2,seconds=5*60,target=1):
        self.i = 0
        self.base = base
        self.target = target
        self.nonzero = True
        self.timesup = False
        self.interval = seconds
        if 0 < seconds:
            self.reset_timer()
            signal.signal(signal.SIGALRM,self.trap_alarm)

    def trap_alarm(self,*args,**kwargs):
        self.timesup = True

    def reset_timer(self,interval=None):
        if interval is None:
            interval = self.interval
        if 0 < interval:
            self.timesup = False
            signal.alarm(interval)

    def __call__(self):
        self.i += 1
        self.nonzero = self.timesup or (self.target <= self.i)
        if self:
            self.target *= self.base
            self.reset_timer()
        return self.nonzero

    @property
    def Value(self):
        return self.i

    def __bool__(self):
        return self.nonzero

    def __str__(self):
        return str(self.Value)

    def __lt__(self,other): return self.Value < other
    def __le__(self,other): return self.Value <= other
    def __eq__(self,other): return self.Value == other
    def __ne__(self,other): return self.Value != other
    def __ge__(self,other): return self.Value >= other
    def __gt__(self,other): return self.Value > other


def main(base=2,seconds=5*60,target=1):
    return loopstatus(base,seconds,target)


'''
I'd include loopstatustest.py, except that I'd also have to post my testing framework.  tests are important.  Here is an annotated sample use case terminated by keyboard interrupt:

    >>> import loopstatus
    >>> status = loopstatus.loopstatus(seconds=4)
    >>> while True:
    ...     if status():
    ...         print(s.Value)
    ...
    1
    2
    4
    8
    16
    32
    64
    128
    256
    512
    1024
    2048
    4096
    8192
    16384
    32768
    65536
    131072
    262144
    524288
    1048576
    2097152
    3592136       # the 4 second timer caused this event
    5106735
    6616367
    8126450
    ^C
    Traceback (most recent call last):
      file "<stdin>", line 2, in <module>
      file "ls.py", line 44, in __call__
        if self.timesup or (self.target <= self.i):
    KeyboardInterrupt
    >>>

**CONTROL**

To closer pack the geometric sequence---set *base* to a float between 1 and 2.

For decade counting---set *base* to 10.  I don't understand the fuss regardinging the usual number of fingers, hence the binary default.

For more frequent initial true tests---set *target* between 0 and 1

    0 < target < 1

To always report True---set base to 1.

To test true less often initially---increase *target*.

To disable truth by time---choose 0 for *seconds*.  The default is 5*60 seconds == 5 minutes.

To disable truth by count---use a large value of *target*.


**METHODS**

Call the loopstatus object to increment its count, set the object's truth, and manage internals.  It returns its truth value.

loopstatus defines __nonzero__ which does not alter the object's truth.

LSObject.Value returns the LSObject() call count.

sample:

    from WriteNumber import WriteNumber
    unfinished = True
    status = loopstatus.loopstatus()

    while unfinished:

        if status():                    # Call updates truth state
            info('measure %s.',WriteNumber(status.Value)) # progress

        unfinished = symphony(
            verbose = not not status)   # safely use boolean state
'''

## do not print any extra messages during an actual run 
# because printing is slow comparatively.

def one_group(length, str_in):
    """ divide the string into sub-groups of the length passed 
          and return a set
    """
    str_in = str_in.lower()
    return_set = set()
    start = 0
    end = length
    print end
    while end <= len(str_in):
        this_group=str_in[start:end]
        return_set.add(this_group)
        print "     ", start, this_group
        start += 1
        end += 1

    return return_set

def find_matches(str_1, str_2):
    for ctr in range(len(str_1)-1, 0, -1):
        group_1=one_group(ctr, str_1)
        group_2=one_group(ctr, str_2)
        for group in group_1:
            if group in group_2:
                print "*****Found*****", ctr, group
                return
 
str_1 = "abcdef"
str_2 = "cdEfg"
if str_1 == str_2:
    print "whole strings are equal"
else:
    find_matches(str_1, str_2) 

def longestdwl(A,B):
    L = 1
    for i in range(len(A)):
        a = A[i:i+L]
        j = 0
        while True:
            j = B.find(a,j)
            if j < 0:
                break
            while (i+L < len(A)) and (j+L < len(B)) and (A[i+L] == B[j+L]):
                a += A[i+L]
                L += 1
            j += 1
    return L