pyarq-presupuestos: Generic/base.py comparison

comparison Generic/base.py @ 1:2ac1551ad2ab version 0.0.0

add code

author	Miguel Ángel Bárcena Rodríguez <miguelangel@obraencurso.es>
date	Sun, 31 Oct 2010 20:07:33 +0100
parents
children	a7b9f7e7dfa4

comparison

equal deleted inserted replaced

-:a1703c4f2990
+:2ac1551ad2ab
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+## File base.py
+## This file is part of pyArq-Presupuestos.
+##
+## Copyright (C) 2010 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
+## (at your option) any later version.
+##
+## pyArq-Presupuestos is distributed in the hope that it will be useful,
+## but WITHOUT ANY WARRANTY; without even the implied warranty of
+## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+## GNU General Public License for more details.
+##
+## You should have received a copy of the GNU General Public License
+## along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"""base module
+In this module are defined the data structures in the
+classes:
+* Record: data of each record
+* ParamentricRecord: data of each parametric record
+* Decomposition: data of the decomposition of each record
+* Measure: data of the measure of each record
+* MeasureLine: each measure line data
+* Decimals: data of the decimal places of all the numbers in a budget
+* Sheet: data of the sheet of conditions of a budget
+* Budget: all data of a budget
+* Company: company data
+* Office: company office data
+* File: file data
+* RecordType: Record type data
+schema:
+* Budget:
++-- __records: dictionary records { code : Record }
+* Record:
++-- code: record code
++-- synonyms: list of synonym codes
++-- hierarchy: A integer number:
+0 -> root
+1 -> Chapter/Subchapter
+2 -> Other
++-- unit:  unit of measure of the record
++-- summary: Short description of the record
++-- prices: List of Prices/Dates
++-- type
++-- subtype
+"type" and "subtype":
+0 Without classifying
+EA  Auxiliary element
+EU  Unitary element
+EC  Complex element
+EF  Functional element
+OB  Construction site
+PA  Cost overrun
+PU  Unitary budget
+1 Labourforce
+H   Labourforce
+2 Machinery and auxiliary equipment
+Q   Machinery
+%   Auxiliary equipment
+3 Building materials
+MC  Cement
+MCr Ceramic
+MM  Wood
+MS  Iron and steel
+ME  Energy
+MCu Copper
+MAl Aluminium
+ML  Bonding agents
+M   Others materials
+Hierarchy         type  subtype
+0->root         -> 0 -> None,OB
+1->[sub]chapter -> 0 -> None,PU
+2->Other        -> 0 -> None,EA,EU,EC,EF,PA
+1 -> None,H
+2 -> None,Q,%
+3 -> None,MC,MCr,MM,MS,ME,MCu,Mal,ML,M
++-- parents: List of parent codes
++-- children: list of Decomposition
+* Decomposition:
++-- position: Position of the child in the parent descomposition
+TODO: change this: the position of the record in the budget
++-- code: child record code
++-- budget: list of budget and amended budget measures
+* Measure:
++-- measure: Total result of measure
++-- lines: List of measure lines
+* MeasureLine:
++-- type: Line type:
+empty string -> Normal
+1 -> Parcial Subtotal
+2 -> Accumulated Subtotal
+3 -> Formula, the comment is a formula.
++-- comment: Can be a descriptive text or a formula
+Valid Operator: '(', ')', '+', '-', '*', '/' and
+'^'
+Valid variable: 'a', 'b', 'c','d' y 'p'
+(Pi=3.1415926)
++-- units: Number of Units (a)
++-- length: length (b)
++-- width: width (c)
++-- height: height (d)
++-- label: Record Identifiers that are used by some measure
+programs
++-- factor: Factor
++-- yield_: Yield
++-- certification: list of certifications for months measures
+* Measure
++-- real_cost: list of real cost of construction for months
+measures
+* Measure
++-- cost_goals: list of cost goals of construction for months
+measures
+* Measure
++-- cost_planned: list of costs planned and amended cost planned
+measures
+* Measure
++-- text: Long Description of the record
++-- sheet: Sheet of conditions object
+* Sheet:
++-- sheet_dict:
+{ <Field key> : { <Section key> : <Paragraph key>}}
++-- files:  List of file object
++-- file
+* Name
+* Type
+* Description
++-- __synonyms: synonyms dictionary. TODO
++-- __root: root record code
++-- __decimals: decimals dictionay = { int : Decimals }
+* 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
+measure lines.
+Default: 2 decimal places.
++-- DS: Number of decimal places of the total sum of a measure.
+Default: 2 decimal places.
++-- DFP: Number of decimal places of the yield factor in a
+decomposition of a budget record.
+Default: 3 decimal places.
++-- DFC: Number of decimal places of the yield factor in a
+decomposition of a chapter or subchapter, and in its measure lines.
+Dafault: 3 decimal places.
++-- DFUO: Number of decimal places of the yield factor in a
+decomposition of a unit of work.
+Default: 3 decimal places.
++-- DFA: Number of decimal places of the yield factor in a
+decomposition of a Auxiliary element.
+Default: 3 decimal places.
++-- DRP: Number of decimal places of the yield in a decomposition
+of a budget record.
+Number of decumal places of the result of the multiplication of
+the factor and the yield in a decompositon of a budget.
+Default: 3 decimal places.
++-- DRC: Number of decimal places of the yield (or measure) in a
+decomposition of a chapter or subchapter.
+Number of decimal places of the result of the multiplictaion of
+the yield (or measure) and the factor in a decomposition of a
+chapter or subcharter.
+Default: 3 decimal places.
++-- DRUO: Number of decimal places of the yield in a decomposition of a
+unit of work.
+Decimal places of the result of the multiplication of the yield
+and the factor in a descomposition of a unit of work.
+Default: 3 decimal places.
++-- DRA: Number of decimal places of the yield in a decompositon of a
+auxiliar element.
+Number of decimal places of the result of the multiplication of
+the yield and the factor in a descomposition of a auxilar element.
+Default: 3 decimal places.
++-- DP: Number of decimal places of the price of a budget.
+Default: 2 decimal places.
++-- DC: Number of decimal places of the price of a chapter or
+subchapter.
+Default: 2 decimal places.
++-- DUO: Number of decimal places of the price of a unit of work.
+Default: 2 decimal places.
++-- DEA: Number of decimal places of the price of a auxiliar element.
+Default: 2 decimal places.
++-- DES: Number of decimal places of the price of the simple elements.
+Default: 2 decimal places.
++-- DIR: Number of decimal places of the resulting amount to multiply
+the total yield and the price of the elements of a unit of work.
+(When there are not measures)
++-- DIM: Number of decimal places of the resulting amount to multiply
+the total yield and the price of the elements of a unit of work.
+(When there are measures)
++-- DIRC: Number of decimal places of the resulting amount to multiply
+the total yield and the price of the elements of a budget, chapter
+or a subchapter.(When there are not measures)
++-- DIMC: Number of decimal places of the resulting amount to multiply
+the total yield and the price of the elements of a budget, chapter
+or a subchapter. (When there are measures)
++-- DCD: Number of decimal places ot the resulting amount to sum the
+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.
++-- __percentages: percentages dictionary:
+{ "CI"  : "",
+"GG"  : "",
+"BI"  : "",
+"BAJA": "",
+"IVA" : ""}
++-- __file_owner
++-- __title_list: titles list: [ "Header", ["Title1", "Title2", ... ] ]
++-- __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 }
+* Comapany:
++-- code: company code
++-- summary: short name
++-- name: long name
++-- offices: List of offices:
+* Office:
++-- type: office type
+"C"  Central office.
+"D"  Local Office.
+"R"  Performer.
++-- subname: Office name
++-- address: Ofiice address
++-- postal_code: postal code
++-- town: town
++-- province: province/state
++-- country: country
++-- phone: list of phone numbers
++-- fax: list of fax numbers
++-- contact_person: Contact person in the office
++-- cif: CIF
++-- web: web page
++-- email: email
+"""
+# Modules
+import re
+import datetime
+import os
+# pyArq-Presupuestos modules
+from Generic import fiebdc
+from Generic import utils
+class Record(object):
+"""base.Record:
+Description:
+Record object
+Constructor:
+base.Record(code, synonyms, hierarchy, unit, summary, prices, type,
+subtype, text="")
+Ancestry:
++-- object
++-- Record
+Atributes:
+"code": Code string
+"recordType": RecordType object
+"synonyms": List of synonym codes.
+"parents":List of parent codes
+"children": Decomposition list,
+list of "Decomposition" instances
+"unit": measure unit of the record
+"summary": Short description of the record
+"prices": List of prices/dates
+"text": Long Description of the record
+"sheet": Sheet of conditions object
+"files": List of file object
+"labels": List of record labels
+Methods:
+__getstate__(self)
+__setstate__(self, tuple)
+__init__(self, filename=None, budget=None)
+{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
+{get/set}children
+appendChild
+{get/set}Text
+{get/set}Sheet
+{get/set}Files
+addFile
+{get/set}Labels
+addLabel
+"""
+__slots__ = ["_Record__code", "_Record__synonyms",
+"_Record__recordType", "_Record__unit",
+"_Record__summary", "_Record__prices",
+"_Record__parents", "_Record__children",
+"_Record__text", "_Record__sheet",
+"_Record__files", "_Record__labels"]
+def __getstate__(self):
+return (self.__code, self.__synonyms, self.__recordType,
+self.__unit, self.__summary, self.__prices,
+self.__parents, self.__children, self.__text,
+self.__sheet, self.__files, self.__labels)
+def __setstate__(self, tuple):
+self.__code = tuple[0]
+self.__synonyms = tuple[1]
+self.__recordType = tuple[2]
+self.__unit = tuple[3]
+self.__summary = tuple[4]
+self.__prices = tuple[5]
+self.__parents = tuple[6]
+self.__children = tuple[7]
+self.__text = tuple[8]
+self.__sheet = tuple[9]
+self.__files = tuple[10]
+self.__labels = tuple[11]
+def __init__(self, decimals, code, synonyms, hierarchy, unit, summary,
+prices, type, subtype, parents=[], text=""):
+self.code = code
+self.synonyms = synonyms
+self.recordType = (hierarchy, type, subtype)
+self.unit = unit
+self.summary = summary
+self.setPrices(prices, decimals)
+self.parents = parents
+self.children = []
+self.text = text
+self.sheet = Sheet()
+self.files = []
+self.labels = []
+def getCode(self):
+return self.__code
+def setCode(self, code):
+"""setCode(self,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),))
+self.__code = code
+def getSynonyms(self):
+return self.__synonyms
+def setSynonyms(self,synonyms):
+"""setSynonyms(self,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, " \
+"code: $2"), (str(synonyms), self.__code))
+for code in synonyms:
+if not utils.is_valid_code(code)[0]:
+raise ValueError, utils.mapping(_("Invalid Code in synomyms "\
+"list ($1) code: $2"), (str(code), self.__code))
+self.__synonyms = synonyms
+def getRecordType(self):
+return self.__recordType
+def setRecordType(self, recordType):
+"""setRecordType(self, recordType)
+Set the record type.
+recordType (hierarchy, type,subtype)
+hierarchy must be -1, 0, 1 or 2
+type must be 0, 1, 2, 3 or a empty string
+subtype must be EA, EU, EC, EF, OB, PA, PU, H, Q, %, MC, MCr,
+MM, MS, ME, MCu, MAl, ML, M, or a empty string
+"""
+_recordType = RecordType(recordType[0],recordType[1],recordType[2])
+self.__recordType = _recordType
+def getUnit(self):
+return self.__unit
+def setUnit(self,unit):
+"""setUnit(self,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"),
+(str(unit), self.__code))
+self.__unit = unit
+def getSummary(self):
+return self.__summary
+def setSummary(self,summary):
+"""setSummary(self,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: "\
+"$1"), (str(summary), self.__code))
+self.__summary = summary
+def getPrices(self):
+return self.__prices
+def setPrices(self, prices, decimals):
+"""setPrice(self, 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"),
+(str(prices), 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)
+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"\
+" with two items: $2"), (str(price_date), self.__code))
+_price = price_date[0]
+_date = price_date[1]
+if not isinstance(_price, float):
+raise TypeError, utils.mapping(_("Price must be a float "\
+"number: $1"), (str(_price),))
+_D = 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"
+% 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")
+return self.__prices[index_price][1]
+def getParents(self):
+return self.__parents
+def setParents(self,parents):
+"""setParents(self,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"),
+(str(parents), self.__code))
+for parent in parents:
+if not utils.is_valid_code(parent)[0]:
+raise ValueError, utils.mapping(_("Invalid parent code ($1) " \
+"in the record: $2"), (str(padre), self.__code))
+self.__parents = parents
+def appendParent(self, parent):
+"""appendParent(self, 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) " \
+"in the record: $2"), (str(parent), self.__code))
+self.__parents.append(parent)
+def getchildren(self):
+return self.__children
+def setchildren(self,children):
+"""setchildren(self,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, "\
+"record: $2"), (str(children), self.__code))
+for _child in children:
+if not isinstance(_child, Decomposition):
+raise ValueError, utils.mapping(_("child ($1) must be a "\
+"Decomposition object, record: $2"),
+(str(_child), 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):
+for _measure in _measure_list:
+_measurerecordCode = _record_code
+self.__children = children
+def appendChild(self, child_code, decimals, factor=0.0, yield_=0.0,
+measure=0.0, measure_list=[], type ="", label=""):
+"""appendChildren(self, child_code, factor=0.0, yield_=0.0,
+measure=0.0, measure_list=[], type ="", label=""))
+position:
+child_code:
+factor:
+yield_:
+measure:
+measure_list:
+type:
+label:
+Append a child to the list of children
+"""
+_measure = Measure(decimals, self.recordType,
+measure, [], label, factor, yield_)
+if len(measure_list) > 0:
+measure.buildMeasure(_measure, measure_list, type, decimals,
+self.recordType)
+_position = len(self.__children)
+_child = Decomposition(_position, child_code, [_measure])
+self.__children.append(_child)
+return _child
+def getText(self):
+return self.__text
+def setText(self,text):
+"""setText(self,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, "\
+"record: $2"), (str(text), self.__code))
+self.__text = text
+def getSheet(self):
+return self.__sheet
+def setSheet(self, sheet):
+"""setSheet(self, sheet)
+Sets the sheet of condition object
+"""
+if not isinstance(sheet, Sheet):
+raise ValueError, _("sheet must be a Sheet instance")
+self.__sheet = sheet
+def getFiles(self):
+return self.__files
+def setFiles(self, files):
+"""setFiles(self, 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"),
+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")
+_file = File(file_path, type, description)
+_files.append(_file)
+else:
+raise ValueError, utils.mapping(_(
+"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)
+Add a file to a record instance
+"""
+if not os.path.exists(file_path):
+raise ValueError, _("Incorrect path")
+_name = os.path.basename(file_path)
+_isin = False
+for _ofile in self.__files:
+if _ofile.name == _name:
+_isin = True
+if not _isin:
+_file = File(_name, type, description)
+self.__files.append(_file)
+def getLabels(self):
+return self.__labels
+def setLabels(self, labels):
+"""setLabels(self, labels)
+Sets the labels list of a record
+"""
+if not isinstance(labels, 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")
+self.__labels = _labels
+def addLabel(self, label):
+"""addLabel(self, label)
+Add a label to a record instance
+"""
+if not isinstance(label, str):
+raise ValueError, _("Label must be a string")
+if not label in self.__labels:
+self.__labels.append(label)
+recordType = property(getRecordType, setRecordType, None,
+"""Record Type object
+""")
+code = property(getCode, setCode, None,
+"""Record code
+""")
+synonyms = property(getSynonyms, setSynonyms, None,
+"""List of codes synonyms of the code
+""")
+unit = property(getUnit,setUnit, None,
+"""Measure Unit of the record
+""")
+summary = property(getSummary, setSummary, None,
+"""Short description of the record
+""")
+prices = property(getPrices, None, None,
+"""List of Price/Date
+""")
+parents = property(getParents, setParents, None,
+"""List of codes of the records which the record is in
+its decomposition
+""")
+children = property(getchildren, setchildren, None,
+"""List of Decompositon intances""")
+text = property(getText, setText, None,
+"""Long description of the record""")
+sheet = property(getSheet, setSheet, None,
+"""Sheet of conditions object""")
+files = property(getFiles, setFiles, None,
+"""File list""")
+labels = property(getLabels, setLabels, None,
+"""Label list""")
+class ParametricRecord(Record):
+"""base.ParametricRecord:
+Description:
+Parametric Record object
+Constructor:
+base.ParametricRecord(code, synonyms, hierarchy, unit, summary, prices,
+type, subtype, text="")
+Ancestry:
++-- object
++-- Record
++-- ParametricRecord
+Atributes:
+Methods:
+"""
+__slots__ = ["_ParametricRecord__budget",
+"_ParametricRecord__code", "_ParametricRecord__synonyms",
+"_ParametricRecord__hierarchy", "_ParametricRecord__unit",
+"_ParametricRecord__summary", "_ParametricRecord__prices",
+"_ParametricRecord__type", "_ParametricRecord__subtype",
+"_ParametricRecord__parents", "_ParametricRecord__children",
+"_ParametricRecord__text", "_ParametricRecord__sheet",
+"_ParametricRecord__files", "_ParametricRecord__labels",
+"_ParametricRecord__parameters",
+"_ParametricRecord__select_comment",
+"_ParametricRecord__vars",
+"_ParametricRecord__parametric_summary",
+"_ParametricRecord__parametric_text",]
+def __getstate__(self):
+return (self.__budget, self.__code, self.__synonyms, self.__hierarchy,
+self.__unit, self.__summary, self.__prices, self.__type,
+self.__subtype, self.__parents, self.__children, self.__text,
+self.__sheet, self.__files, self.__labels, self.__parameters,
+self.__select_comment, self.__vars,
+self.__parametric_summary, self.__parametric_text)
+def __setstate__(self, tuple):
+self.__budget = tuple[0]
+self.__code = tuple[1]
+self.__synonyms = tuple[2]
+self.__hierarchy = tuple[3]
+self.__unit = tuple[4]
+self.__summary = tuple[5]
+self.__prices = tuple[6]
+self.__type = tuple[7]
+self.__subtype = tuple[8]
+self.__parents = tuple[9]
+self.__children = tuple[10]
+self.__text = tuple[11]
+self.__sheet = tuple[12]
+self.__files = tuple[13]
+self.__labels = tuple[14]
+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=[], text=""):
+Record.__init__(self, budget, code, synonyms, hierarchy, unit, summary,
+prices, type, subtype, parents=[], text="")
+self.__parameters = {}
+self.__select_comment = ""
+self.__vars = {}
+self.parametric_summary = ""
+self.parametric_text = ""
+def getParameter(self, parameter):
+if parameter in self.__parameters:
+return self.__parameters[parameter]
+else:
+return None
+def setParameter(self, parameter, parameter_list):
+self.__parameters[parameter] = parameter_list
+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
+def setVar(self, var, var_list):
+self.__vars[var] = var_list
+def getParametricSummary(self):
+return self.__parametric_summary
+def setParametricSummary(self, parametric_summary):
+self.__parametric_summary = parametric_summary
+def getParametricText(self):
+return self.__parametric_text
+def setParametricText(self, parametric_text):
+self.__parametric_text = parametric_text
+parameter = property(getParameter, setParameter, None,
+"""Record parameter
+""")
+select_comment = property(getSelectComment, setSelectComment, None,
+"""Seclect comment
+""")
+var = property(getVar, setVar, None,
+"""Record var
+""")
+parametric_summary = property(getParametricSummary, setParametricSummary,
+None,
+"""Parametric summary
+""")
+parametric_text = property(getParametricText, setParametricText, None,
+"""Seclect comment
+""")
+class Decomposition(object):
+"""base.Decomposition:
+Description:
+Decomposition object
+Constructor:
+base.Decomposition(position, code, budgetMeasures, certification=None,
+real_cost=None, cost_goals=None, cost_planned=None)
+Ancestry:
++-- object
++-- Decomposition
+Atributes:
+"position": the position of the child record in the parent record
+"code": Record code.
+Measures:
+"budgetMeasures": list of budget and Amended budget measures
+"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.__real_cost = tuple[4]
+self.__cost_goals = tuple[5]
+self.__cost_planned = tuple[6]
+def __init__(self, position, code, budgetMeasures, certification=None,
+real_cost=None, cost_goals=None, cost_planned=None):
+self.position = position
+self.code = code
+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")
+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")
+for _measure in budgetMeasures:
+if not isinstance(_measure, Measure):
+raise ValueError, _("BudgetMeasures item must be a Measure "/
+"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")
+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")
+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")
+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")
+self.__cost_planned = cost_planned
+position = property(getPosition, setPosition, None,
+"""Postion of the record in the budget
+""")
+code = property(getCode, setCode, None,
+"""Record code
+""")
+budgetMeasures = property(getBudgetMeasures, setBudgetMeasures, None,
+"""list of budget and Amended budget measures
+""")
+certification = property(getCertification, setCertification,None,
+""" list of certifications by months measures
+""")
+real_cost = property(getRealCost, setRealCost, None,
+""" list of real cost of construction for months measures
+""")
+cost_goals = property(getCostGoals, setCostGoals, None,
+""" list of cost goals of construction for months measures
+""")
+cost_planned = property(getCostPlanned, setCostPlanned, None,
+""" list of costs planned and amended cost planned measures
+""")
+class Measure(object):
+"""base.Measure:
+Description:
+Measure object
+Constructor:
+base.Measure(decimals, recordType, measure, lines,
+label, factor, yield_)
+Ancestry:
++-- object
++-- Measure
+Atributes:
+"measure": Total result of measure.
+"lines": List of measure lines, List of LineM instances.
+"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()
+setFactor(factor, decimals, recordType)
+getYield()
+setYield(yield_, decimals, recordType)
+getFixed()
+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.setFactor(factor, decimals, recordType)
+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 "\
+"number. Type: $1"), (type(measure),))
+# TODO: test after
+_DS = 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")
+for _line in lines:
+if not isinstance(_line, MeasureLine):
+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 "\
+"|$1|"), (factor,))
+# TODO: test after
+_DF = 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")
+# TODO: test after
+_DR = 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")
+self.__fixed = fixed
+self.updateYield(decimals)
+def getFixed(self):
+return self.__fixed
+measure = property(getMeasure, None, None,
+"""Total result of the measure
+""")
+lines = property(getLines, setLines, None,
+"""List of measure lines, List of "MeasureLine" instances
+""")
+label = property(getLabel, setLabel, None,
+"""Record identifiers that are used in some measure programs
+""")
+factor = property(getFactor, None, None,
+"""Factor
+""")
+yield_ = property(getYield, None, None,
+"""Yield of a record
+""")
+fixed = property(getFixed, setFixed,None,
+"""If fixed is True the yield is not calculated from measure
+""")
+def buildMeasure(self, list_lines, type, decimals, recordType):
+"""setMeasure(self, list_lines, type, decimals)
+list_lines: list of measure lines
+[ [linetype, comment, units, length, width, height, formula], ... ]
+linetype:
+#-#empty string -> Normal
+0 -> Normal
+1 -> Parcial Subtotal
+2 -> Accumulated Subtotal
+3 -> Formula
+comment: comment string
+units: Number of Units (a)
+length: Length (b)
+width: Width (c)
+height: Height (d)
+formula: Can be a formula or a empty string
+Valid Operator: '(', ')', '+', '-', '*', '/' and '^'
+Valid variable: 'a', 'b', 'c','d' and 'p' (Pi=3.1415926)
+type: type of action
+M: Set measure
+A: Add measure
+decimal: budget decimals object
+Sets the measurelines for a record
+"""
+# TODO: calcutate measure from lines
+_parcial = 0
+_total = 0
+_lines = []
+for _line in list_lines:
+_type, _comment = _line[0], _line[1]
+_units, _length = _line[2], _line[3]
+_width, _height = _line[4], _line[5]
+_formula = _line[6]
+_measure_line = MeasureLine(decimals, _type, _comment, _units,
+_length, _width, _height, _formula)
+_lines.append(_measure_line)
+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"),
+(type,))
+self.calculateMeasure(decimals, recordType)
+def calculateMeasure(self, decimals, recordType):
+#TODO: round acumulated_subtotal and parcial_subtotal
+if len(self.lines) > 0:
+_acumulated_total = 0.0
+_parcial_total = 0.0
+for line in self.lines:
+_parcial = line.parcial
+_acumulated_total += _parcial
+if line.lineType == 2:
+line.setAcumulatedSubtotal(_acumulated_total, decimals)
+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)
+self.updateYield(decimals, recordType)
+def updateYield(self, decimals, recordType):
+if not self.fixed:
+self.setYield(self.measure, decimals, recordType)
+class MeasureLine(object):
+"""base.MeasureLine:
+Description:
+MeasureLine object
+Constructor:
+base.MeasureLine(budget, type, comment, units, length, width, height,
+formula)
+Ancestry:
++-- object
++-- MeasureLine
+Atributes:
+"lineType": Line type:
+#-#empty string -> Normal
+0 -> Normal
+1 -> Parcial Subtotal
+2 -> Accumulated Subtotal
+3 -> Formula, the comment is a formula.
+"comment": Descriptive text string
+"units": Number of Units (a)
+"length": length (b)
+"width": Width (c)
+"height": Height (d)
+"formula": can be a valid formula or a empty string
+Valid Operator: '(', ')', '+', '-', '*', '/' and '^'
+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}Height
+{get/set}Formula
+getParcial
+{get/set}ParcialSubtotal
+{get/set}AcumulatedSubtotal
+calculateParcial
+eval_formula
+"""
+__slots__ = ["_MeasureLine__lineType",
+"_MeasureLine__comment",
+"_MeasureLine__units",
+"_MeasureLine__length",
+"_MeasureLine__width",
+"_MeasureLine__height",
+"_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.lineType = type
+self.comment = comment
+self.setUnits(units, decimals)
+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 "\
+"float number. Parcial: $1"), (str(parcial_subtotal),))
+_DS = 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 "\
+"a float number. Parcial: $1"),
+(str(acumulated_subtotal),))
+_DS = decimals.DS
+acumulated_subtotal = round(acumulated_subtotal, _DS)
+self.__acumulated_subtotal = acumulated_subtotal
+def calculateParcial(self, decimals):
+_DS = 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
+else:
+_a = 0.0
+if isinstance(self.length, float):
+_b = self.length
+else:
+_b = 1.0
+if isinstance(self.width, float):
+_c = self.width
+else:
+_c = 1.0
+if isinstance(self.height, float):
+_d = self.height
+else:
+_d = 1.0
+_parcial =  _a * _b  * _c * _d
+else:
+_parcial = self.eval_formula()
+_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)"),
+(str(type),))
+self.__lineType = type
+def setComment(self, comment):
+if not isinstance(comment, str):
+raise ValueError, utils.mapping(_("Measure Comment must be a "\
+"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)"),
+(str(units),))
+_DN = 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)"),
+(str(units),))
+_DD = 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)"),
+(str(units),))
+_DD = 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)"),
+(str(height),))
+_DD = 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 "\
+"string ($1)"), (str(formula),))
+if re.match(".*[^0123456789\.()\+\-\*/\^abcdp ].*", formula):
+raise ValueError, utils.mapping(_("There is invalid characters"\
+"in formula ($1)"), (str(formula),))
+self.__formula = formula
+try:
+self.calculateParcial(decimals)
+except AttributeError:
+pass
+lineType = property(getLineType, setLineType, None,
+"""Type of measure line
+""")
+comment = property(getComment, setComment, None,
+"""Text
+""")
+units = property(getUnits, None, None,
+"""Number of units
+""")
+length = property(getLength, None, None,
+"""Length measure
+""")
+width = property(getWidth, None, None,
+"""Width measure
+""")
+height = property(getHeight, None, None,
+"""Height measure
+""")
+formula = property(getFormula, None, None,
+"""Formula
+""")
+parcial = property(getParcial, None, None,
+"""result of measure line
+""")
+acumulated_subtotal = property(getAcumulatedSubtotal,
+None, None,
+"""Acumulated subtotal
+""")
+parcial_subtotal = property(getParcialSubtotal,
+None, None,
+"""Parcial subtotal
+""")
+def eval_formula(self):
+"""eval_formula()
+formula:
+Valid Operator: '(', ')', '+', '-', '*', '/' and '^'
+Valid variable: 'a', 'b', 'c','d'y 'p' (Pi=3.1415926)
+units: Number of Units (a)
+length: Length (b)
+width: Width (c)
+height: Height (d)
+Evals the formula and return the result
+"""
+formula = self.formula
+a = self.units
+b = self.length
+c = self.width
+d = self.height
+if a == "": a = 0.0
+if b == "": b = 0.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")
+try:
+b = float(b)
+except:
+raise ValueError, _("'b' value must be a float number")
+try:
+c = float(c)
+except:
+raise ValueError, _("'c' value must be a float number")
+try:
+d = float(d)
+except:
+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("-", " - ")
+formula = formula.replace("*", " * ")
+formula = formula.replace("/", " / ")
+formula = formula.replace("^", " ** ")
+formula = formula.replace("(", " ( ")
+formula = formula.replace(")", " ) ")
+formula = formula.replace("a", str(a))
+formula = formula.replace("b", str(b))
+formula = formula.replace("c", str(c))
+formula = formula.replace("d", str(d))
+formula = formula.replace("p", "3.1415926")
+_list_formula = formula.split(" ")
+_formula2 = ""
+for oper in _list_formula:
+try:
+_float_oper= str(float(oper))
+_formula2 = _formula2 + _float_oper
+except ValueError:
+_formula2 = _formula2 + oper
+_g ={"__builtins__":{}}
+try:
+return eval(_formula2, _g)
+except:
+raise ValueError, _("Invalid formula")
+class Decimals(object):
+"""base.Decimals:
+Description:
+Decimals object
+Constructor:
+base.Decimals(DN=2, DD=2, DSP=2, DS=2,
+DFC=3, DFPU=3, DFUO=3, DFA=3,
+DRP=3, DRC=3, DRUO=3, DRA=3,
+DP=2, DC=2, DPU=2, DUO=2, DEA=2, DES=2,
+DIR=2, DIM=2, DIRC=2, DIMC=2, DCD=2,
+DIVISA="EUR")
+Ancestry:
++-- object
++-- Decimals
+Atributes:
+"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
+measure lines.
+Default: 2 decimal places.
+"DSP": Number of decimal places of the subtotal of a measure.
+Default: 2 decimal places.
+"DS": Number of decimal places of the total sum of a measure.
+Default: 2 decimal places.
+"DFC": Number of decimal places of the yield factor in a decomposition
+of a chapter or subchapter.
+Dafault: 3 decimal places.
+"DFPU": Number of decimal places of the yield factor in a decomposition
+of a unitary budget.
+Default: 3 decimal places.
+"DFUO": Number of decimal places of the yield factor in a decomposition
+of a unit of work.
+Default: 3 decimal places.
+"DFA": Number of decimal places of the yield factor in a decomposition
+of a Auxiliary element.
+Default: 3 decimal places.
+"DRC": Number of decimal places of the yield in a
+decomposition of a chapter or subchapter.
+Number of decimal places of the result of the multiplictaion of
+the yield (or measure) and the factor in a decomposition of a
+chapter or subcharter.
+Default: 3 decimal places.
+"DRPU": Number of decimal places of the yield in a decomposition
+of a unitary budget record.
+Number of decumal places of the result of the multiplication of
+the factor and the yield in a decompositon of a untitary budget.
+Default: 3 decimal places.
+"DRUO": Number of decimal places of the yield in a decomposition of a
+unit of work.
+Decimal places of the result of the multiplication of the yield
+and the factor in a descomposition of a unit of work.
+Default: 3 decimal places.
+"DRA": Number of decimal places of the yield in a decompositon of a
+auxiliar element.
+Number of decimal places of the result of the multiplication of
+the yield and the factor in a descomposition of a auxilar element.Decimales
+Default: 3 decimal places.
+"DP": Number of decimal places of the price of a budget.
+Default: 2 decimal places.
+"DC": Number of decimal places of the price of a chapter or subchapter.
+Default: 2 decimal places.
+"DPU": Number of decimal places of the price of a unitary budget.
+Default: 2 decimal places.
+"DUO": Number of decimal places of the price of a unit of work.
+Default: 2 decimal places.
+"DEA": Number of decimal places of the price of a auxiliar element.
+Default: 2 decimal places.
+"DES": Number of decimal places of the price of the simple elements.
+Default: 2 decimal places.
+"DIR": Number of decimal places of the resulting amount to multiply
+the total yield and the price of the elements of a unit of work or
+a auxiliar element.
+"DIRC": Number of decimal places of the resulting amount to multiply
+the total yield and the price of the elements of a budget, chapter
+or a subchapter.
+"DCD": Number of decimal places ot the resulting amount to sum the
+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,
+DIR=2, DIRC=2, DCD=2,
+DIVISA="EUR" ):
+self.DN = DN
+self.DD = DD
+self.DSP = DSP
+self.DS = DS
+self.DFP = 3
+self.DFC = DFC
+self.DFPU = DFPU
+self.DFUO = DFUO
+self.DFA = DFA
+self.DRP = 3
+self.DRC = DRC
+self.DRPU = DRPU
+self.DRUO = DRUO
+self.DRA = DRA
+self.DP = DP
+self.DC = DC
+self.DPU = DPU
+self.DUO = DUO
+self.DEA = DEA
+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.
+# DES: simple element.
+_hierarchy = recordType.hierarchy
+if _hierarchy == 0: #budget, type 0, subtipe "OB"
+_decimal = self.DP
+elif _hierarchy == 1: #chapter/subcharter, type 0, subtipe ""
+_decimal = self.DC
+else: # other
+_type = recordType.type
+_subtype = recordType.subtype
+if _subtype == "EA": # auxiliar element type 0 subitype "EA"
+_decimal = self.DEA
+if _subtype == "PU": # unitary budget type 0 subitype "PU"
+_decimal = self.DPU
+elif (_type in [1, 2, 3] or
+_subtype in ["H", "Q", "%", "MC", "MCr", "MM", "MS", "ME",
+"MCu", "Mal","ML", "M"]
+): # 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
+#   ->DFA: Auxiliar
+#   ->DFPU: Unitary budget
+if recordType.hierarchy == 0: #budget
+_decimal = self.DFP
+elif recordType.hierarchy == 1: #chapter/subcharter
+_decimal = self.DFC
+else: # other
+if recordType.subtype == "EA": # auxiliar element
+_decimal = self.DFA
+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
+#   ->DRA: Auxiliar
+#   ->DRPU: Unitary budget
+if recordType.hierarchy == 0: #budget
+_decimal = self.DRP
+elif recordType.hierarchy == 1: #chapter/subcharter
+_decimal = self.DRC
+else: # other
+if recordType.subtype == "EA": # auxiliar element
+_decimal = self.DRA
+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
+if _hierarchy == 0 or _hierarchy == 1 or _subtype == "PU":
+#budget, type 0, subtipe "OB"
+#chapter/subcharter, type 0, subtipe ""
+#unitary budget, type 2, subtype "PU"
+_decimal = self.DIRC
+else: # other
+# 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:
+base.Sheet(sheet_dict)
+Ancestry:
++-- object
++-- Sheet
+Atributes:
+"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")
+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")
+if not isinstance(section_dict, dict):
+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")
+if not isinstance(section, str):
+raise ValueError, _("sheet section must be a string")
+if not isinstance(paragraph, str):
+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
+Constructor:
+base.Budget()
+Ancestry:
++-- object
++-- Budget
+Atributes:
+"filename": file name of the budget file (FIEBDC)
+"__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)
+hasPath(self, path)
+getchildren(self, code)
+setOwner(self, owner)
+setDate(self, date)
+setComment(self, comment)
+setBudgetType(self, type)
+setCertificateOrder(self, order)
+setCertificateDate(self, date)
+setTitleList(self, title)
+getTitleList(self)
+getActiveTitle(self)
+setDecimals(self, dictionary)
+getDecimals(self, decimal="All", N=None)
+setPercentages(self, dictionary)
+getPercentages(self, percentage="All")
+getAllParents(self, code)
+getAllchildren(self, code)
+getNDecomposition(self, code, N)
+getDecomposition(self,code)
+getMeasure(self, path)
+getStrYield
+getStrFactor
+setTree(sef, code, child_code, position, factor, yield_, total,
+list_lines, label, type)
+eval_formula(self, formula, a, b, c, d)
+getText(self, code)
+setText(self, code, text)
+setRecord(self, code, synonyms, hierarchy, unit, sumary, ...
+hasRecord(self, code)
+getRecord
+addPriceToRecord
+getStrPriceFromRecord
+getCode(self, path)
+getAmount
+getStrAmount
+setSheetSection(self, sheet_code, sheet_title)
+hasSheetSection(self, section)
+setSheetSections(self,dictionary)
+setSheetField(self, field_code, field_title)
+hasSheetField(self, field)
+getSheetField(self, field)
+setSheetFields(self, field_dict)
+setSheetParagraph(self, paragraph_code, paragraph_text)
+hasSheetParagraph(self, paragraph)
+getSheetParagraph(self, paragraph)
+setSheetParagraphs(self, paragraph_dict)
+setSheetRecord(self, record_code,field, section_dict)
+addFile(self, record_code, filename)
+setCompany(self, code, summary, name, offices, cif, web, email )
+getCompany
+getCompanyKeys
+addTecInfo(self, ti_code, text, unit)
+hasTecInfo(self, ti_code)
+getTecInfo(self, ti_code)
+setTecnicalInformation(self, _record_code, _ti_dict)
+changeCode(self, record_code, new_rocord_code)
+addLabel
+setParametricSelectComment
+setParametricSummary
+setParametricText
+"""
+def __init__(self):
+"""__init__(self)
+Initialize the budget atributes
+"""
+self.__title_index = 0
+self.__decimals = [Decimals(), Decimals()]
+self.__percentages = { "CI" : "" ,"GG": "", "BI": "",
+"BAJA": "", "IVA" : ""}
+self.__title_list = [ "", [ ] ]
+self.__root = None
+self.__file_owner = ""
+self.__comment = ""
+self.__budgetCerficateOrder = None
+self.__budgetCerficateDate = None
+self.__date = (0,0,0)
+self.__budgetType = 0
+self.__records = { }
+self.__synonyms = { }
+self.__sheet_sections = { }
+self.__sheet_fields = { }
+self.__sheet_paragraphs = { }
+self.__companys = { }
+self.__tec_info = { }
+self.__labels = { }
+def __getstate__(self):
+return (self.__title_index, self.__decimals, self.__percentages,
+self.__title_list, self.__root, self.__file_owner,
+self.__records, self.__synonyms, self.__sheet_sections,
+self.__sheet_fields, self.__sheet_paragraphs,self.__companys,
+self.__tec_info, self.__labels)
+def __setstate__(self, tuple):
+self.__title_index = tuple[0]
+self.__decimals = tuple[1]
+self.__percentages = tuple[3]
+self.__title_list = tuple[4]
+self.__root = tuple[4]
+self.__file_owner = tuple[5]
+self.__records = tuple[6]
+self.__synonyms = tuple[7]
+self.__sheet_sections = tuple[8]
+self.__sheet_fields = tuple[9]
+self.__sheet_paragraphs = tuple[10]
+self.__companys = tuple[11]
+self.__tec_info = tuple[12]
+self.__labels = tuple[13]
+def iter(self):
+for record in self.__records:
+yield record
+def iterPreOrder(self, recordCode, 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=[]):
+_children = self.getchildren(recordCode)
+for _child in _children:
+if not _child in codes:
+self.iterPreOrder(_child, codes)
+codes.append(_child)
+return codes
+def getRoot(self):
+"""getRoot(self)
+Returns the root record code
+"""
+return self.__root
+def hasPath(self, path):
+"""hasPath(self, path)
+path: The path of the record in the budget, It is a tuple.
+Tests if the path is valid in the budget
+"""
+try:
+self.getCode(path)
+return True
+except ValueError:
+return False
+def getchildren(self, code):
+"""getchildren(self, code)
+code: a record code.
+Return a list whith the child codes of a record
+"""
+_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")
+def setDate(self, date):
+"""setOwner(self, date)
+date (_y, _m, _d)
+Set the date when de file was generated
+"""
+if isinstance(date, tuple) and len(date) == 3 and \
+isinstance(date[0], int) and isinstance(date[1], int) and \
+isinstance(date[2], int) and date[1] in range(13) and \
+date[2] in range(32):
+if date[1] != 0 and date[2] != 0:
+datetime.date(*date)
+self.__date = date
+else:
+raise  TypeError, _("Invalid Date: %s" % 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")
+def setBudgeType(self, budget_type):
+"""setOwner(self, budget_type)
+budget_type: type of data in budget
+0 -> Undefined
+1 -> Base data.
+2 -> Budget.
+3 -> Budget certificate.
+4 -> Base date update.
+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.")
+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.")
+def setCertificateDater(self, certificate_date):
+"""setCertidicateDate(self, certificate_date)
+Set the certificate date.
+"""
+if isinstance(certificate_date, tuple) and \
+len(certificate_date) == 3 and \
+isinstance(certificate_date[0], int) and \
+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.")
+def setTitleList(self, title_list):
+"""setTitleList(self, title_list)
+title_list: [ "Header", ["Title1", "Title2", ... ] ]
+Set the header and titles for the price groups and decimals.
+"""
+title_list[0] = str(title_list[0])
+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")
+def getTitleList(self):
+""" getTitleList(self)
+Returns the header and titles for the price groups and decimals.
+"""
+return self.__title_list
+def getActiveTitle(self):
+"""getActiveTitle(self)
+Returns the active Title of price group
+"""
+return self.__title_index
+def setDecimals(self, dictionary, N):
+"""setDecimals(self, dictionary, N)
+dictionay: the decimal dictionary
+N: the price group
+Sets the Decimals for a price group.
+"""
+if N == -1 or N == len(self.__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")
+for _decimal in dictionary:
+if dictionary[_decimal] == "":
+dictionary[_decimal] = eval("_default_decimals." + _decimal)
+decimals = Decimals(dictionary["DN"], dictionary["DD"],
+dictionary["DSP"], dictionary["DS"],
+dictionary["DFC"],
+dictionary["DFPU"], dictionary["DFUO"],
+dictionary["DFA"], dictionary["DRC"],
+dictionary["DRPU"], dictionary["DRUO"],
+dictionary["DRA"], dictionary["DP"],
+dictionary["DC"], dictionary["DPU"],
+dictionary["DUO"], dictionary["DEA"],
+dictionary["DES"], dictionary["DIR"],
+dictionary["DIRC"], dictionary["DCD"],
+dictionary["DIVISA"])
+self.__decimals[N] = decimals
+def getDecimals(self, decimal="All", N=None):
+"""getDecimals(self,decimal="All",N=None)
+decimal:
+"All": Return a Decimals objet for a price group
+"keys": Return the keys of a Decimal object
+key: Return a Decimal value for a price group
+N: the price group None,1,2,..
+None: Return the active price group
+"""
+if N is None: N = self.getActiveTitle()
+if decimal == "All":
+return self.__decimals[N+1]
+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")
+def setPercentages(self, dictionary):
+"""setPercentages(self, dictionary):
+dictionary: the percentage dictionary
+Sets the percentage dictionary.
+"""
+_default_percentages = self.__percentages
+for percentage in dictionary:
+if dictionary[percentage] == 0:
+dictionary[percentage] = ""
+elif dictionary[percentage] == "":
+dictionary[percentage] = _default_percentages[percentage]
+_percentages = { "CI": dictionary["CI"],
+"GG": dictionary["GG"],
+"BI": dictionary["BI"],
+"BAJA": dictionary["BAJA"],
+"IVA" : dictionary["IVA"]}
+self.__percentages = _percentages
+def getPercentages(self, key="All"):
+"""getPercentages(self, percentage="All")
+key:
+"All": Return the Percentages dictionary
+"keys": Return the keys of a Percentages object
+key: Return a Percentages value for the key
+"""
+if key == "All":
+return self.__percentages
+elif key == "keys":
+return self.__percentages.keys
+elif key in self.__percentages:
+return self.__percentages[key]
+else:
+raise KeyError, _("Invalid Percentage key")
+def getAllParents(self,code):
+"""getAllParents(self,code)
+code: a record code.
+Returns a list with all the parents of a record
+All record which the record is in its descomposition list,
+including the parents of the parents
+"""
+if code in self.__records:
+_parents = self.__records[code].parents
+if len(_parents) == 0: return [ ]
+for _antecesor in _parents[:]:
+_parents = _parents + self.getAllParents(_antecesor)
+return _parents
+else:
+return [ ]
+def getAllchildren(self,code):
+"""getAllchildren(self,code
+code: a record code.
+Returns a list with all the children of a record, including
+the children of the children
+"""
+if code in self.__records:
+_children = self.__records[code].children
+_children = [ _child.code for _child in _children ]
+for _child in _children[:]:
+_children = _children + self.getAllchildren(_child)
+return _children
+else:
+return [ ]
+def getNDecomposition(self, code, N):
+"""getDecomposition(self,path)
+path: the path for a record
+Returns the Decomposition object of a record
+"""
+_record = self.getRecord(code)
+_decomposition_list = _record.children
+_decomposition = _decomposition_list[N]
+return _decomposition
+def getDecomposition(self, path):
+"""getDecomposition(self,path)
+path: the path for a record
+Returns the Decomposition object of a record
+"""
+if path == (0,):
+_type = self.getRecord(self.__root).recordType
+return Decomposition( 0, self.__root,
+[Measure(self.getDecimals(), _type,
+0.0, [], "", 1.0, 1.0)])
+else:
+return self.getNDecomposition(self.getCode(path[:-1]), path[-1])
+def getMeasure(self, path):
+"""getMeasure(self, path)
+path: the path for a record
+Return the measute object of a record
+"""
+_decomposition = self.getDecomposition(path)
+_measure = _decomposition.budgetMeasures[0]
+return _measure
+def getStrYield(self, measure, recordType):
+#_DR = measure.getDR(self.getDecimals())
+_DR = self.getDecimals().getDR(recordType)
+_yield = ("%." + str(_DR) + "f" ) % measure.yield_
+return _yield
+def getStrFactor(self, measure, recorType):
+_DF = 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,
+list_lines, label, type):
+"""setTree(self, code, child_code, position, factor,yield_, total,
+list_lines, label, type)
+code: the parent record code
+child_code: child record code
+position: position of child record in record parent record
+decomposition. Position == -1 -> new child
+factor:
+yield_:
+total: total measure (float)
+list_lines: list of measure lines
+[ [linetype, comment, units, length, width, height], ... ]
+linetype:
+empty string -> Normal
+1 -> Parcial Subtotal
+2 -> Accumulated Subtotal
+3 -> Formula, the comment is a formula.
+comment: Can be a descriptive text or a formula
+Valid Operator: '(', ')', '+', '-', '*', '/' and '^'
+Valid variable: 'a', 'b', 'c','d'y 'p' (Pi=3.1415926)
+units: Number of Units (a)
+length: Length (b)
+width: Width (c)
+height: Height (d)
+label: Record Identifiers that are used by some measure programs.
+type: type of action
+M: Set measure
+A: Add measure
+Sets the decomposition of a record in a child record
+"""
+if not utils.is_valid_code(code)[0]:
+raise ValueError, utils.mapping(_("Invalid parent code: $1"),
+(code,))
+if not utils.is_valid_code(child_code)[0]:
+raise ValueError, utils.mapping(_("Invalid child code: $1"),
+(code,))
+if not isinstance(position, int):
+raise ValueError, utils.mapping(_("Invalid position in measure "\
+"$1, in code $2"), (parent_code, 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: "\
+"$1, child code: $2, repeated code: $3"),
+(code, child_code, _parent_code))
+return
+# Creating reference to parent code in child record
+if child_code in self.__records:
+_child_record = self.__records[child_code]
+else:
+_child_record = self.setRecord(child_code, [], -1, "", "", [], [],
+"", "")
+if code in self.__records:
+code = self.__records[code].code
+_child_record.appendParent(code)
+child_code = self.__records[child_code].code
+if code in self.__records:
+# if the code exits retake previous values.
+_record = self.__records[code]
+_child_number = len(_record.children)
+if position == -1:
+position = _child_number
+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
+if not isinstance(list_lines, list): list_lines = []
+_child = _record.appendChild(child_code, self.getDecimals(),
+factor, yield_, total, list_lines, type, label)
+elif position < _child_number:
+# The record have the child
+_child = _record.children[position]
+if child_code != "" and child_code != _child.code:
+_child.code = child_code
+if factor != "" :
+if not isinstance(factor, float):
+factor == 1.0
+_child.budgetMeasures[0].setFactor(factor,
+self.getDecimals(), _record.recordType)
+if yield_ != "":
+if not isinstance(yield_, float):
+yield_ = 1.0
+_child.budgetMeasures[0].setYield(yield_,
+self.getDecimals(), _record.recordType)
+_measure = _child.budgetMeasures[0]
+if total != "":
+if not isinstance(total, float):
+yield_ = 0.0
+_measure.setMeasure(total, self.getDecimals())
+if isinstance(list_lines, list) and len(list_lines) > 0:
+_measure.buildMeasure(list_lines, type, self.getDecimals(),
+_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 "
+"decomposition. Parent code: $1 Child code: $2 "\
+"Position: $3"), (code, child_code, position))
+return
+else:
+if child_code == "" :
+print utils.mapping(_("Error: Empty child code. Parent code: "\
+"$1 Position: $2"), (code, position))
+return
+if position == -1:
+position = 0
+elif position != 0:
+print utils.mapping(_("Error: Invalid child position in "\
+"decomposition. Parent code: $1 Child code: $2 "\
+"Position: $3"), (code, child_code, position))
+return
+if not isinstance(factor, float):
+factor == 1.0
+if not isinstance(yield_, float):
+yield_ = 1.0
+_record = self.setRecord(code, [], "", "", "", [], [],
+"", "")
+_child = _record.appendChild(child_code, self.getDecimals(),
+factor, yield_, total, list_lines, type, label)
+_child.budgetMeasures[0] = measure
+def eval_formula(self, formula, a, b, c, d):
+"""eval_formula(self, formula, a, b, c, d)
+formula:
+Valid Operator: '(', ')', '+', '-', '*', '/' and '^'
+Valid variable: 'a', 'b', 'c','d'y 'p' (Pi=3.1415926)
+units: Number of Units (a)
+length: Length (b)
+width: Width (c)
+height: Height (d)
+Evals the formula and return the result
+"""
+if a == "": a = 0.0
+if b == "": b = 0.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")
+try:
+b = float(b)
+except:
+raise ValueError, _("'b' value must be a float number")
+try:
+c = float(c)
+except:
+raise ValueError, _("'c' value must be a float number")
+try:
+d = float(d)
+except:
+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("-", " - ")
+formula = formula.replace("*", " * ")
+formula = formula.replace("/", " / ")
+formula = formula.replace("^", " ** ")
+formula = formula.replace("(", " ( ")
+formula = formula.replace(")", " ) ")
+formula = formula.replace("a", str(a))
+formula = formula.replace("b", str(b))
+formula = formula.replace("c", str(c))
+formula = formula.replace("d", str(d))
+formula = formula.replace("p", "3.1415926")
+_list_formula = formula.split(" ")
+_formula2 = ""
+for oper in _list_formula:
+try:
+_float_oper= str(float(oper))
+_formula2 = _formula2 + _float_oper
+except ValueError:
+_formula2 = _formula2 + oper
+_g = {"__builtins__":{}}
+try:
+return eval(_formula2, _g)
+except:
+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")
+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,))
+if not code in self.__records:
+_record = self.setRecord(code, [], "", "", "", [], [],
+"", "")
+_record.text = text
+else:
+_record = self.__records[code]
+_record.text = text
+def setRecord(self, code, synonyms, hierarchy, unit, summary, price, date,
+type, subtype):
+"""setRecord(self, code, synonyms, hierarchy, unit, summary, price,
+date, type, subtype)
+code: Code string
+synonyms: List of synonym codes of the record
+hierarchy:
+0 -> root
+1 -> Chapter/Subchapter
+2 -> Other
+unit: unit of measure record
+summary: Short description of a record
+price: List of prices
+date: List of dates
+"type" and "subtype":
+0 Without classifying
+EA  Auxiliary element
+EU  Unitary element
+EC  Complex element
+EF  Functional element
+OB  Construction site
+PA  Cost overrun
+PU  Unitary budget
+1 Labourforce
+H   Labourforce
+2 Machinery and auxiliary equipment
+Q   Machinery
+%   Auxiliary equipment
+3 Building materials
+MC  Cement
+MCr Ceramic
+MM  Wood
+MS  Iron and steel
+ME  Energy
+MCu Copper
+MAl Aluminium
+ML  Bonding agents
+M   Others materials
+Hierarchy            type subtype
+0->root         -> 0 -> None,OB
+1->[sub]chapter -> 0 -> None,PU
+2->Other        -> 0 -> None,EA,EU,EC,EF,PA
+1 -> None,H
+2 -> None,Q,%
+3 -> None,MC,MCr,MM,MS,ME,MCu,Mal,ML,M
+Adds a record in the budget
+"""
+# hierarchy
+if hierarchy == 0 :
+# is the root record
+if self.__root is None:
+self.__root = code
+else:
+print _("Only can be one root record")
+return
+# retake previous values.
+# TODO: test synonyms
+_budget = self
+if not code in self.__records:
+if code[-1] == "$":
+_record = ParametricRecord(_budget.getDecimals(), code,
+synonyms, hierarchy,
+unit, summary, [], type, subtype,
+[], "")
+else:
+_record = Record(_budget.getDecimals(), code, synonyms,
+hierarchy, unit,
+summary, [], type, subtype,[], "")
+self.__records[code] = _record
+_prices = [[price[i], date[i]] for i in range(len(price))]
+_record.setPrices(_prices, self.getDecimals())
+else:
+_record = self.__records[code]
+code = _record.code
+if len(synonyms) != 0 and synonyms[0] == "":
+synonyms = _record.synonyms
+if unit == "":
+unit = _record.unit
+if summary == "":
+summary = _record.summary
+#TODO: test empty price list
+if len(price) == 0 or price[0] == "":
+_prices = _record.prices
+else:
+_prices = [ [price[i], date[i]] for i in range(len(price))]
+if type == "":
+type = _record.recordType.type
+_record.synonyms = synonyms
+_record.unit = unit
+_record.summary = summary
+_record.setPrices(_prices, self.getDecimals())
+_record.recordType.hierarchy = hierarchy
+_record.recordType.type = type
+_record.recordType.subtype = subtype
+return _record
+def hasRecord(self,code):
+"""hasRecord(self,code)
+code: Code record
+Return True if the budget have this record code.
+"""
+if code in self.__records:
+return True
+else:
+return False
+def getRecord(self, code):
+"""getRecord(self, code)
+code: Code record
+Return the Record object
+"""
+return self.__records[code]
+def addPriceToRecord(self, price_date, record):
+"""addPriceToRecord(self, price, record)
+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
+"""
+record.addPrice(price_date, self.getDecimals())
+def getStrPriceFromRecord(self, index_price, record):
+_price = record.getPrice(index_price)
+_D = self.getDecimals().getD(record.recordType)
+_price = ("%." + str(_D) + "f" ) % _price
+return _price
+def getCode(self, path):
+"""getCode(self, path)
+path: path record in the budget.
+Return the code record
+"""
+if isinstance(path, tuple) and len(path)>= 1:
+if path[0] == 0:
+_code = self.__root
+for i in path[1:]:
+if isinstance(i, int):
+_record = self.__records[_code]
+_children_list = _record.children
+try:
+_child = _children_list[i]
+except:
+raise ValueError, _("This record does not exits")
+_code = _child.code
+else:
+raise ValueError, _("Path item must be a integer")
+return _code
+else:
+raise ValueError, _("This record does not exits")
+else:
+raise ValueError, utils.mapping(_("Path must be a not empty "\
+"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
+else:
+_parent_code = self.getCode(path[:-1])
+_parent_record = self.getRecord(_parent_code)
+_child_number = path[-1]
+_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())
+_DR = self.getDecimals().getDR(_parent_record.recordType)
+_total_yield = round(_factor * _yield, _DR)
+_DI = 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)
+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)
+_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")
+if not isinstance(sheet_title, str):
+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")
+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")
+if not isinstance(field_title, str):
+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")
+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")
+if not isinstance(paragraph_text, str):
+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")
+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")
+if not isinstance(field, str):
+raise ValueError, _("The field must be a string")
+if not isinstance(section_dict, dict):
+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 "\
+"code and can not be added the sheet text in the field $1. "\
+"Record Code: $2"), ( field, record_code))
+return
+#-#
+if not self.hasSheetField(field):
+self.setSheetField(field, "")
+for section, paragraph in section_dict.iteritems():
+if not self.hasSheetParagraph(paragraph):
+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")
+if not isinstance(filepath, str):
+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 "\
+"code $1 and can not be added the file: $2"),
+(record_code, 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")
+if not isinstance(sumamary, str):
+raise ValueError, _("The summary must be a string")
+if not isinstance(name, str):
+raise ValueError, _("The name must be a string")
+if not isinstance(offices, 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")
+if not len(_office) == 10:
+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 "\
+"string")
+for _item in _office[7:8]:
+if not isinstance(_item, list):
+raise ValueError, _("This office item must be a "\
+"list")
+_offices.append(Office(_office[0],
+_office[1],
+_office[2],
+_office[3],
+_office[4],
+_office[5],
+_office[6],
+_office[7],
+_office[8],
+_office[9]))
+if not isinstance(cif, str):
+raise ValueError, _("The name must be a string")
+if not isinstance(web, str):
+raise ValueError, _("The web must be a string")
+if not isinstance(email, str):
+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")
+if not isinstance(text, str):
+raise ValueError, _("The tecnical info description must be a "\
+"string")
+if not isinstance(unit, str):
+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.
+"""
+if self.hasRecord(record_code) and not self.hasRecord(new_record_code):
+_record = self.__records[code]
+_record.code = new_record_code
+_parents = _record.parents
+for _parent in _parents:
+_decomposition_list = self.__records[_parent].children
+for _decomposition in _decomposition_list:
+if _decomposition.code == record_code:
+_decomposition.code = new_record_code
+break
+_children = self.getchildren(record_code)
+for _child in _children:
+_parents_list = self.__records[_child].parents
+for index in range(len(_parents_list)):
+if _parents_list[index] == record_code:
+_parents_list[index] = new_record_code
+break
+self.__records[new_record_code] = _record
+del self.__records[record_code]
+# TODO: attachment files
+def addLabel(self, record_code, label):
+"""addLabel(self, record_code, label)
+Add a label to a record
+"""
+if not isinstance(label,str):
+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")
+if not isinstance(comment, str):
+raise ValueError, _("The parametric select comment must be a "\
+"string")
+if not self.hasRecord(record_code):
+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))
+return
+_record = self.getRecord(record_code)
+if not isinstance(_record, ParametricRecord):
+print utils.mapping(_("Error: The Record $1 is not a "\
+"Parametric Record and can not have Parametric comment"),
+(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")
+if not isinstance(summary, str):
+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 "\
+"code $1 and can not be seted the summary: $2"),
+(record_code, summary))
+return
+_record = self.getRecord(record_code)
+if not isinstance(_record, ParametricRecord):
+print utils.mapping(_("Error: The Record $1 is not a "\
+"Parametric Record and can not have Parametric summary"),
+(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")
+if not isinstance(text, str):
+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 "\
+"code $1 and can not be seted the text: $2"),
+(record_code, text))
+return
+_record = self.getRecord(record_code)
+if not isinstance(_record, ParametricRecord):
+print utils.mapping(_("Error: The Record $1 is not a "\
+"Parametric Record and can not have Parametric text"),
+(record_code,))
+else:
+self.getRecord(record_code).parametric_text = text
+class Office(object):
+"""base.Office:
+Description:
+Office of a company
+Constructor:
+base.Office(type, subname, address, postal_code, town, province,
+country, phone, fax, contact_person)
+Ancestry:
++-- object
++-- Office
+Atributes:
+"officeType" : type of Office
+are defined:
+"C"  Central.
+"D"  Local Office.
+"R"  performer.
+"subname" : name of Office or Performer
+"address" :
+"postal_code" :
+"town" :
+"province" :
+"country" :
+"phone" : list of phone numbers
+"fax" : list of fax numbers
+"contact_person" : name of contact person
+"values":
+Methods:
+__getstate__(self)
+__setstate__(self, tuple)
+__init__(self, measure, lines, label)
+{get/set}OfficeType
+{get/set}Subname
+{get/set}Address
+{get/set}PostalCode
+{get/set}Town
+{get/set}Province
+{get/set}Country
+{get/set}Phone
+{get/set}Fax
+{get/set}ContactPerson
+getValues
+"""
+__slots__ = ["_Office__officeType",
+"_Office__subname",
+"_Office__address",
+"_Office__postal_code",
+"_Office__town",
+"_Office__province",
+"_Office__country",
+"_Office__phone",
+"_Office__fax",
+"_Office__contact_person",
+]
+def __getstate__ (self):
+return ( self.__officeType,
+self.__subname,
+self.__address,
+self.__postal_code,
+self.__town,
+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.__town = tuple[4]
+self.__province = tuple[5]
+self.__country = tuple[6]
+self.__phone = tuple[7]
+self.__fax = tuple[8]
+self.__contact_person = tuple[9]
+def __init__(self, type, subname, address, postal_code, town, province,
+country, phone, fax, contact_person):
+self.officeType = type
+self.subname = subname
+self.address = address
+self.postal_code = postal_code
+self.town = town
+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,
+"town": self.town,
+"province": self.province,
+"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
+""")
+address = property(getAddress, setAddress, None,
+"""Adress
+""")
+postal_code = property(getPostalCode, setPostalCode, None,
+"""Postal code
+""")
+town = property(getTown, setTown, None,
+"""Town
+""")
+province = property(getProvince, setProvince, None,
+"""Province
+""")
+country = property(getCountry, setCountry, None,
+"""Country
+""")
+phone = property(getPhone, setPhone, None,
+"""Phone numbers
+""")
+fax = property(getFax, setFax, None,
+"""Fax numbers
+""")
+contact_person = property(getContactPerson, setContactPerson, None,
+"""Contact Person
+""")
+values = property(getValues, None, None,
+"""Dictionary with comapany values
+""")
+class Company(object):
+"""base.Company:
+Description:
+Company object
+__slots__ attribute, __getstate__ and __setstate__ method are defined
+to use less ram memory.
+Constructor:
+base.Company(code, summary, name, offices, cif, web, email)
+Ancestry:
++-- object
++-- Company
+Atributes:
+"code": code to indentifie the company in the buget
+"summary": short name
+"name": long name
+"offices": List of Offices
+"cif": CIF
+"web": web page
+"email": email
+"values":
+Methods:
+__getstate__(self)
+__setstate__(self, tuple)
+__init__(self, measure, lines, label)
+{get/set}Code
+{get/set}Summary
+{get/set}Name
+{get/set}Offices
+{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.__cif = tuple[4]
+self.__web = tuple[5]
+self.__email = tuple[6]
+def __init__(self, code, summary, name, offices, cif, web, email):
+self.code = code
+self.summary = summary
+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
+""")
+name = property(getName, setName, None,
+"""Company name
+""")
+offices = property(getOffices, setOffices, None,
+"""List of Offices
+""")
+cif = property(getCif, setCif, None,
+"""CIF
+""")
+web = property(getWeb, setWeb, None,
+"""Web page
+""")
+email = property(getEmail, setEmail, None,
+"""Email
+""")
+values = property(getValues, None, None,
+"""Dictionary with comapany values
+""")
+class File(object):
+"""base.Company:
+Description:
+File object
+Constructor:
+base.File(name, type, description)
+Ancestry:
++-- object
++-- File
+Atributes:
+"name": name
+"fileType": type of file
+"description": description file
+Methods:
+__getstate__(self)
+__setstate__(self, tuple)
+__init__(self, path,type, 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
+""")
+description = property(getDescription, setDescription, None,
+"""File description
+""")
+values = property(getValues, None, None,
+"""Dictionary with file values
+""")
+class RecordType(object):
+"""base.RecordType:
+Description:
+Record Type object
+"hierarchy":
+-1 -> temporarily unfixed
+0 -> root
+1 -> Chapter/Subchapter
+2 -> Other
+"type" and "subtype":
+0 Without classifying
+EA  Auxiliary element
+EU  Unitary element
+EC  Complex element
+EF  Functional element
+OB  Construction site
+PA  Cost overrun
+PU  Unitary budget
+1 Labourforce
+H   Labourforce
+2 Machinery and auxiliary equipment
+Q   Machinery
+%   Auxiliary equipment
+3 Building materials
+MC  Cement
+MCr Ceramic
+MM  Wood
+MS  Iron and steel
+ME  Energy
+MCu Copper
+MAl Aluminium
+ML  Bonding agents
+M   Others materials
+Hierarchy           type  subtype
+0->root         -> 0 -> None,OB
+1->[sub]chapter -> 0 -> None,PU
+2->Other        -> 0 -> None,EA,EU,EC,EF,PA
+1 -> None,H
+2 -> None,Q,%
+3 -> None,MC,MCr,MM,MS,ME,MCu,Mal,ML,M
+Constructor:
+base.File(hierarchy,type,subtype)
+Ancestry:
++-- object
++-- RecordType
+Atributes:
+"hierarchy": hierarchy
+"type": type
+"subtype": subtype
+Methods:
+__getstate__(self)
+__setstate__(self, tuple)
+__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) "\
+"The hierarchy must be -1, 0, 1 or 2"), (str(hierarchy)))
+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),"\
+"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 "\
+"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)))
+self.__subtype = subtype
+hierarchy = property(getHierarchy, setHierarchy, None,
+"""Record Hierarchy
+-1 -> temporarily unfixed
+0 -> root
+1 -> Chapter/Subchapter
+2 -> Other
+""")
+type = property(getType, setType, None,
+"""Record Type
+0 Without classifying
+1 Labourforce
+2 Machinery and auxiliary equipment
+3 Building materials
+""")
+subtype = property(getSubtype, setSubtype, None,
+"""Record Subtype
+None
+EA  Auxiliary element
+EU  Unitary element
+EC  Complex element
+EF  Functional element
+OB  Construction site
+PA  Cost overrun
+PU  Unitary budget
+H   Labourforce
+Q   Machinery
+%   Auxiliary equipment
+MC  Cement
+MCr Ceramic
+MM  Wood
+MS  Iron and steel
+ME  Energy
+MCu Copper
+MAl Aluminium
+ML  Bonding agents
+M   Others materials
+""")

Mercurial > pyarq-presupuestos

comparison Generic/base.py @ 1:2ac1551ad2ab version 0.0.0