NinoCode/Tool_Box/BatesRangeFunctions.py

"""
BatesRangeFunctions

Created by
Emanuel Borges
12.31.2019

A set of functions for dealing wiht bates ranges, like enumerating, page counts, etc.  Originally this was a program
called FixBatesRange_func in the summation tools package but I use the enumerate and page counts for lots of other reasons,
so I copied it out to tools and deleted the parts that I didnt need.

Note that separate_alpha was the third version of this function, fixing lots of bugs, but it still calls the original SeperateAlpha
as a fall back for some reason.

"""


import re

class EnumError(Exception):
    def __init__(self,value):
        self.value = value
    def __str__(self):
        return repr(self.value)


def _SeperateAlphaOrig(bates):
    """ This original function will chop the individual bates into alpha and numeric. still used as a fall back for separate_alpha"""
    import string
    alpha = []
    for i in bates:
        if i in string.letters:
            alpha.append(i)
        if i in string.punctuation:
            alpha.append(i)
    alpha = string.join(alpha).replace(" ","")
    if alpha == "":
        num = bates
    else:
        num = bates.replace(alpha,"")
    while num[0] == '0':
        alpha = alpha + num[0]
        num = num[1:]
    return (alpha, int(num))

def seperate_alpha(bates):
    """This third version of this function will chop the individual bates into alpha and numeric"""

    parts =  filter(None,re.split(r'(\d+|\s+)',bates))
    moreParts = _SeperateAlphaOrig(parts[-1])
    num = moreParts[-1]
    parts = parts[0:-1]
    moreParts = moreParts[0:-1]
    alpha = ""
    for i in parts:
        alpha = alpha + i
    for x in moreParts:
        alpha = alpha +x
    return (alpha, int(num))


def generate_index(str):
    """
    Splits a string into alpha and numeric elements, which
    is used as an index for sorting"
    """
    #
    # the index is built progressively
    # using the _append function
    #
    index = []
    def _append(fragment, alist=index):
        if fragment.isdigit(): fragment = int(fragment)
        alist.append(fragment)

    # initialize loop
    prev_isdigit = str[0].isdigit()
    current_fragment = ''
    # group a string into digit and non-digit parts
    for char in str:
        curr_isdigit = char.isdigit()
        if curr_isdigit == prev_isdigit:
            current_fragment += char
        else:
            _append(current_fragment)
            current_fragment = char
            prev_isdigit = curr_isdigit
    _append(current_fragment)
    return tuple(index)


def GetBatesPageCount(begNo, endNo):
    begNoIndex = generate_index(begNo)
    endNoIndex = generate_index(endNo)
    matrix = zip(begNoIndex, endNoIndex)
    for i in matrix:
        try:
            numb = int(i[1]) - int(i[0])
        except:
            pass
    ## Now check to see if there was a hanging chad on the endDoc and account for it.
    if len(endNoIndex) > len(begNoIndex):
        ## first lets see if it's an int first. this will work if its begno foo-0001 endno foo0001_002
        ## but not if the endno was foo0001_002a
        if str(endNoIndex[-1]).isdigit():
            numb=+endNoIndex[-1]
            numb = numb - 1
        else:
            ## otherwise it's probable just a real handing chad like foo-0001a
            numb =+1
    return numb +1

def GetBatesRanges(batesList):
    """Takes a list of bates numbers (this single list will include all bates from beg and end values) and
    returns a list of tuple ranges"""
    batesMatrix = {}
    batesRangeList = []
    for bates in batesList:
        alpha, numb  =  seperate_alpha(bates)
        ## now remove the trailing zeros
        alpha = alpha.rstrip("0")
        if alpha in batesMatrix.keys():
            batesMatrix[alpha].append(bates)
        else:
            batesMatrix[alpha] = [bates,]
    for batesGroup in batesMatrix.keys():
        tempList = batesMatrix[batesGroup]
        tempList.sort()
        batesRangeList.append((tempList[0],tempList[-1]))
    return batesRangeList

