hal/cvs/versioning.py
#!/usr/bin/env python
# coding: utf-8
"""Models to version stuff"""
from abc import abstractmethod
from hal.data.linked_list import LinkedList
class VersionNumber:
"""Version"""
@abstractmethod
def get_current_amount(self):
"""Gets current set amount
:return: Current set amount
"""
pass
def can_increase(self, amount):
"""Checks iff can increase by such amount
:param amount: Amount to increase
:return: True iff this number can be increased by such amount
"""
return amount <= self.max_amount_allowed()
@abstractmethod
def increase(self, amount=1):
"""Increase version by this amount
:param amount: Increase number by this amount
:return: True iff increase was successful
"""
pass
@abstractmethod
def maximize(self):
"""Maximizes this version"""
pass
@abstractmethod
def reset(self):
"""Zeroes this number"""
pass
@abstractmethod
def max_amount_allowed(self):
"""Calculates number of increases available
:return: Number of increases that can be done before reaching
"""
pass
@abstractmethod
def max(self):
"""Calculates max increases
:return: Number of increases that can be done before reaching
"""
pass
class Level(VersionNumber):
"""Level of version number"""
def __init__(self, max_inner, start=0):
"""
:param max_inner: Max number of this level. If you set to 0 this level
will increase never
:param start: Start at this number
"""
self.max_inner = max_inner
self.current = start
def __str__(self):
return str(self.current)
def get_current_amount(self):
return self.current
def increase(self, amount=1):
if self.can_increase(amount):
self.current += amount
return True
return False
def maximize(self):
self.current = self.max_inner
def reset(self):
self.current = 0
def max_amount_allowed(self):
return self.max_inner - self.current
def max(self):
return self.max_inner
class Subsystem(VersionNumber):
"""List of levels of version system"""
def __init__(self, levels, separator="."):
"""
:param levels: Levels in order of importance (from left to right the
importance increases). The version number is the reversed
:param separator: Compose version number separating with this split
"""
self.levels = LinkedList(levels)
self.current = self.max() - self.max_amount_allowed() # inverse
self.split = separator
def __str__(self):
out = [
str(val) for val in self.levels.to_lst()
]
out = self.split.join(reversed(out)) # reverse according importance
return out
def get_current_amount(self):
return self.current
def reset(self):
node = self.levels.head
while node is not None:
node.val.reset()
node = node.next_node
def increase(self, amount=1):
if self.levels.head.val.increase(amount):
return True
# head cannot increase -> reset and check for carry
amount_left = amount - self.levels.head.val.max_amount_allowed() - 1
self.levels.head.val.reset()
node = self.levels.head.next_node
carried = False
while node is not None and not carried:
if node.val.increase():
carried = True
else:
node.val.reset()
node = node.next_node
if not carried: # can't broadcast carry to last level
return False
return self.increase(amount_left)
def maximize(self):
node = self.levels.head
while node is not None:
node.val.maximize()
node = node.next_node
def max_amount_allowed(self):
amount_allowed = self.levels.head.val.max_amount_allowed()
multiplier = self.levels.head.val.max()
node = self.levels.head.next_node
while node is not None:
amount_allowed += (node.val.max_amount_allowed() - 1) * multiplier
multiplier *= node.val.max_inner
node = node.next_node
return amount_allowed
def max(self):
multiplier = 1
node = self.levels.head
while node is not None:
multiplier *= node.val.max()
node = node.next_node
return multiplier
class Version(VersionNumber):
"""Version"""
def __init__(self, start="0.0.0", max_number=9, separator="."):
"""
:param start: Current version
:param max_number: Max number reachable by sub-versions numbers
:param separator: Compose version number separating with this split
"""
self.version = Version.from_str(start, max_number, separator)
def __str__(self):
return str(self.version)
def get_current_amount(self):
return self.version.get_current_amount()
def reset(self):
return self.version.reset()
def max_amount_allowed(self):
return self.version.max_amount_allowed()
def increase(self, amount=1):
"""
:param amount:
"""
return self.version.increase(amount)
def increase_by_changes(self, changes_amount, ratio):
"""Increase version by amount of changes
:param changes_amount: Number of changes done
:param ratio: Ratio changes
:return: Increases version accordingly to changes
"""
increases = round(changes_amount * ratio)
return self.increase(int(increases))
def maximize(self):
return self.version.maximize()
def max(self):
return self.version.max()
@staticmethod
def from_str(string, max_number=9, separator="."):
"""Parses string
:param string: Version
:param max_number: Max number reachable by sub
:param separator: Version numbers are separated with this split
:return: Parses string and returns object
"""
tokens = string.split(separator)
tokens = list(reversed(tokens)) # reverse order of importance
most_important = tokens[-1] # cannot be parsed like the others
levels = [
Level(max_number, int(token)) for token in tokens[:-1]
]
levels.append(
Level(float("inf"), int(most_important))
)
return Subsystem(levels, separator)