pyarq-presupuestos: Generic/base.py comparison

comparison Generic/base.py @ 23:65e7ae0d0e63

GTK2 to GTK3

author	Miguel Ángel Bárcena Rodríguez <miguelangel@obraencurso.es>
date	Thu, 02 May 2019 16:31:17 +0200
parents	7bd4ca56607d
children	189f8274aecd

comparison

equal deleted inserted replaced

-:7bd4ca56607d
+:65e7ae0d0e63
 #!/usr/bin/python
 # -*- coding: utf-8 -*-
 ## File base.py
 ## This file is part of pyArq-Presupuestos.
 ##
-## Copyright (C) 2010-2014 Miguel Ángel Bárcena Rodríguez
+## Copyright (C) 2010-2019 Miguel Ángel Bárcena Rodríguez
 ##                         <miguelangel@obraencurso.es>
 ##
 ## pyArq-Presupuestos 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, either version 3 of the License, or
 * Name
 * Type
 * Description
 +-- __synonyms: synonyms dictionary. TODO
 +-- __root: root record code
-+-- __decimals: decimals dictionay = { int : Decimals }
++-- __decimals:  List with the decimal places used to round the
+-            result of the calculations with prices and measures
+-            The values are Decimals objects
+-            The <0> objets is the default Decimals (seted in FIEBDC-3),
+-            The others keys are for the diferent groups of Prices
 * Decimals:
 +-- DN: Number of decimal places of the field "equal-size parts" in the
 measure lines.
 Default: 2 decimal places.
 +-- DD: Number of decimal places of the three dimensions in the
 +-- fax: list of fax numbers
 +-- contact_person: Contact person in the office
 +-- cif: CIF
 +-- web: web page
 +-- email: email
++-- __comment
++-- __date
++-- __budgetType" A integer. Type of data in budget
+0 -> Undefined
+1 -> Base data.
+2 -> Budget.
+3 -> Certificate.
+4 -> Base date update.
++-- __budgetCerficateOrder" Only valid if budgetType is 3.
++-- __budgetCerficateDate" Only valid if budgetType is 3
++-- __tec_info": Dictionary whith tecnical information
+{ti_code : ["desciption text", "unit"]}
++-- __labels": Label dictionary { "label": [ "code", ], }
 """
 # Modules
+# python 2/3 compatibility
+#from __future__ import absolute_import, division, print_function, unicode_literals
 import re
 import datetime
 import os
 # pyArq-Presupuestos modules
 from Generic import fiebdc
 from Generic import utils
+# Translatable global Vars
+authors = ["Miguel Ángel Bárcena Rodríguez"]
+copyright = "Copyright \xc2\xa9 2019 Autoras de Pyarq Presupuestos"
+website = "http://pyarq.obraencurso.es/pyarq-Presupuestos"
+website_label = "pyarq Presupuestos Web"
+comments = _("""
+A free program of measurements, budgets and control of construction sites.
+In beta development, still there is not a fully functional version.
+""")
+help = _(
+"""
+Usage:
+pyarqPresupuestos [file]...
+Help Options:
+-h, --help     Show this help
+""")
 class Record(object):
 """base.Record:
 Description:
 prices, type_, subtype, parents=None, text=None)
 Ancestry:
 +-- object
 +-- Record
 Atributes:
-"code": Code string
+"code": Write/Read. Code string
-"recordType": RecordType object
+"recordType": Write/Read. RecordType object
-"synonyms": List of synonym codes.
+"synonyms": Write/Read. List of synonym codes.
-"parents":List of parent codes
+"parents": Write/Read. List of parent codes
-"children": Decomposition list,
+"children": Write/Read. Decomposition list,
 list of "Decomposition" instances
-"unit": measure unit of the record
+"unit": Write/Read. measure unit of the record
-"summary": Short description of the record
+"summary": Write/Read. Short description of the record
-"prices": List of prices/dates
+"prices": Read. List of prices/dates
-"text": Long Description of the record
+"text": Write/Read. Long Description of the record
-"sheet": Sheet of conditions object
+"sheet": Write/Read. Sheet of conditions object
-"files": List of file object
+"files": Write/Read. List of file object
-"labels": List of record labels
+"labels": Write/Read. List of record labels
 Methods:
-__getstate__(self)
+isPercentage
-__setstate__(self, tuple)
+percentageMasq
-__init__(self, filename=None, budget=None)
+hasPercentageMasq(masq)
 {get/set}Code
 {get/set}Synonyms
 {get/set}RecordType
 {get/set}Unit
 {get/set}Summary
 {get/set}Prices
 addPrice
-_validate_price_date
 getPrice
 getAmount
 getDate
 {get/set}Parents
 appendParent
 self.text = text
 self.sheet = Sheet()
 self.files = []
 self.labels = []
+def isPercentage(self):
+if "%" in self.__code or "&" in self.__code:
+return True
+else:
+return False
+def percentageMasq(self):
+if "%" in self.__code:
+return self.__code.split("%")[0]
+elif "&" in self.__code:
+return self.__code.split("&")[0]
+def hasPercentageMasq(self, masq):
+if len(self.__code) >= len(masq):
+_part_code = self.__code[:len(masq)]
+if _part_code == masq:
+return True
+return False
 def getCode(self):
 return self.__code
 def setCode(self, code):
-"""setCode(self,code)
+"""setCode(code)
 Sets the code, must be a valid code
 """
 if not utils.is_valid_code(code)[0]:
-raise ValueError, utils.mapping(_("Invalid code: $1"),(str(code),))
+raise ValueError( utils.mapping(_("Invalid code: $1"),(str(code),)) )
 self.__code = code
 def getSynonyms(self):
 return self.__synonyms
 def setSynonyms(self,synonyms):
-"""setSynonyms(self,synonyms)
+"""setSynonyms(synonyms)
 Sets the synonyms codes of the record.
 synonyms must fulfill:
 - must be a list
 - the items must be valid codes
 """
 if not isinstance(synonyms, list):
-raise TypeError, utils.mapping(_("Synonyms ($1) must be a list, " \
+raise TypeError( utils.mapping(_("Synonyms ($1) must be a list, " \
-"code: $2"), (str(synonyms), self.__code))
+"code: $2"), (str(synonyms), str(self.__code))) )
 for code in synonyms:
 if not utils.is_valid_code(code)[0]:
-raise ValueError, utils.mapping(_("Invalid Code in synomyms "\
+raise ValueError( utils.mapping(_("Invalid Code in synomyms "\
-"list ($1) code: $2"), (str(code), self.__code))
+"list ($1) code: $2"), (str(code), str(self.__code))) )
 self.__synonyms = synonyms
 def getRecordType(self):
 return self.__recordType
 def setRecordType(self, recordType):
-"""setRecordType(self, recordType)
+"""setRecordType(recordType)
 Set the record type.
 recordType (hierarchy, type,subtype)
 hierarchy must be -1, 0, 1 or 2
 def getUnit(self):
 return self.__unit
 def setUnit(self,unit):
-"""setUnit(self,unit)
+"""setUnit(unit)
 Set the unit of measure
 The unit must be a string.
 """
 if not isinstance(unit, str):
-raise TypeError, utils.mapping(_("Unit ($1) must be a string: $2"),
+raise TypeError( utils.mapping(_("Unit ($1) must be a string: $2"),
-(str(unit), self.__code))
+(str(unit), str(self.__code))) )
 self.__unit = unit
 def getSummary(self):
 return self.__summary
 def setSummary(self,summary):
-"""setSummary(self,summary)
+"""setSummary(summary)
 Set the summary of a record
 The summary must be a string.
 """
 if not isinstance(summary, str):
-raise TypeError, utils.mapping(_("Summary ($1) must be a string: "\
+raise TypeError( utils.mapping(_("Summary ($1) must be a string: "\
-"$1"), (str(summary), self.__code))
+"$1"), (str(summary), str(self.__code))) )
 self.__summary = summary
 def getPrices(self):
 return self.__prices
 def setPrices(self, prices, decimals):
-"""setPrice(self, prices, decimals)
+"""setPrice(prices, decimals)
 Set the price list of the record.
 prices must fulfill:
 - it must be a list
 - the items must be a list with two items
 - the first item: price must be a float
 """
 if not isinstance(prices, list):
-raise TypeError, utils.mapping(_("Prices ($1) must be a list: $2"),
+raise TypeError( utils.mapping(_("Prices ($1) must be a list: $2"),
-(str(prices), self.__code))
+(str(prices), str(self.__code))) )
 for index in range(len(prices)):
 _price_date = prices[index]
 _price_date = self._validate_price_date(_price_date, decimals)
 prices[index] = _price_date
 self.__prices = prices
 def addPrice(self, price_date, decimals):
-"""addPrice(self, price_date, decimals)
+"""addPrice(price_date, decimals)
 Add a price to the price list of the record.
 price must fulfill:
 - must be a list with two items
 - the first item: price must be a float
 price_date = self._validate_price_date(price_date, decimals)
 self.__prices.append(price_date)
 def _validate_price_date(self, price_date, decimals):
 if not isinstance(price_date, list) and len(price_date) == 2:
-raise ValueError, utils.mapping(_("Price ($1) must be a list"\
+raise ValueError( utils.mapping(_("Price ($1) must be a list"\
-" with two items: $2"), (str(price_date), self.__code))
+" with two items: $2"), (str(price_date), str(self.__code))) )
 _price = price_date[0]
 _date = price_date[1]
 if not isinstance(_price, float):
-raise TypeError, utils.mapping(_("Price must be a float "\
+raise TypeError( utils.mapping(_("Price must be a float "\
-"number: $1"), (str(_price),))
+"number: $1"), (str(_price),)) )
-_D = decimals.getD(self.recordType)
+_D = abs(decimals.getD(self.recordType))
 _price = round(_price, _D)
 price_date[0] = _price
 # TODO: validate date
 return price_date
 def getPrice(self, index_price):
 if len(self.__prices) <= index_price:
-raise IndexError, _("The record do not have this Price. Code: %s"
+raise IndexError( _("The record do not have this Price. Code: %s"
-% self.__code)
+% self.__code) )
 return self.__prices[index_price][0]
 def getDate(self, index_price):
 if len(self.__prices) <= index_price:
-raise IndexError, _("The record do not have this Price")
+raise IndexError( _("The record do not have this Price") )
 return self.__prices[index_price][1]
 def getParents(self):
 return self.__parents
 def setParents(self,parents):
-"""setParents(self,parents)
+"""setParents(parents)
 Sets the list of parents codes of the record.
 parents must fulfill
 - it must be a list
 - the items must be valid codes
 """
 if not isinstance(parents, list):