def EnumerateBates(begNo, endNo):
    """Will return all the possible bates values in between begNo and endNo.  Split Alpha needs to be fixed
    for bates with spaces.  This will error out if the begdoc or enddoc has a weird value like foo-001.a"""
    pageCount = GetBatesPageCount(begNo, endNo)
    begBates = seperate_alpha(begNo)
    endBates = seperate_alpha(endNo)
    prefix = begBates[0]
    padding = ""
    #reverse the string
    for x in prefix[::-1]:
        if x.isdigit():
            padding = padding + x
            prefix = prefix[:-1]
        else:
            break
    padding = len(str(begBates[-1]) + padding)

    batesList = []
    for i in range(begBates[-1], endBates[-1]+1):
        batesList.append(prefix + str(i).zfill(padding))
    if len(batesList) == pageCount:
        return batesList
    else:
        #print begBates,endBates
        ## My own exception that I can catch.
        raise EnumError("Could not enumerate fully.")

def NextBatesShouldBe(bates):
    """Method will tell you what the next bates should be based on the bates that you give it."""
    batesPrefix, batesNumber = seperate_alpha(bates)
    batesNumber = batesNumber + 1
    newBates = batesPrefix + str(batesNumber)
    return newBates

def PreviousBatesShouldBe(bates):
    """Method will tell you what the previous bates should be based on the bates that you give it."""
    batesPrefix, batesNumber = seperate_alpha(bates)
    batesNumber = batesNumber - 1
    newBates = batesPrefix + str(batesNumber)
    return newBates