-raise TypeError, utils.mapping(_("Parents ($1) must be a list: $2"),
+raise TypeError( utils.mapping(_("Parents ($1) must be a list: $2"),
-(str(parents), self.__code))
+(str(parents), str(self.__code))) )
 for parent in parents:
 if not utils.is_valid_code(parent)[0]:
-raise ValueError, utils.mapping(_("Invalid parent code ($1) " \
+raise ValueError(utils.mapping(_("Invalid parent code ($1) " \
-"in the record: $2"), (str(padre), self.__code))
+"in the record: $2"), (str(padre), str(self.__code))) )
 self.__parents = parents
 def appendParent(self, parent):
-"""appendParent(self, parent)
+"""appendParent(parent)
 parent must be a valid code
 Append a parent to the list of parents codes of the record.
 """
 if not utils.is_valid_code(parent)[0]:
-raise ValueError, utils.mapping(_("Invalid parent code ($1) " \
+raise ValueError( utils.mapping(_("Invalid parent code ($1) " \
-"in the record: $2"), (str(parent), self.__code))
+"in the record: $2"), (str(parent), str(self.__code))) )
 self.__parents.append(parent)
 def getchildren(self):
 return self.__children
 def setchildren(self,children):
-"""setchildren(self,children)
+"""setchildren(children)
 Sets the list of children of a record
 children must fulfill
 - it must be a list
 - the items must be instances of Decomposition class
 """
 if not isinstance(children, list):
-raise TypeError, utils.mapping(_("children ($1) must be a list, "\
+raise TypeError( utils.mapping(_("children ($1) must be a list, "\
-"record: $2"), (str(children), self.__code))
+"record: $2"), (str(children), str(self.__code))) )
 for _child in children:
 if not isinstance(_child, Decomposition):
-raise ValueError, utils.mapping(_("child ($1) must be a "\
+raise ValueError( utils.mapping(_("child ($1) must be a "\
 "Decomposition object, record: $2"),
-(str(_child), self.__code))
+(str(_child), str(self.__code))) )
 _record_code = self.code
 for _measure_list in [_child.budgetMeasures, _child.certification,
 _child.real_cost, _child.cost_goals,
 _child.cost_planned]:
 if isinstance(_measure_list, list):
 _measurerecordCode = _record_code
 self.__children = children
 def appendChild(self, child_code, decimals, factor=0.0, yield_=0.0,
 measure=0.0, measure_list=None, type_=None, label=None):
-"""appendChildren(self, child_code, factor=0.0, yield_=0.0,
+"""appendChildren(child_code, factor=0.0, yield_=0.0,
 measure=0.0, measure_list=None, type_=None, label=None))
 position:
 child_code:
 factor:
 def getText(self):
 return self.__text
 def setText(self,text):
-"""setText(self,text)
+"""setText(text)
 Sets the text of the record
 It must be a string
 """
 if not isinstance(text, str):
-raise TypeError, utils.mapping(_("Text ($1) must be a string, "\
+raise TypeError( utils.mapping(_("Text ($1) must be a string, "\
-"record: $2"), (str(text), self.__code))
+"record: $2"), (str(text), str(self.__code))) )
 self.__text = text
 def getSheet(self):
 return self.__sheet
 def setSheet(self, sheet):
-"""setSheet(self, sheet)
+"""setSheet(sheet)
 Sets the sheet of condition object
 """
 if not isinstance(sheet, Sheet):
-raise ValueError, _("sheet must be a Sheet instance")
+raise ValueError( _("sheet must be a Sheet instance") )
 self.__sheet = sheet
 def getFiles(self):
 return self.__files
 def setFiles(self, files):
-"""setFiles(self, files)
+"""setFiles(files)
 Sets the files list
 """
-# TODO: only sets files and File object format (durusdatabase)
 if not isinstance(files, list):
-raise ValueError, utils.mapping(_("files must be a list: $1"),
+raise ValueError( utils.mapping(_("files must be a list: $1"),
-str(files))
+str(files)) )
 _files = []
 for file in files:
 if isinstance(file, File):
 _files.append(file)
 elif isinstance(file, list):
 _file_path = file[0]
 _type = file[1]
 _description = file[2]
 if not os.path.exists(file[0]):
-raise ValueError, _("Incorrect path")
+raise ValueError( _("Incorrect path") )
 _file = File(file_path, type_, description)
 _files.append(_file)
 else:
-raise ValueError, utils.mapping(_(
+raise ValueError( utils.mapping(_(
-"file must be a list or a File object: $1"),str(file))
+"file must be a list or a File object: $1"),str(file)) )
 self.__files = _files
 def addFile(self, file_path, type_, description):
-"""addFile(self, file_path, type_, description)
+"""addFile(file_path, type_, description)
 Add a file to a record instance
 """
 if not os.path.exists(file_path):
-raise ValueError, _("Incorrect path")
+raise ValueError( _("Incorrect path") )
 _name = os.path.basename(file_path)
 _isin = False
 for _ofile in self.__files:
 if _ofile.name == _name:
 _isin = True
 def getLabels(self):
 return self.__labels
 def setLabels(self, labels):
-"""setLabels(self, labels)
+"""setLabels(labels)
 Sets the labels list of a record
 """
 if not isinstance(labels, list):
-raise ValueError, _("labels must be a list")
+raise ValueError( _("labels must be a list") )
 _labels = []
 for _label in labels:
 if isinstance(_label, str):
 _labels.append(_label)
 else:
-raise ValueError, _("label must be a string")
+raise ValueError( _("label must be a string") )
 self.__labels = _labels
 def addLabel(self, label):
-"""addLabel(self, label)
+"""addLabel(label)
 Add a label to a record instance
 """
 if not isinstance(label, str):
-raise ValueError, _("Label must be a string")
+raise ValueError( _("Label must be a string") )
 if not label in self.__labels:
 self.__labels.append(label)
 def getChildPositions(self, child_code):
-"""getChildPath(self, child_code):
+"""getChildPath(child_code):
 Try to return positions of a childcode
 """
 children = self.children
 positions = []
 files = property(getFiles, setFiles, None,
 """File list""")
 labels = property(getLabels, setLabels, None,
 """Label list""")
 class ParametricRecord(Record):
 """base.ParametricRecord:
 Description:
 Parametric Record object
 self.__parameters = tuple[15]
 self.__select_comment = tuple[16]
 self.__vars = tuple[17]
 self.__parametric_summary = tuple[18]
 self.__parametric_text = tuple[19]
 def __init__(self, budget, code, synonyms, hierarchy, unit, summary,
 prices, type_, subtype, parents=None, text=None):
 if parents is None:
 parents = []
 if text is None:
 def getSelectComment(self):
 return self.__select_comment
 def setSelectComment(self, select_comment):
 self.__select_comment = select_comment
 def getVar(self, var):
 if var in self.__vars:
 return self.__vars[var]
 else:
 return None
 """Parametric summary
 """)
 parametric_text = property(getParametricText, setParametricText, None,
 """Seclect comment
 """)
 class Decomposition(object):
 """base.Decomposition:
 Description:
 "certification": list of certifications for months measures
 "real_cost": list of real cost of construction for months measures
 "cost_goals": list of cost goals of construction for months measures
 "cost_planned": list of costs planned and amended cost planned measures
 Methods:
-__getstate__(self)
-__setstate__(self, tuple)
-__init__( position, code, budgetMeasures, certification=None,
-real_cost=None, cost_goals=None, cost_planned=None)
 {get/set}position
 {get/set}Code
 {get/set}BudgetMeasures
 {get/set}Certification
 {get/set}RealCost
 {get/set}CostGoals
 {get/set}CostPlanned
 """
 __slots__ = ["_Decomposition__position",
 "_Decomposition__code",
 "_Decomposition__budgetMeasures",
 "_Decomposition__certification",
 "_Decomposition__real_cost",
 "_Decomposition__cost_goals",
 "_Decomposition__cost_planned",
 ]
 def __getstate__ (self):
 return (self.__position, self.__code, self.__budgetMeasures,
 self.__certification, self.__real_cost, self.__cost_goals,
 self.__cost_planned)
 def __setstate__(self,tuple):
 self.__position = tuple[0]
 self.__code = tuple[1]
 self.__budgetMeasures = tuple[2]
 self.__certification = tuple[3]
 self.budgetMeasures = budgetMeasures
 self.certification = certification
 self.real_cost = real_cost
 self.cost_goals = cost_goals
 self.cost_planned = cost_planned
 def getPosition(self):
 return self.__position
 def setPosition(self, position):
 if not isinstance(position, int):
-raise ValueError, _("Position must be a integer")
+raise ValueError( _("Position must be a integer") )
 self.__position = position
 def getCode(self):
 return self.__code
 def setCode(self, code):
 self.__code = code
 def getBudgetMeasures(self):
 return self.__budgetMeasures
 def setBudgetMeasures(self, budgetMeasures):
 if not isinstance(budgetMeasures, list):
-raise ValueError, _("BudgetMeasures atribute must be a list")
+raise ValueError( _("BudgetMeasures atribute must be a list") )
 for _measure in budgetMeasures:
 if not isinstance(_measure, Measure):
-raise ValueError, _("BudgetMeasures item must be a Measure "/
+raise ValueError( _("BudgetMeasures item must be a Measure "/
-"object")
+"object") )
 self.__budgetMeasures = budgetMeasures
 def getCertification(self):
 return self.__certification
 def setCertification(self, certification):
 if not (certification is None or isinstance(certification, list)):
-raise ValueError, _("Certification atribute must be a list or None")
+raise ValueError( _("Certification atribute must be a list or None") )
 self.__certification = certification
 def getRealCost(self):
 return self.__real_cost
 def setRealCost(self, real_cost):
 if not (real_cost is None or  isinstance(real_cost, list)):
-raise ValueError, _("Real cost atribute must be a list or None")
+raise ValueError( _("Real cost atribute must be a list or None") )
 self.__real_cost = real_cost
 def getCostGoals(self):
 return self.__cost_goals
 def setCostGoals(self, cost_goals):
 if not (cost_goals is None or  isinstance(cost_goals, list)):
-raise ValueError, _("Cost goals atribute must be a list or None")
+raise ValueError( _("Cost goals atribute must be a list or None") )
 self.__cost_goals = cost_goals
 def getCostPlanned(self):
 return self.__cost_planned
 def setCostPlanned(self, cost_planned):
 if not (cost_planned is None or  isinstance(cost_planned, list)):
-raise ValueError, _("Cost Planned atribute must be a list or None")
+raise ValueError( _("Cost Planned atribute must be a list or None") )
 self.__cost_planned = cost_planned
 position = property(getPosition, setPosition, None,
 """Postion of the record in the budget
 """)
 code = property(getCode, setCode, None,
 """Record code
 "label": Record Identifiers that are used by some measure programs.
 "factor":
 "yield":
 "fixed": If fixed is True the yield is not calculated from measure
 Methods:
-__getstate__()
-__setstate__(tuple)
-__init__(decimals, recordType, measure, lines,
-label, factor, yield_)
 getMeasure()
 setMeasure(measure, decimals)
 {get/set}Lines
 {get/set}Label
 getFactor()
 setFixed(decimals)
 buildMeasure(list_lines, type, decimals)
 calculateMeasure(decimals)
 updateYield(decimals)
 """
 __slots__ = ["_Measure__measure",
 "_Measure__lines",
 "_Measure__label",
 "_Measure__factor",
 "_Measure__yield_",
 "_Measure__fixed"]
 def __getstate__ (self):
 return (self.__measure, self.__lines, self.__label,
 self.__factor, self.__yield_, self.__fixed)
 def __setstate__(self,tuple):
 self.__measure = tuple[0]
 self.__lines = tuple[1]
 self.__label = tuple[2]
 self.__factor = tuple[3]
 self.__yield_ = tuple[4]
 self.__fixed = tuple[5]
 def __init__(self, decimals, recordType, measure, lines,
 label, factor, yield_):
 self.setMeasure(measure, decimals)
 self.lines = lines
 self.label = label
 self.setYield(yield_, decimals, recordType)
 self.__fixed = False
 def getMeasure(self):
 return self.__measure
 def setMeasure(self, measure, decimals):
 if not isinstance(measure, float):
-raise ValueError, utils.mapping(_("Measure must be a float "\
+raise ValueError( utils.mapping(_("Measure must be a float "\
-"number. Type: $1"), (type(measure),))
+"number. Type: $1"), (type(measure),)) )
 # TODO: test after
-_DS = decimals.DS
+_DS = abs(decimals.DS)
 measure = round(measure, _DS)
 self.__measure = measure
 def getLines(self):
 return self.__lines
 def setLines(self, lines):
 if not isinstance(lines, list):
-raise ValueError, _("Lines must be a list")
+raise ValueError( _("Lines must be a list") )
 for _line in lines:
 if not isinstance(_line, MeasureLine):
-raise ValueError, _("Line must be a MeasureLine objetc")
+raise ValueError( _("Line must be a MeasureLine objetc") )
 self.__lines = lines
 def getLabel(self):
 return self.__label
 def setLabel(self, label):
 self.__label = label
 def setFactor(self, factor, decimals, recordType):
 if not isinstance(factor, float):
-raise ValueError, utils.mapping(_("Factor must be a float number "\
+raise ValueError( utils.mapping(_("Factor must be a float number "\
-"|$1|"), (factor,))
+"|$1|"), (str(factor),)) )
 # TODO: test after
-_DF = decimals.getDF(recordType)
+_DF = abs(decimals.getDF(recordType))
 factor = round(factor, _DF)
 self.__factor = factor
 def getFactor(self):
 return self.__factor
 def setYield(self, yield_, decimals, recordType):
 if not isinstance(yield_, float):
-raise ValueError, _("Yield must be a float number")
+raise ValueError( _("Yield must be a float number") )
 # TODO: test after
-_DR = decimals.getDR(recordType)
+_DR = abs(decimals.getDR(recordType))
 yield_ = round(yield_, _DR)
 self.__yield_ = yield_
 def getYield(self):
 return self.__yield_
 def setFixed(self, fixed, decimals):
 if not isinstance(fixed, bool):
-raise ValueError, _("Fixed must be boolean object")
+raise ValueError( _("Fixed must be boolean object") )
 self.__fixed = fixed
 self.updateYield(decimals)
 def getFixed(self):
 return self.__fixed
 if type_ == "M":
 self.lines = _lines
 elif type_ == "A":
 self.lines.extend(_lines)
 else:
-raise ValueError, utils.mapping(_("Type must be M or A. Type: $1"),
+raise ValueError( utils.mapping(_("Type must be M or A. Type: $1"),
-(type_,))
+(str(type_),)) )
 self.calculateMeasure(decimals, recordType)
 def calculateMeasure(self, decimals, recordType):
 #TODO: round acumulated_subtotal and parcial_subtotal
 if len(self.lines) > 0:
 elif line.lineType == 1:
 _parcialSubtotal = _acumulated_total - _parcial_total
 line.setParcialSubtotal(_parcialSubtotal, decimals)
 _parcial_total = _acumulated_total
 self.setMeasure(_acumulated_total, decimals)
-_DR = decimals.getDR(recordType)
+_DR = abs(decimals.getDR(recordType))
 self.updateYield(decimals, recordType)
 def updateYield(self, decimals, recordType):
 if not self.fixed:
 self.setYield(self.measure, decimals, recordType)
 class MeasureLine(object):
 Valid variable: 'a', 'b', 'c','d'y 'p' (Pi=3.1415926)
 "partial" : result of measure line
 "parcial_subtotal"
 "acumulated_subtotal"
 Methods:
-__getstate__(self)
-__setstate__(self, tuple)
-__init__(self, decimals, type_, comment, units, length, width, height,
-formula)
 {get/set}LineType
 {get/set}Comment
 {get/set}Units
 {get/set}Length
 {get/set}Width
 {get/set}ParcialSubtotal
 {get/set}AcumulatedSubtotal
 calculateParcial
 eval_formula
 """
 __slots__ = ["_MeasureLine__lineType",
 "_MeasureLine__comment",
 "_MeasureLine__units",
 "_MeasureLine__length",
 "_MeasureLine__width",
 "_MeasureLine__formula",
 "_MeasureLine__parcial",
 "_MeasureLine__parcial_subtotal",
 "_MeasureLine__acumulated_subtotal",
 ]
 def __getstate__ (self):
 return (self.__lineType, self.__comment, self.__units,
 self.__length, self.__width, self.__height, self.__formula,
 self.__parcial)
 def __setstate__(self,tuple):
 self.__lineType = tuple[0]
 self.__comment = tuple[1]
 self.__units = tuple[2]
 self.__length = tuple[3]
 self.__width = tuple[4]
 self.__height = tuple[5]
 self.__formula = tuple[6]
 self.__parcial = tuple[7]
 #self.calculateParcial()
 def __init__(self, decimals, type_, comment, units, length, width, height,
 formula):
 self.__parcial = 0.0
 self.__parcial_subtotal = 0.0
 self.__acumulated_subtotal = 0.0
 self.setLength(length, decimals)
 self.setWidth(width, decimals)
 self.setHeight(height, decimals)
 self.setFormula(formula, decimals)
 #self.calculateParcial()
 def getLineType(self):
 return self.__lineType
 def getComment(self):
 return self.__comment
 def getUnits(self):
 return self.__units
 def getLength(self):
 return self.__length
 def getWidth(self):
 return self.__width
 def getHeight(self):
 return self.__height
 def getFormula(self):
 return self.__formula
 def getParcial(self):
 return self.__parcial
 def getParcialSubtotal(self):
 return self.__parcial_subtotal
 def getAcumulatedSubtotal(self):
 return self.__acumulated_subtotal
 def setParcialSubtotal(self, parcial_subtotal, decimals):
 if not isinstance(parcial_subtotal, float):
-raise ValueError, utils.mapping(_(" Parcial Subtotal must be a "\
+raise ValueError( utils.mapping(_(" Parcial Subtotal must be a "\
-"float number. Parcial: $1"), (str(parcial_subtotal),))
+"float number. Parcial: $1"), (str(parcial_subtotal),)) )
-_DS = decimals.DS
+_DS = abs(decimals.DS)
 parcial_subtotal = round(parcial_subtotal, _DS)
 self.__parcial_subtotal = parcial_subtotal
 def setAcumulatedSubtotal(self, acumulated_subtotal, decimals):
 if not isinstance(acumulated_subtotal, float):
-raise ValueError, utils.mapping(_(" Acumulated Subtotal must be "\
+raise ValueError( utils.mapping(_(" Acumulated Subtotal must be "\
 "a float number. Parcial: $1"),
-(str(acumulated_subtotal),))
+(str(acumulated_subtotal),)) )
-_DS = decimals.DS
+_DS = abs(decimals.DS)
 acumulated_subtotal = round(acumulated_subtotal, _DS)
 self.__acumulated_subtotal = acumulated_subtotal
 def calculateParcial(self, decimals):
-_DS = decimals.DS
+_DS = abs(decimals.DS)
 if self.lineType == 1 or self.lineType == 2:
 _parcial = 0.0
 elif self.lineType == 0: # self.formula == "":
 if isinstance(self.units, float):
 _a = self.units
 _parcial = round(_parcial, _DS)
 self.__parcial = _parcial
 def setLineType(self, type_):
 if not type_ in [0, 1, 2, 3]:
-raise ValueError, utils.mapping(_("Invalid measure line type ($1)"),
+raise ValueError( utils.mapping(_("Invalid measure line type ($1)"),
-(str(type_),))
+(str(type_),)) )
 self.__lineType = type_
 def setComment(self, comment):
 if not isinstance(comment, str):
-raise ValueError, utils.mapping(_("Measure Comment must be a "\
+raise ValueError( utils.mapping(_("Measure Comment must be a "\
-"string ($1)"), (str(comment),))
+"string ($1)"), (str(comment),)) )
 self.__comment = comment
 def setUnits(self, units, decimals):
 if units != "":
 if not isinstance(units, float):
-raise ValueError, utils.mapping(_("Invalid Measure Units ($1)"),
+raise ValueError( utils.mapping(_("Invalid Measure Units ($1)"),
-(str(units),))
+(str(units),)) )
-_DN = decimals.DN
+_DN = abs(decimals.DN)
 units = round(units, _DN)
 self.__units = units
 try:
 self.calculateParcial(decimals)
 except AttributeError:
 pass
 def setLength(self, length, decimals):
 if length != "":
 if not isinstance(length, float):
-raise ValueError, utils.mapping(_("Invalid Measure length ($1)"),
+raise ValueError( utils.mapping(_("Invalid Measure length ($1)"),
-(str(units),))
+(str(units),)) )
-_DD = decimals.DD
+_DD = abs(decimals.DD)
 length = round(length, _DD)
 self.__length = length
 try:
 self.calculateParcial(decimals)
 except AttributeError:
 pass
 def setWidth(self, width, decimals):
 if width != "":
 if not isinstance(width, float):
-raise ValueError, utils.mapping(_("Invalid Measure Width ($1)"),
+raise ValueError( utils.mapping(_("Invalid Measure Width ($1)"),
-(str(units),))
+(str(units),)) )
-_DD = decimals.DD
+_DD = abs(decimals.DD)
 width = round(width, _DD)
 self.__width = width
 try:
 self.calculateParcial(decimals)
 except AttributeError:
 pass
 def setHeight(self, height, decimals):
 if height != "":
 if not isinstance(height, float):
-raise ValueError, utils.mapping(_("Invalid Measure Height ($1)"),
+raise ValueError( utils.mapping(_("Invalid Measure Height ($1)"),
-(str(height),))
+(str(height),)) )
-_DD = decimals.DD
+_DD = abs(decimals.DD)
 height = round(height, _DD)
 self.__height = height
 try:
 self.calculateParcial(decimals)
 except AttributeError:
 pass
 def setFormula(self, formula, decimals):
 if not isinstance(formula, str):
-raise ValueError, utils.mapping(_("Formula must be a "\
+raise ValueError( utils.mapping(_("Formula must be a "\
-"string ($1)"), (str(formula),))
+"string ($1)"), (str(formula),)) )
 if re.match(".*[^0123456789\.()\+\-\*/\^abcdp ].*", formula):
-raise ValueError, utils.mapping(_("There is invalid characters"\
+raise ValueError( utils.mapping(_("There is invalid characters"\
-"in formula ($1)"), (str(formula),))
+"in formula ($1)"), (str(formula),)) )
 self.__formula = formula
 try:
 self.calculateParcial(decimals)
 except AttributeError:
 pass
 """)
 parcial_subtotal = property(getParcialSubtotal,
 None, None,
 """Parcial subtotal
 """)
 def eval_formula(self):
 """eval_formula()
 formula:
 Valid Operator: '(', ')', '+', '-', '*', '/' and '^'
 if c == "": c = 0.0
 if d == "": d = 0.0
 try:
 a = float(a)
 except:
-raise ValueError, _("'a' value must be a float number")
+raise ValueError( _("'a' value must be a float number") )
 try:
 b = float(b)
 except:
-raise ValueError, _("'b' value must be a float number")
+raise ValueError( _("'b' value must be a float number") )
 try:
 c = float(c)
 except:
-raise ValueError, _("'c' value must be a float number")
+raise ValueError( _("'c' value must be a float number") )
 try:
 d = float(d)
 except:
-raise ValueError, _("'d' value must be a float number")
+raise ValueError( _("'d' value must be a float number") )
 # spaces are erased
 formula.replace(" ","")
 # operators and varibles are replaced
 formula = formula.replace("+", " + ")
 formula = formula.replace("-", " - ")
 _formula2 = _formula2 + oper
 _g ={"__builtins__":{}}
 try:
 return eval(_formula2, _g)
 except:
-raise ValueError, _("Invalid formula")
+raise ValueError( _("Invalid formula") )
 class Decimals(object):
 """base.Decimals:
 Description:
 direct costs of a unit of work (and auxiliar element).
 Number of decimal places of the indirect costs.
 Default: 2 decimal places.
 "DIVISA": monetary unit.
 Methods:
-__init__(DN=2, DD=2, DSP=2, DS=2,
-DFC=3, DFPU=3, DFUO=3, DFA=3,
-DRC=3, DRPU=3, DRUO=3, DRA=3,
-DP=2, DC=2, DPU=2, DUO=2, DEA=2, DES=2,
-DIR=2, DIRC=2, DCD=2,
-DIVISA="EUR")
-__getitem__(key)
 haskey(key)
 getD(recordtype)
 getDF(recordType)
 getDR(recordType)
 getDI(recordType)
 """
 # TODO: get/set methods
 def __init__(self,
 DN=2, DD=2, DSP=2, DS=2,
 DFC=3, DFPU=3, DFUO=3, DFA=3,
 DRC=3, DRPU=3, DRUO=3, DRA=3,
 DP=2, DC=2, DPU=2, DUO=2, DEA=2, DES=2,
 self.DES = DES
 self.DIR = DIR
 self.DIRC = DIRC
 self.DCD = DCD
 self.DIVISA = DIVISA
 def __getitem__(self, key):
 return self.__dict__[key]
 def haskey(self, key):
 return key in self.__dict__
 def getD(self, recordType):
 # DP: budget.
 # DC: chapter and subcharter.
 # DUO: unit.
 # DEA: auxiliar element.
 ): # simple element
 _decimal = self.DES
 else: # unit  type 0, subtipe ["EU", "EC", "EF", "PA"]
 _decimal = self.DUO
 return _decimal
 def getDF(self, recordType):
 # Factor: DF
 #   ->DFP: Budget
 #   ->DFC: Chapter/Subchapter
 #   ->DFUO: Unit
 if recordType.subtype == "PU": # unitary budget element
 _decimal = self.DFPU
 else: # unit  EU EC EF PA
 _decimal = self.DFUO
 return _decimal
 def getDR(self, recordType):
 # Yield: DR
 #   ->DRP: Budget
 #   ->DRC: Chapter/Subchapter
 #   ->DRUO: Unit
 if recordType.subtype == "PU": # unitary budget element
 _decimal = self.DRPU
 else: # unit
 _decimal = self.DRUO
 return _decimal
 def getDI(self, recordType):
 # DIRC: budget, chapter and subcharter.
 # DIR: unit, auxiliar element.
 _hierarchy = recordType.hierarchy
 _subtype = recordType.subtype
 # auxiliar element type 0 subitype "EA"
 # unit  type 0, subtipe ["EU", "EC", "EF", "PA", "PU"]
 _decimal = self.DIR
 return _decimal
 class Sheet(object):
 """base.Sheet:
 Description:
 Sheet of conditions object
 Constructor:
 "sheet_dict": { <Field key> : { <Section key> : <Paragraph key>}
 <Field key>: must be in Budget.SheetFields
 <Section key>: must be in Budget.SheetSections
 <Paragraph key>: must be in Budget.SheetParagraph
 Methods:
-__getstate__(self)
-__setstate__(self, tuple)
-__init__(self, sheet_dict={})
 {get/set}Sheet_dict
 getFields
 getSections
 getParagraph
 addField
 addSection
 """
 __slots__ = ["_Sheet__sheet_dict"]
 def __getstate__ (self):
 return (self.__sheet_dict,)
 def __setstate__(self,tuple):
 self.__sheet_dict = tuple[0]
 def __init__(self):
 self.__sheet_dict = {}
 def getSheet_dict(self):
 return self.__sheet_dict
 def setSheet_dict(self, sheet_dict):
 if not isinstance(sheet_dict, dict):
-raise ValueError, _("sheet_dict must be a dictionay")
+raise ValueError( _("sheet_dict must be a dictionay") )
 self.__sheet_dict = sheet_dict
 def getFields(self):
 return self.sheet_dict.keys()
 def getSections(self, field):
 if field in self.__sheet_dict:
 return self.__sheet_dict[field].keys()
 else:
 return None
 def getParagraph(self, field, section):
 if (field in self.__sheet_dict and
 section in self.__sheet_dict[field]):
 return self.__sheet_dict[field][section]
 else:
 return None
 def addField(self, field, section_dict):
 if not isinstance(field, str):
-raise ValueError, _("sheet field must be a string")
+raise ValueError( _("sheet field must be a string") )
 if not isinstance(section_dict, dict):
-raise ValueError, _("section_dict must be a dictionary")
+raise ValueError( _("section_dict must be a dictionary") )
 self.__sheet_dict[field] = section_dict
 def addSection(self, field, section, paragraph):
 if not isinstance(field, str):
-raise ValueError, _("sheet field must be a string")
+raise ValueError( _("sheet field must be a string") )
 if not isinstance(section, str):
-raise ValueError, _("sheet section must be a string")
+raise ValueError( _("sheet section must be a string") )
 if not isinstance(paragraph, str):
-raise ValueError, _("sheet paragraph must be a string")
+raise ValueError( _("sheet paragraph must be a string") )
 if not field in self.__sheet_dict:
 self.addField(field, { })
 _field = self.__sheet_dict[field]
 _field[section] = paragraph
 sheet_dict = property(getSheet_dict, setSheet_dict, None,
 """Sheet dictionary { <Field key> : { <Section key> : <Paragraph key>}""")
 class Budget(object):
 """base.Budget:
 Description:
-Budget objetc
+Budget object
++-- __records: dictionary records { code : Record }
++-- __synonyms: synonyms dictionary. TODO { "code" : ["synonym",],}
+Each record code can have synonym codes.
++-- __root: the root record code
++-- __decimals: List with the decimal places used to round the
+-            result of the calculations with prices and measures
+-            The values are Decimals objects
+-            The <0> objets is the default Decimals (seted in FIEBDC-3),
+-            The others keys are for the diferent groups of Prices
++-- __percentages: percentages dictionary:
+{ "CI"  : "",
+"GG"  : "",
+"BI"  : "",
+"BAJA": "",
+"IVA" : ""}
++-- __file_owner
++-- __title_list: titles list: [ "Header", ["Title1", "Title2", ... ] ]
+List with the Headers and list of Titles for prices and
+decimal places.
+The Headers is the type of hierarchy of the prices
+Each Title have a group of Prices and a Decimals definition
+The records can have diferent prices for diferent ages, geografical
+places, ...
++-- __title_index: A integer. The active group of Prices and Decimals.
++-- __sheet_sections: sheet sections dictionary { sheet_code : sheet_title }
++-- __sheet_fields: sheet fields dictionary { field_code : field_title }
++-- __sheet_paragraphs: sheet paragraphs dictionary
+{ paragraph_code : paragraph_text}
++-- __companys: Dictionary whith companys object
+{ company_code: company_object }
++-- __comment
+-       +-- __date
+-       +-- __budgetType" A integer. Type of data in budget
+-                0 -> Undefined
+-                1 -> Base data.
+-                2 -> Budget.
+-                3 -> Certificate.
+-                4 -> Base date update.
+-       +-- __budgetCerficateOrder" Only valid if budgetType is 3.
+-       +-- __budgetCerficateDate" Only valid if budgetType is 3
+-       +-- __tec_info": Dictionary whith tecnical information
+-                        {ti_code : ["desciption text", "unit"]}
+-       +-- __labels": Label dictionary { "label": [ "code", ], }
 Constructor:
 base.Budget()
 Ancestry:
 +-- object
 +-- Budget
 Atributes:
-"filename": file name of the budget file (FIEBDC)
+No public Atributes
-"__records": Dictionary with the budget records.
-{ "code" : Record object, }
-"__synonyms": Dictionary with the records synonums.
-{ "code" : ["synonym",],}
-Each record code can have synonym codes.
-"__root": The root record code.
-"__title_list": List with the Headers and list of Titles for prices and
-decimal places.
-[ "Header", ["Title1", "Title2", ... ] ]
-The records can have diferent prices for diferent ages, geografical
-places, ...
-The Headers is the type of hierarchy of the prices
-Each Title have a group of Prices and a Decimals definition
-"__decimals": List with the decimal places used to round the
-result of the calculations with prices and measures
-The values are Decimals objects
-The <0> objets is the default Decimals (seted in FIEBDC-3),
-The others keys are for the diferent groups of Prices
-"__percentages": Dictionary with the percentages
-keys:
-"CI"    Indirect Cost
-"GG"    General expenses
-"BI"    Industrial benefit
-"BAJA"  Low (what this do here?)
-"IVA"   Tax
-"__file_owner"
-"__comment"
-"__date"
-"__budgetType" A integer. Type of data in budget
-0 -> Undefined
-1 -> Base data.
-2 -> Budget.
-3 -> Certificate.
-4 -> Base date update.
-"__budgetCerficateOrder" Only valid if budgetType is 3.
-"__budgetCerficateDate" Only valid if budgetType is 3
-"__title_index": A integer. The active group of Prices and Decimals.
-"__sheet_sections": Dictionary whith de sheet sections
-"__sheet_fields": Dictionary whith sheet fields
-"__sheet_paragraphs": Dictionary whith sheet paragraphs
-"__companys": Dictionary whith companys object
-{ company_code: company_object }
-"__tec_info": Dictionary whith tecnical information
-{ti_code : ["desciption text", "unit"]}
-"__labels": Label dictionary { "label": [ "code", ], }
 Methods:
 iter
 iterPreOrder
 iterPostOrder
 getRoot(self)
 setParametricSelectComment
 setParametricSummary
 setParametricText
 """
 def __init__(self):
 """__init__(self)
 Initialize the budget atributes
 """
+# title_index: A integer. The active group of Prices and Decimals.
+# TODO: change title_index
 self.__title_index = 0
+# List with the decimal places used to round the
+# result of the calculations with prices and measures
+# The values are Decimals objects
+# The <0> objets is the default Decimals (seted in FIEBDC-3),
+# The others keys are for the diferent groups of Prices
 self.__decimals = [Decimals(), Decimals()]
+# Dictionary with the percentages
+#    keys:
+#        "CI"    Indirect Cost
+#        "GG"    General expenses
+#        "BI"    Industrial benefit
+#        "BAJA"  Low (what this do here?)
+#        "IVA"   Tax
 self.__percentages = { "CI" : "" ,"GG": "", "BI": "",
 "BAJA": "", "IVA" : ""}
+# List with the Headers and list of Titles for prices and
+#    decimal places.
+#    [ "Header", ["Title1", "Title2", ... ] ]
+#    The records can have diferent prices for diferent ages, geografical
+#    places, ...
+#    The Headers is the type of hierarchy of the prices
+#    Each Title have a group of Prices and a Decimals definition
 self.__title_list = [ "", [ ] ]
+# The root record code.
 self.__root = None
 self.__file_owner = ""
 self.__comment = ""
-self.__budgetCerficateOrder = None
+self.__budgetCerficateOrder = None  # Only valid if budgetType is 3.
-self.__budgetCerficateDate = None
+self.__budgetCerficateDate = None   # Only valid if budgetType is 3.
 self.__date = (0,0,0)
+# budgetType: A integer. Type of data in budget
+#        0 -> Undefined
+#        1 -> Base data.
+#        2 -> Budget.
+#        3 -> Certificate.
+#        4 -> Base date update.
 self.__budgetType = 0
+# Dictionary with the budget records: { "code" : Record object, }
 self.__records = { }
+# Dictionary with the records synonyms.
+#    { "code" : ["synonym",],}
+#    Each record code can have synonym codes.
 self.__synonyms = { }
+# sheet_sections: Dictionary whith de sheet sections
 self.__sheet_sections = { }
+# sheet_fields: Dictionary whith sheet fields
 self.__sheet_fields = { }
+# sheet_paragraphs: Dictionary whith sheet paragraphs
 self.__sheet_paragraphs = { }
+# companys: Dictionary whith companys object
+#           { company_code: company_object }
 self.__companys = { }
+# tec_info: Dictionary whith tecnical information
+#           {ti_code : ["desciption text", "unit"]}
 self.__tec_info = { }
+# labels: Label dictionary { "label": [ "code", ], }
 self.__labels = { }
 def __getstate__(self):
 return (self.__title_index, self.__decimals, self.__percentages,
 self.__title_list, self.__root, self.__file_owner,
 self.__labels = tuple[13]
 def iter(self):
 for record in self.__records:
 yield record
 def iterPreOrder(self, recordCode, codes=None):
 if codes is None:
 codes = []
 _children = self.getchildren(recordCode)
 for _child in _children:
 if not _child in codes:
 codes.append(_child)
 self.iterPreOrder(_child, codes)
 return codes
 def iterPostOrder(self, recordCode, codes=None):
 if codes is None:
 codes = []
 _children = self.getchildren(recordCode)
 for _child in _children:
 """
 _record = self.__records[code]
 _children = _record.children
 _child_code = [ _child.code for _child in _children ]
 return _child_code
 def setOwner(self, owner):
 """setOwner(self, owner)
 owner: data owner
 Set the data owner.
 """
 if isinstance(owner, basestring):
 self.__file_owner = owner
 else:
-raise  TypeError, _("Owner must be a string")
+raise  TypeError( _("Owner must be a string") )
 def setDate(self, date):
 """setOwner(self, date)
 date (_y, _m, _d)
 date[2] in range(32):
 if date[1] != 0 and date[2] != 0:
 datetime.date(*date)
 self.__date = date
 else:
-raise  TypeError, utils.mapping(_("Invalid Date: $1"),(str(date),))
+raise  TypeError( utils.mapping(_("Invalid Date: $1"),(str(date),)) )
 def setComment(self, comment):
 """setOwner(self, comment)
 comment: text to comment the budged
 Set the comment.
 """
 if isinstance(comment, basestring):
 self.__comment = comment
 else:
-raise  TypeError, _("Comment must be a string")
+raise  TypeError( _("Comment must be a string") )
 def setBudgeType(self, budget_type):
 """setOwner(self, budget_type)
 budget_type: type of data in budget
 Set the budget type.
 """
 if budget_type in [1, 2, 3, 4]:
 self.__budgetType = budget_type
 else:
-raise  ValueError, _("Budget type must be 1, 2, 3 or 4.")
+raise  ValueError( _("Budget type must be 1, 2, 3 or 4.") )
 def setCertificateOrder(self, certificate_order, certificate_date):
 """setOwner(self, budget_type)
 certificate_order: certificate number
 certificate_date: certificate date
 Set the certificate order and date.
 """
 if isinstance(certificate_order, int):
 self.__budgetCerficateOrder = certificate_order
 else:
-raise  ValueError, _("Certificate order must be a integer.")
+raise  ValueError( _("Certificate order must be a integer.") )
 def setCertificateDater(self, certificate_date):
 """setCertidicateDate(self, certificate_date)
 Set the certificate date.
 isinstance(certificate_date[1], int) and \
 isinstance(certificate_date[2], int):
 datetime.date(*certificate_date)
 self.__budgetCerficateDate = certificate_date
 else:
-raise  ValueError, _("Budget certificate Date must be a valid Date.")
+raise  ValueError( _("Budget certificate Date must be a valid Date.") )
 def setTitleList(self, title_list):
 """setTitleList(self, title_list)
 title_list: [ "Header", ["Title1", "Title2", ... ] ]
 if isinstance(title_list, list) and isinstance(title_list[1], list):
 for i in range(len(title_list[1])):
 title_list[1][i] = str(title_list[1][i])
 self.__title_list = title_list
 else:
-raise TypeError, _("Invalid title list format")
+raise TypeError( _("Invalid title list format") )
 def getTitleList(self):
 """ getTitleList(self)
 Returns the header and titles for the price groups and decimals.
 _default_decimals = self.__decimals[0]
 self.__decimals.append(_default_decimals)
 elif N < len(self.__decimals):
 _default_decimals = self.__decimals[N]
 else:
-raise IndexError, _("Invalid Index Title")
+raise IndexError( _("Invalid Index Title") )
 for _decimal in dictionary:
 if dictionary[_decimal] == "":
 dictionary[_decimal] = eval("_default_decimals." + _decimal)
 decimals = Decimals(dictionary["DN"], dictionary["DD"],
 dictionary["DSP"], dictionary["DS"],
 dictionary["DUO"], dictionary["DEA"],
 dictionary["DES"], dictionary["DIR"],
 dictionary["DIRC"], dictionary["DCD"],
 dictionary["DIVISA"])
 self.__decimals[N] = decimals
 def getDecimals(self, decimal=None, N=None):
 """getDecimals(self,decimal="All",N=None)
 decimal:
 "All": Return a Decimals objet for a price group
 elif decimal == "keys":
 return self.__decimals[N+1].keys
 elif self.__decimals[N+1].haskey(decimal):
 return self.__decimals[N+1][decimal]
 else:
-raise KeyError, _("Decimal Key error")
+raise KeyError( _("Decimal Key error") )
 def setPercentages(self, dictionary):
 """setPercentages(self, dictionary):
 dictionary: the percentage dictionary
 elif key == "keys":
 return self.__percentages.keys
 elif key in self.__percentages:
 return self.__percentages[key]
 else:
-raise KeyError, _("Invalid Percentage key")
+raise KeyError( _("Invalid Percentage key") )
 def getAllParents(self,code):
 """getAllParents(self,code)
 code: a record code.
 _measure = _decomposition.budgetMeasures[0]
 return _measure
 def getStrYield(self, measure, recordType):
 #_DR = measure.getDR(self.getDecimals())
-_DR = self.getDecimals().getDR(recordType)
+_DR = abs(self.getDecimals().getDR(recordType))
 _yield = ("%." + str(_DR) + "f" ) % measure.yield_
 return _yield
 def getStrFactor(self, measure, recorType):
-_DF = self.getDecimals().getDF(recordType)
+_DF = abs(self.getDecimals().getDF(recordType))
 #_DF = measure.getDF(self.getDecimals())
 _factor = ("%." + str(_DF) + "f" ) % measure.factor
 return _factor
 def setTree(self, code, child_code, position, factor, yield_, total,
 Sets the decomposition of a record in a child record
 """
 if code is None: # No-estructured measures
 code = self.getRoot()
 if code == None: # No root
-print "No-estructured measures. Adding root record",
+print( "No-estructured measures. Adding root record " +
-self.setRecord("root", [], 0, "", "", [0.0,], [(1,1,1970)],
+str(self.setRecord("root", [], 0, "", "", [0.0,], [(1,1,1970)],
-0, "")
+0, "") ))
 code = self.getRoot()
 if not utils.is_valid_code(code)[0]:
-raise ValueError, utils.mapping(_("Invalid parent code: $1"),
+raise ValueError( utils.mapping(_("Invalid parent code: $1"),
-(code,))
+(str(code),)) )
 if not utils.is_valid_code(child_code)[0]:
-raise ValueError, utils.mapping(_("Invalid child code: $1 $2"),
+raise ValueError( utils.mapping(_("Invalid child code: $1 $2"),
-(code,child_code))
+(str(code),str(child_code))) )
 if not isinstance(position, int):
-raise ValueError, utils.mapping(_("Invalid position in measure "\
+raise ValueError( utils.mapping(_("Invalid position in measure "\
-"$1, in code $2"), (parent_code, position))
+"$1, in code $2"), (str(parent_code), str(position))) )
 # Test circular references
 _all_parent_list = self.getAllParents(code) + [ code ]
 _all_child_list = self.getAllchildren(child_code) + [ child_code ]
 for _parent_code in _all_parent_list:
 if _parent_code in _all_child_list:
 # TODO: change return to except
-print utils.mapping(_("Circular Decomposition, parent code: "\
+print(utils.mapping(_("Circular Decomposition, parent code: "\
 "$1, child code: $2, repeated code: $3"),
-(code, child_code, _parent_code))
+(str(code), str(child_code), str(_parent_code))) )
 return
 # Creating reference to parent code in child record
 if child_code in self.__records:
 _child_record = self.__records[child_code]
 position = _child_number
 if position == -2: # No-estructured measures or empty position (error in FIEBDC file)
 positions = _record.getChildPositions(child_code)
 if len(positions) == 1:
 position = positions[0]
-print utils.mapping(_("No-estructured measure or empty position. Parent Code: "\
+print(utils.mapping(_("No-estructured measure or empty position. Parent Code: "\
-"$1, Child code: $2, Position: $3"),(code, child_code, position))
+"$1, Child code: $2, Position: $3"),(str(code), str(child_code), str(position))) )
 else:
 position = _child_number
-print utils.mapping(_("No-estructured measure or empty position. "\
+print(utils.mapping(_("No-estructured measure or empty position. "\
 "Repeated child in unspecified position. "\
 "It is impossible to determine the position. "\
 "New child is added in the decomposition. "\
-"Parent code: $1, Child code: $2, Position: $3"),(code, child_code, position))
+"Parent code: $1, Child code: $2, Position: $3"),(str(code), str(child_code), str(position))) )
 if position == _child_number:
 # The record do not have the child
 if not isinstance(factor, float): factor = 1.0
 if not isinstance(yield_, float): yield_ = 1.0
 if not isinstance(total, float): total = 0.0
 _record.recordType)
 if isinstance(label, str) and label != "" :
 _measure.label = label
 else:
 # TODO: change return for except
-print utils.mapping(_("Error: Invalid child position in "
+print(utils.mapping(_("Error: Invalid child position in "
 "decomposition. Parent code: $1 Child code: $2 "\
-"Position: $3"), (code, child_code, position))
+"Position: $3"), (str(code), str(child_code), str(position))) )
 return
 else:
 if child_code == "" :
-print utils.mapping(_("Error: Empty child code. Parent code: "\
+print(utils.mapping(_("Error: Empty child code. Parent code: "\
-"$1 Position: $2"), (code, position))
+"$1 Position: $2"), (str(code), str(position))) )
 return
 if position == -1:
 position = 0
 elif position != 0:
-print utils.mapping(_("Error: Invalid child position in "\
+print(utils.mapping(_("Error: Invalid child position in "\
 "decomposition. Parent code: $1 Child code: $2 "\
-"Position: $3"), (code, child_code, position))
+"Position: $3"), (str(code), str(child_code), str(position))) )
 return
 if not isinstance(factor, float):
 factor = 1.0
 if not isinstance(yield_, float):
 yield_ = 1.0
 if c == "": c = 0.0
 if d == "": d = 0.0
 try:
 a = float(a)
 except:
-raise ValueError, _("'a' value must be a float number")
+raise ValueError( _("'a' value must be a float number") )
 try:
 b = float(b)
 except:
-raise ValueError, _("'b' value must be a float number")
+raise ValueError( _("'b' value must be a float number") )
 try:
 c = float(c)
 except:
-raise ValueError, _("'c' value must be a float number")
+raise ValueError( _("'c' value must be a float number") )
 try:
 d = float(d)
 except:
-raise ValueError, _("'d' value must be a float number")
+raise ValueError( _("'d' value must be a float number") )
 # spaces are erased
 sre.sub("[ ]","",formula)
 # operators and varibles are replaced
 formula = formula.replace("+", " + ")
 formula = formula.replace("-", " - ")
 _formula2 = _formula2 + oper
 _g = {"__builtins__":{}}
 try:
 return eval(_formula2, _g)
 except:
-raise ValueError, _("Invalid formula")
+raise ValueError( _("Invalid formula") )
 def getText(self,code):
 """getText(self,code)
 code: the record code
 Returns the description text of a record
 """
 if code in self.__records:
 return self.__records[code].text
 else:
-raise IndexError, _("Invalid code")
+raise IndexError( _("Invalid code") )
 def setText(self,code,text):
 """setText(self,code,text)
 code: the parent record code
 text: the descripion text
 Sests the description text of a record
 """
 if not utils.is_valid_code(code)[0]:
-raise ValueError, utils.mapping(_("Invalid record: $1"), (code,))
+raise ValueError( utils.mapping(_("Invalid record: $1"), (str(code),)) )
 if not code in self.__records:
 _record = self.setRecord(code, [], "", "", "", [], [],
 "", "")
 _record.text = text
 else:
 if hierarchy == 0 :
 # is the root record
 if self.__root is None:
 self.__root = code
 else:
-print _("Only can be one root record")
+print(_("Only can be one root record") )
 return
 # TODO: If the root is created in settree. No-estructured measures
 # TODO  Rewrite root values
 # retake previous values.
 # TODO: test synonyms
 - must be a list with two items
 - the first item: price must be a float
 """
 record.addPrice(price_date, self.getDecimals())
-def getStrPriceFromRecord(self, index_price, record):
+def getStrPriceFromRecord(self, index_price, record, path):
-_price = record.getPrice(index_price)
+if record.isPercentage():
-_D = self.getDecimals().getD(record.recordType)
+_percentageMasq = record.percentageMasq()
+_parent_code = self.getCode(path[:-1])
+_N_record = path[-1]
+_amount_sum = 0.0
+for N,_code in enumerate(self.getchildren(_parent_code)[:_N_record]):
+_child_record = self.getRecord(_code)
+if _child_record.hasPercentageMasq(_percentageMasq):
+_path = path[:-1] + (N,)
+_amount = self.getAmount(_path)
+_amount_sum = _amount_sum + _amount
+_price = _amount_sum
+else:
+_price = record.getPrice(index_price)
+_D = abs(self.getDecimals().getD(record.recordType))
 _price = ("%." + str(_D) + "f" ) % _price
 return _price
 def getCode(self, path):
 """getCode(self, path)
 _record = self.__records[_code]
 _children_list = _record.children
 try:
 _child = _children_list[i]
 except:
-raise ValueError, _("This record does not exits")
+raise ValueError( _("This record does not exits") )
 _code = _child.code
 else:
-raise ValueError, _("Path item must be a integer")
+raise ValueError( _("Path item must be a integer") )
 return _code
 else:
-raise ValueError, _("This record does not exits")
+raise ValueError( _("This record does not exits") )
 else:
-raise ValueError, utils.mapping(_("Path must be a not empty "\
+raise ValueError( utils.mapping(_("Path must be a not empty "\
-"tuple: $1"), (str(path),))
+"tuple: $1"), (str(path),)) )
 def getAmount(self, path):
 """def getAmount(self,path)
 path: record path
 Calculate the record amount
 """
 if len(path) == 1:
 # root: amount is the root price
 _root = self.getRecord(self.getRoot())
 _amount = _root.getPrice(self.__title_index)
 return _amount
 _decomposition = _parent_record.children[_child_number]
 _factor = _decomposition.budgetMeasures[0].factor
 _yield = _decomposition.budgetMeasures[0].yield_
 _child_code = _decomposition.code
 _child_record = self.getRecord(_child_code)
-_price = _child_record.getPrice(self.getActiveTitle())
+_code = self.getCode(path)
-_DR = self.getDecimals().getDR(_parent_record.recordType)
+_record = self.getRecord(_code)
+if _record.isPercentage():
+_percentageMasq = _record.percentageMasq()
+_N_record = path[-1]
+_amount_sum = 0.0
+for N,_code in enumerate(self.getchildren(_parent_code)[:_N_record]):
+_child_record = self.getRecord(_code)
+if _child_record.hasPercentageMasq(_percentageMasq):
+_path = path[:-1] + (N,)
+_amount = self.getAmount(_path)
+_amount_sum = _amount_sum + _amount
+_price = _amount_sum
+else:
+_price = _child_record.getPrice(self.getActiveTitle())
+_DR = abs(self.getDecimals().getDR(_parent_record.recordType))
 _total_yield = round(_factor * _yield, _DR)
-_DI = self.getDecimals().getDI(_parent_record.recordType)
+_DI = abs(self.getDecimals().getDI(_parent_record.recordType))
 _amount = round(_total_yield * _price, _DI)
 return _amount
 def getStrAmount(self, path):
 """def getStrAmount(self, path)
 path: record path
 Calculate the string record amount
 """
 if len(path) == 1: #root
 _root = self.getRecord(self.getRoot())
-_amount = self.getStrPriceFromRecord(self.__title_index, _root)
+_amount = self.getStrPriceFromRecord(self.__title_index, _root, path)
 return _amount
 else:
 _parent_code = self.getCode(path[:-1])
 _parent_record = self.getRecord(_parent_code)
 _amount = self.getAmount(path)
-_DI = self.getDecimals().getDI(_parent_record.recordType)
+_DI = abs(self.getDecimals().getDI(_parent_record.recordType))
 _amount = ("%." + str(_DI) + "f") % _amount
 return _amount
 def setSheetSection(self,sheet_code,sheet_title):
 if not isinstance(sheet_code, str):
-raise ValueError, _("The sheet code must be a string")
+raise ValueError( _("The sheet code must be a string") )
 if not isinstance(sheet_title, str):
-raise ValueError, _("The sheet title must be a string")
+raise ValueError( _("The sheet title must be a string") )
 self.__sheet_sections[sheet_code] = sheet_title
 def hasSheetSection(self, section):
 return section in self.__sheet_sections
 def getSheetSection(self, section):
 return self.__sheet_sections[section]
 def setSheetSections(self,dictionary):
 if not isinstance(dictionary, dict):
-raise ValueError, _("The sheet sections must be a dictionary")
+raise ValueError( _("The sheet sections must be a dictionary") )
 for sheet_code in dictionary.keys():
 self.setSheetSection(sheet_code, dictionary[sheet_code])
 def setSheetField(self, field_code, field_title):
 if not isinstance(field_code, str):
-raise ValueError, _("The field code must be a string")
+raise ValueError( _("The field code must be a string") )
 if not isinstance(field_title, str):
-raise ValueError, _("The field title must be a string")
+raise ValueError( _("The field title must be a string") )
 self.__sheet_fields[field_code] = field_title
 def hasSheetField(self, field):
 return field in self.__sheet_fields
 def getSheetField(self, field):
 return self.__sheet_fields[field]
 def setSheetFields(self, field_dict):
 if not isinstance(field_dict, dict):
-raise ValueError, _("The sheet field must be a dictionary")
+raise ValueError( _("The sheet field must be a dictionary") )
 for field_code in field_dict.keys():
 self.setSheetField( field_code, field_dict[field_code])
 def setSheetParagraph(self, paragraph_code, paragraph_text):
 if not isinstance(paragraph_code, str):
-raise ValueError, _("The paragraph code must be a string")
+raise ValueError( _("The paragraph code must be a string") )
 if not isinstance(paragraph_text, str):
-raise ValueError, _("The paragraph text must be a string")
+raise ValueError( _("The paragraph text must be a string") )
 self.__sheet_paragraphs[paragraph_code] = paragraph_text
 def hasSheetParagraph(self, paragraph):
 return paragraph in self.__sheet_paragraphs
 def getSheetParagraph(self, paragraph):
 return self.__sheet_paragraphs[paragraph]
 def setSheetParagraphs(self, paragraph_dict):
 if not isinstance(paragraph_dict, dict):
-raise ValueError, _("The paragraph dict must be a dictionary")
+raise ValueError( _("The paragraph dict must be a dictionary") )
 for paragraph_code in paragraph_dict.keys():
 self.setSheetParagraph( paragraph_code, paragraph_dict[paragraph_code])
 def setSheetRecord(self, record_code, field, section_dict):
 if not isinstance(record_code, str):
-raise ValueError, _("The record_code code must be a string")
+raise ValueError( _("The record_code code must be a string") )
 if not isinstance(field, str):
-raise ValueError, _("The field must be a string")
+raise ValueError( _("The field must be a string") )
 if not isinstance(section_dict, dict):
-raise ValueError, _("The section dict must be a dictionary")
+raise ValueError( _("The section dict must be a dictionary") )
 #-#
 # TODO: Add a empty record?
 if not self.hasRecord(record_code):
-print utils.mapping(_("Error: The budget do not have this record "\
+print(utils.mapping(_("Error: The budget do not have this record "\
 "code and can not be added the sheet text in the field $1. "\
-"Record Code: $2"), ( field, record_code))
+"Record Code: $2"), ( str(field), str(record_code))) )
 return
 #-#
 if not self.hasSheetField(field):
 self.setSheetField(field, "")
 for section, paragraph in section_dict.iteritems():
 self.setSheetParagraph(paragraph,"")
 if not self.hasSheetSection(section):
 self.setSheetSection(section, "")
 _sheet = self.getRecord(record_code).getSheet()
 _sheet.addSection(field, section, paragraph)
 def addFile(self, record_code, filepath, type_, description):
 if not isinstance(record_code, str):
-raise ValueError, _("The record_code code must be a string")
+raise ValueError( _("The record_code code must be a string") )
-if not isinstance(filepath, str):
+#-# str and unicode
-raise ValueError, _("The filename must be a string")
+if not isinstance(filepath, str) and not isinstance(filepath, unicode):
+raise ValueError( _("The filename must be a string") )
 #-#
 # TODO: Add a empty record?
 if not self.hasRecord(record_code):
-print utils.mapping(_("Error: The budget do not have the record "\
+print(utils.mapping(_("Error: The budget do not have the record "\
 "code $1 and can not be added the file: $2"),
-(record_code, filepath))
+(str(record_code), str(filepath))) )
 return
 #-#
 _record = self.getRecord(record_code)
 _record.addFile(filepath, type_, description)
 def setCompany(self, company_code, sumamary, name, offices,
 cif, web, email):
 if not isinstance(company_code, str):
-raise ValueError, _("The company code must be a string")
+raise ValueError( _("The company code must be a string") )
 if not isinstance(sumamary, str):
-raise ValueError, _("The summary must be a string")
+raise ValueError( _("The summary must be a string") )
 if not isinstance(name, str):
-raise ValueError, _("The name must be a string")
+raise ValueError( _("The name must be a string") )
 if not isinstance(offices, list):
-raise ValueError, _("The name must be a list")
+raise ValueError( _("The name must be a list") )
 _offices = []
 for _office in offices:
 if not isinstance(_office, list):
-raise ValueError, _("The office must be a list")
+raise ValueError( _("The office must be a list") )
 if not len(_office) == 10:
-raise ValueError, _("The office must be a 10 items list")
+raise ValueError( _("The office must be a 10 items list") )
 for _item in _office[:7] + _office[9:10]:
 if not isinstance(_item, str):
-raise ValueError, _("This office item must be a "\
+raise ValueError( _("This office item must be a "\
-"string")
+"string") )
 for _item in _office[7:8]:
 if not isinstance(_item, list):
-raise ValueError, _("This office item must be a "\
+raise ValueError( _("This office item must be a "\
-"list")
+"list") )
 _offices.append(Office(_office[0],
 _office[1],
 _office[2],
 _office[3],
 _office[4],
 _office[6],
 _office[7],
 _office[8],
 _office[9]))
 if not isinstance(cif, str):
-raise ValueError, _("The name must be a string")
+raise ValueError( _("The name must be a string") )
 if not isinstance(web, str):
-raise ValueError, _("The web must be a string")
+raise ValueError( _("The web must be a string") )
 if not isinstance(email, str):
-raise ValueError, _("The email must be a string")
+raise ValueError( _("The email must be a string") )
 self.__companys[company_code] = Company(company_code, sumamary, name,
 _offices, cif, web, email)
 def getCompany(self, company_code):
 return self.__companys[company_code]
 def getCompanyKeys(self):
 return self.__companys.keys()
 def addTecInfo(self, ti_code, text, unit):
 if not isinstance(ti_code, str):
-raise ValueError, _("The tecnical info code must be a string")
+raise ValueError( _("The tecnical info code must be a string") )
 if not isinstance(text, str):
-raise ValueError, _("The tecnical info description must be a "\
+raise ValueError( _("The tecnical info description must be a "\
-"string")
+"string") )
 if not isinstance(unit, str):
-raise ValueError, _("The tecnical info unit must be a string")
+raise ValueError( _("The tecnical info unit must be a string") )
 self.__tec_info[ti_code] = [text, unit]
 def hasTecInfo(self, ti_code):
 return ti_code in self.__tec_info
 def getTecInfo(self, ti_code):
 return self.__tec_info[ti_code]
 def setTecnicalInformation(self, record_code, ti_dict):
 """setTecnicalInformation(record_code, ti_dict)
 Sets the tecnical information to a record
 record_code: the record code
 ti_dict: {ti_code : ti_value}
 """
 # TODO: setTecnicalInformation
 pass
 def changeCode(self, record_code, new_record_code):
 """changeCode(self, record_code, new_record_code):
 Change the record code for a new recor code.
 """
 """addLabel(self, record_code, label)
 Add a label to a record
 """
 if not isinstance(label,str):
-raise ValueError, _("The label must be a string")
+raise ValueError( _("The label must be a string") )
 if self.hasRecord(record_code):
 _record = self.__records[record_code]
 _record.addLabel(label)
 if not label in self.__labels:
 self.__labels[label] = [record_code]
 else:
 _codes = self.__labels[label]
 if not record_code in _codes:
 _codes.append(record_code)
 def setParametricSelectComment(self, record_code, comment):
 """setParametricSelectComment(self, record_code, comment)
 Sets Paramtric Record Select Comment
 """
 if not isinstance(record_code, str):
-raise ValueError, _("The record_code code must be a string")
+raise ValueError( _("The record_code code must be a string") )
 if not isinstance(comment, str):
-raise ValueError, _("The parametric select comment must be a "\
+raise ValueError( _("The parametric select comment must be a "\
-"string")
+"string") )
 if not self.hasRecord(record_code):
-print utils.mapping(_("Error: The budget do not have the record "\
+print(utils.mapping(_("Error: The budget do not have the record "\
 "code $1 and can not be added the Parametric select comment: "\
 "$2"),
-(record_code, comment))
+(str(record_code), str(comment))) )
 return
 _record = self.getRecord(record_code)
 if not isinstance(_record, ParametricRecord):
-print utils.mapping(_("Error: The Record $1 is not a "\
+print(utils.mapping(_("Error: The Record $1 is not a "\
 "Parametric Record and can not have Parametric comment"),
-(record_code,))
+(str(record_code),)) )
 else:
 _record.select_comment = comment
 def setParametricSummary(self, record_code, summary):
 """setParametricSummary(self, record_code, summary)
 Sets parametric record summary
 """
 if not isinstance(record_code, str):
-raise ValueError, _("The record_code code must be a string")
+raise ValueError( _("The record_code code must be a string") )
 if not isinstance(summary, str):
-raise ValueError, _("The summary record must be a string")
+raise ValueError( _("The summary record must be a string") )
 if not self.hasRecord(record_code):
-print utils.mapping(_("Error: The budget do not have the record "\
+print(utils.mapping(_("Error: The budget do not have the record "\
 "code $1 and can not be seted the summary: $2"),
-(record_code, summary))
+(str(record_code), str(summary))) )
 return
 _record = self.getRecord(record_code)
 if not isinstance(_record, ParametricRecord):
-print utils.mapping(_("Error: The Record $1 is not a "\
+print(utils.mapping(_("Error: The Record $1 is not a "\
 "Parametric Record and can not have Parametric summary"),
-(record_code,))
+(str(record_code),)) )
 else:
 self.getRecord(record_code).parametric_summary = summary
 def setParametricText(self, record_code, text):
 """setParametricText(self, record_code, text)
 Sets parametric record text
 """
 if not isinstance(record_code, str):
-raise ValueError, _("The record_code code must be a string")
+raise ValueError( _("The record_code code must be a string") )
 if not isinstance(text, str):
-raise ValueError, _("The text record must be a string")
+raise ValueError( _("The text record must be a string") )
 if not self.hasRecord(record_code):
-print utils.mapping(_("Error: The budget do not have the record "\
+print(utils.mapping(_("Error: The budget do not have the record "\
 "code $1 and can not be seted the text: $2"),
-(record_code, text))
+(str(record_code), str(text))) )
 return
 _record = self.getRecord(record_code)
 if not isinstance(_record, ParametricRecord):
-print utils.mapping(_("Error: The Record $1 is not a "\
+print(utils.mapping(_("Error: The Record $1 is not a "\
 "Parametric Record and can not have Parametric text"),
-(record_code,))
+(str(record_code),)) )
 else:
 self.getRecord(record_code).parametric_text = text
 class Office(object):
 """base.Office:
 Description:
 {get/set}Phone
 {get/set}Fax
 {get/set}ContactPerson
 getValues
 """
 __slots__ = ["_Office__officeType",
 "_Office__subname",
 "_Office__address",
 "_Office__postal_code",
 "_Office__town",
 "_Office__country",
 "_Office__phone",
 "_Office__fax",
 "_Office__contact_person",
 ]
 def __getstate__ (self):
 return ( self.__officeType,
 self.__subname,
 self.__address,
 self.__postal_code,
 self.__province,
 self.__country,
 self.__phone,
 self.__fax,
 self.__contact_person)
 def __setstate__(self,tuple):
 self.__officeType = tuple[0]
 self.__subname = tuple[1]
 self.__address = tuple[2]
 self.__postal_code = tuple[3]
 self.province = province
 self.country = country
 self.phone = phone
 self.fax = fax
 self.contact_person = contact_person
 def getOfficeType(self):
 return self.__officeType
 def setOfficeType(self, type_):
 self.__officeType = type_
 def getSubname(self):
 return self.__subname
 def setSubname(self, subname):
 self.__subname = subname
 def getAddress(self):
 return self.__address
 def setAddress(self, address):
 self.__address = address
 def getPostalCode(self):
 return self.__postal_code
 def setPostalCode(self, postal_code):
 self.__postal_code = postal_code
 def getTown(self):
 return self.__town
 def setTown(self, town):
 self.__town = town
 def getProvince(self):
 return self.__province
 def setProvince(self, province):
 self.__province = province
 def getCountry(self):
 return self.__country
 def setCountry(self, country):
 self.__country = country
 def getPhone(self):
 return self.__phone
 def setPhone(self, phone):
 self.__phone = phone
 def getFax(self):
 return self.__fax
 def setFax(self, fax):
 self.__fax = fax
 def getContactPerson(self):
 return self.__contact_person
 def setContactPerson(self, contact_person):
 self.__contact_person = contact_person
 def getValues(self):
 return {"officeType": self.officeType,
 "subname": self.subname,
 "address": self.address,
 "postal code": self.postal_code,
 "country": self.country,
 "phone": self.phone,
 "fax": self.fax,
 "contact person": self.contact_person,
 }
 officeType = property(getOfficeType, setOfficeType, None,
 """Type of office
 """)
 subname = property(getSubname, setSubname, None,
 """Name of office
 """Contact Person
 """)
 values = property(getValues, None, None,
 """Dictionary with comapany values
 """)
 class Company(object):
 """base.Company:
 Description:
 {get/set}Cif
 {get/set}Web
 {get/set}Email
 getValues
 """
 __slots__ = ["_Company__code",
 "_Company__summary",
 "_Company__name",
 "_Company__offices",
 "_Company__cif",
 "_Company__web",
 "_Company__email",
 ]
 def __getstate__ (self):
 return ( self.__code,
 self.__summary,
 self.__name,
 self.__offices,
 self.__cif,
 self.__web,
 self.__email)
 def __setstate__(self,tuple):
 self.__code = tuple[0]
 self.__summary = tuple[1]
 self.__name = tuple[2]
 self.__offices = tuple[3]
 self.name = name
 self.offices = offices
 self.cif = cif
 self.web = web
 self.email = email
 def getCode(self):
 return self.__code
 def setCode(self, code):
 self.__code = code
 def getSummary(self):
 return self.__summary
 def setSummary(self, summary):
 self.__summary = summary
 def getName(self):
 return self.__name
 def setName(self, name):
 self.__name = name
 def getOffices(self):
 return self.__offices
 def setOffices(self, offices):
 self.__offices = offices
 def getCif(self):
 return self.__cif
 def setCif(self, cif):
 self.__cif = cif
 def getWeb(self):
 return self.__web
 def setWeb(self, web):
 self.__web = web
 def getEmail(self):
 return self.__email
 def setEmail(self, email):
 self.__email = email
 def getValues(self):
 return {"code": self.code,
 "summary": self.summary,
 "name": self.name,
 "cif": self.cif,
 "web": self.web,
 "email": self.email}
 code = property(getCode, setCode, None,
 """Company code
 """)
 summary = property(getSummary, setSummary, None,
 """Company summary
 """Email
 """)
 values = property(getValues, None, None,
 """Dictionary with comapany values
 """)
 class File(object):
 """base.Company:
 Description:
 {get/set}Name
 {get/set}FileType
 {get/set}Description
 getValues
 """
 __slots__ = ["_File__name",
 "_File__fileType",
 "_File__description",
 ]
 def __getstate__ (self):
 return (self.__name,
 self.__description,
 self.__fileType,
 )
 def __setstate__(self,tuple):
 self.__name = tuple[0]
 self.__fileType = tuple[1]
 self.__description = tuple[2]
 def __init__(self, name, type_, description):
 self.name = name
 self.fileType = type_
 self.description = description
 def getName(self):
 return self.__name
 def setName(self, name):
 self.__name = name
 def getFileType(self):
 return self.__fileType
 def setFileType(self, type_):
 self.__fileType = type_
 def getDescription(self):
 return self.__description
 def setDescription(self, description):
 self.__description = description
 def getValues(self):
 return {"name": self.name,
 "fileType": self.fileType,
 "description": self.description,
 }
 name = property(getName, setName, None,
 """File name
 """)
 fileType = property(getFileType, setFileType, None,
 """FileType
 """File description
 """)
 values = property(getValues, None, None,
 """Dictionary with file values
 """)
 class RecordType(object):
 """base.RecordType:
 Description:
 __init__(self, hierarchy, type, subtype)
 {get/set}Hierarchy
 {get/set}Type
 {get/set}Subtype
 """
 __slots__ = ["_RecordType__hierarchy",
 "_RecordType__type",
 "_RecordType__subtype",
 ]
 def __getstate__ (self):
 return (self.__hierarchy,
 self.__type,
 self.__subtype,
 )
 def __setstate__(self,tuple):
 self.__hierarchy = tuple[0]
 self.__type = tuple[1]
 self.__subtype = tuple[2]
 def __init__(self, hierarchy, type_, subtype):
 self.hierarchy = hierarchy
 self.type = type_
 self.subtype = subtype
 def getHierarchy(self):
 return self.__hierarchy
 def setHierarchy(self, hierarchy):
 if not hierarchy in [-1, 0 , 1 ,2, ""]:
-raise ValueError, utils.mapping(_("Invalid Hierarchy ($1) "\
+raise ValueError( utils.mapping(_("Invalid Hierarchy ($1) "\
-"The hierarchy must be -1, 0, 1, 2"), (str(hierarchy),))
+"The hierarchy must be -1, 0, 1, 2"), (str(hierarchy),)) )
 elif hierarchy == "":
-print "Hierarchy temporarily set to an empty string"
+print("Hierarchy temporarily set to an empty string")
 #TODO Check empty Hierarchy in Generic.fiebdc.Read._testBudget
 self.__hierarchy = hierarchy
 def getType(self):
 return self.__type
 def setType(self, type_):
 if not type_ in  ["", 0, 1, 2, 3] :
-raise ValueError, utils.mapping(_("Invalid type ($1),"\
+raise ValueError( utils.mapping(_("Invalid type ($1),"\
-"the type must be (empty string,0,1,2,3)"),(str(type_)),)
+"the type must be (empty string,0,1,2,3)"),(str(type_)),) )
 self.__type = type_
 def getSubtype(self):
 return self.__subtype
 def setSubtype(self, subtype):
 if not subtype in ["", "OB", "PU", "EA", "EU", "EC", "EF", "PA", "H",
 "Q", "%", "MC", "MCr", "MM", "MS", "ME", "MCu",
 "Mal","ML","M"]:
-raise ValueError, utils.mapping(_("Invalid subtype ($1), The "\
+raise ValueError( utils.mapping(_("Invalid subtype ($1), The "\
 "subtype must one in (empty string, EA, "\
 "EU, EC, EF, OB, PA, PU, H, Q, %, MC, MCr, "\
-"MM, MS, ME, MCu, MAl, ML, M)"), (str(subtype),))
+"MM, MS, ME, MCu, MAl, ML, M)"), (str(subtype),)) )
 self.__subtype = subtype
 hierarchy = property(getHierarchy, setHierarchy, None,
 """Record Hierarchy
 -1 -> temporarily unfixed
 0 -> root
 1 -> Chapter/Subchapter

Mercurial > pyarq-presupuestos

comparison Generic/base.py @ 23:65e7ae0d0e63