Revision:	716
Committed:	Thu Nov 5 22:04:23 2020 UTC (5 years, 4 months ago) by nino.borges
Content type:	text/x-python
File size:	5749 byte(s)
Log Message:	Added NextBatesShouldBe and PreviousBatesShouldBe methods.
#	User	Rev	Content
1	nino.borges	669	"""
2			BatesRangeFunctions
3
4			Created by
5			Emanuel Borges
6			12.31.2019
7
8			A set of functions for dealing wiht bates ranges, like enumerating, page counts, etc. Originally this was a program
9			called FixBatesRange_func in the summation tools package but I use the enumerate and page counts for lots of other reasons,
10			so I copied it out to tools and deleted the parts that I didnt need.
11
12			Note that separate_alpha was the third version of this function, fixing lots of bugs, but it still calls the original SeperateAlpha
13			as a fall back for some reason.
14
15			"""
16
17
18			import re
19
20			class EnumError(Exception):
21			def __init__(self,value):
22			self.value = value
23			def __str__(self):
24			return repr(self.value)
25
26
27			def _SeperateAlphaOrig(bates):
28			""" This original function will chop the individual bates into alpha and numeric. still used as a fall back for separate_alpha"""
29			import string
30			alpha = []
31			for i in bates:
32			if i in string.letters:
33			alpha.append(i)
34			if i in string.punctuation:
35			alpha.append(i)
36			alpha = string.join(alpha).replace(" ","")
37			if alpha == "":
38			num = bates
39			else:
40			num = bates.replace(alpha,"")
41			while num[0] == '0':
42			alpha = alpha + num[0]
43			num = num[1:]
44			return (alpha, int(num))
45
46			def seperate_alpha(bates):
47			"""This third version of this function will chop the individual bates into alpha and numeric"""
48
49			parts = filter(None,re.split(r'(\d+\|\s+)',bates))
50			moreParts = _SeperateAlphaOrig(parts[-1])
51			num = moreParts[-1]
52			parts = parts[0:-1]
53			moreParts = moreParts[0:-1]
54			alpha = ""
55			for i in parts:
56			alpha = alpha + i
57			for x in moreParts:
58			alpha = alpha +x
59			return (alpha, int(num))
60
61
62			def generate_index(str):
63			"""
64			Splits a string into alpha and numeric elements, which
65			is used as an index for sorting"
66			"""
67			#
68			# the index is built progressively
69			# using the _append function
70			#
71			index = []
72			def _append(fragment, alist=index):
73			if fragment.isdigit(): fragment = int(fragment)
74			alist.append(fragment)
75
76			# initialize loop
77			prev_isdigit = str[0].isdigit()
78			current_fragment = ''
79			# group a string into digit and non-digit parts
80			for char in str:
81			curr_isdigit = char.isdigit()
82			if curr_isdigit == prev_isdigit:
83			current_fragment += char
84			else:
85			_append(current_fragment)
86			current_fragment = char
87			prev_isdigit = curr_isdigit
88			_append(current_fragment)
89			return tuple(index)
90
91
92			def GetBatesPageCount(begNo, endNo):
93			begNoIndex = generate_index(begNo)
94			endNoIndex = generate_index(endNo)
95			matrix = zip(begNoIndex, endNoIndex)
96			for i in matrix:
97			try:
98			numb = int(i[1]) - int(i[0])
99			except:
100			pass
101			## Now check to see if there was a hanging chad on the endDoc and account for it.
102			if len(endNoIndex) > len(begNoIndex):
103			## first lets see if it's an int first. this will work if its begno foo-0001 endno foo0001_002
104			## but not if the endno was foo0001_002a
105			if str(endNoIndex[-1]).isdigit():
106			numb=+endNoIndex[-1]
107			numb = numb - 1
108			else:
109			## otherwise it's probable just a real handing chad like foo-0001a
110			numb =+1
111			return numb +1
112
113	nino.borges	706	def GetBatesRanges(batesList):
114			"""Takes a list of bates numbers (this single list will include all bates from beg and end values) and
115			returns a list of tuple ranges"""
116			batesMatrix = {}
117			batesRangeList = []
118			for bates in batesList:
119			alpha, numb = seperate_alpha(bates)
120	nino.borges	708	## now remove the trailing zeros
121			alpha = alpha.rstrip("0")
122	nino.borges	706	if alpha in batesMatrix.keys():
123			batesMatrix[alpha].append(bates)
124			else:
125			batesMatrix[alpha] = [bates,]
126			for batesGroup in batesMatrix.keys():
127			tempList = batesMatrix[batesGroup]
128			tempList.sort()
129			batesRangeList.append((tempList[0],tempList[-1]))
130			return batesRangeList
131
132	nino.borges	669	def EnumerateBates(begNo, endNo):
133			"""Will return all the possible bates values in between begNo and endNo. Split Alpha needs to be fixed
134			for bates with spaces. This will error out if the begdoc or enddoc has a weird value like foo-001.a"""
135			pageCount = GetBatesPageCount(begNo, endNo)
136			begBates = seperate_alpha(begNo)
137			endBates = seperate_alpha(endNo)
138			prefix = begBates[0]
139			padding = ""
140			#reverse the string
141			for x in prefix[::-1]:
142			if x.isdigit():
143			padding = padding + x
144			prefix = prefix[:-1]
145			else:
146			break
147			padding = len(str(begBates[-1]) + padding)
148
149			batesList = []
150			for i in range(begBates[-1], endBates[-1]+1):
151			batesList.append(prefix + str(i).zfill(padding))
152			if len(batesList) == pageCount:
153			return batesList
154			else:
155			#print begBates,endBates
156			## My own exception that I can catch.
157			raise EnumError("Could not enumerate fully.")
158	nino.borges	716
159			def NextBatesShouldBe(bates):
160			"""Method will tell you what the next bates should be based on the bates that you give it."""
161			batesPrefix, batesNumber = seperate_alpha(bates)
162			batesNumber = batesNumber + 1
163			newBates = batesPrefix + str(batesNumber)
164			return newBates
165
166			def PreviousBatesShouldBe(bates):
167			"""Method will tell you what the previous bates should be based on the bates that you give it."""
168			batesPrefix, batesNumber = seperate_alpha(bates)
169			batesNumber = batesNumber - 1
170			newBates = batesPrefix + str(batesNumber)
171			return newBates