21 |
# |
# |
22 |
#Fichero: fechahoramine.py |
#Fichero: fechahoramine.py |
23 |
|
|
24 |
"""Clase FechaHoraMine.""" |
"""Módulo para manejar fechas y horas del calendario de Minë. |
25 |
|
|
26 |
|
Contiene dos clases: |
27 |
|
- FechaHoraMine |
28 |
|
- FechaHoraMineRel |
29 |
|
""" |
30 |
|
|
31 |
from time import * |
from time import * |
32 |
|
|
33 |
class FechaHoraMine: |
class FechaHoraMine: |
34 |
"""Objeto que contiene una fecha y hora dentro de juego. |
"""Objeto que contiene una fecha y hora dentro de juego. |
35 |
|
|
36 |
|
Externamente el tiempo se identifica como el año, mes, dia, hora y segundo, desde el |
37 |
|
inicio de la Tercera Edad (dia 1 del mes 1 del año 0, a las 0:000 horas). En Minë no se |
38 |
|
cuentan los minutos. |
39 |
|
|
40 |
Internamente almacena la información como un entero largo con el número de segundos |
Internamente almacena la información como un entero largo con el número de segundos |
41 |
transcurridos desde la Fecha 0. Tiene fórmulas para transformar en año, mes, dia, hora |
transcurridos desde la Fecha R (la fecha usada para sincronizar el mundo de Minë con |
42 |
y segundo (en Minë no se cuentan minutos). |
el real). Tiene fórmulas para transformar en año, mes, dia, hora y segundo. |
43 |
|
|
44 |
La equivalencia con el tiempo real es 1 segundo Minë = 1 segundo real. A partir de ahí, |
La equivalencia con el tiempo real es 1 segundo Minë = 1 segundo real. A partir de ahí, |
45 |
las constantes SEGUNDOS_POR_HORA, etc. definen la cuenta del tiempo. En cuanto al |
las constantes SEGUNDOS_POR_HORA, etc. definen la cuenta del tiempo. |
|
calendario, se establecen FECHA0 y FECHA0_REAL para sincronizar con el tiempo real. |
|
46 |
|
|
47 |
Contiene los siguientes atributos: |
Contiene los siguientes atributos: |
48 |
- __anno (int): el año dentro de la Tercera Edad |
- __anno (int): el año dentro de la Tercera Edad |
50 |
- __dia (int): el número del día |
- __dia (int): el número del día |
51 |
- __hora (int): la hora del día |
- __hora (int): la hora del día |
52 |
- __segundo (int): el segundo dentro de la hora |
- __segundo (int): el segundo dentro de la hora |
53 |
- __segundos_totales (int): el número de segundos transcurridos desde la Fecha 0 |
- __segundos_totales (int): el número de segundos transcurridos desde la Fecha R |
54 |
|
|
55 |
Invariantes: |
Invariantes: |
56 |
__anno >= 0 |
__anno >= 0 (en realidad podría ser < 0, pero no consideraremos fechas anteriores a la T.E.) |
57 |
__mes in range(1,MESES_POR_ANNO) |
__mes in range(1,MESES_POR_ANNO) |
58 |
__dia in range(1,DIAS_POR_MES) |
__dia in range(1,DIAS_POR_MES) |
59 |
__hora in range(0,HORAS_POR_DIA) |
__hora in range(0,HORAS_POR_DIA-1) |
60 |
__segundo in range(0,SEGUNDOS_POR_HORA) |
__segundo in range(0,SEGUNDOS_POR_HORA-1) |
61 |
""" |
""" |
62 |
|
|
63 |
FECHA0_ANNO = 2500 # Fecha0 = 1 de ?? del 2500 T.E., a las 0:0h |
# Los siguientes valores representan la correspondencia Tiempo Real - Tiempo Minë. |
64 |
FECHA0_MES = 1 |
# Pueden ser modificados libremente. |
65 |
FECHA0_DIA = 1 |
|
66 |
FECHA0_HORA = 0 |
FECHA_R_ANNO = 2500 # Fecha R = 1 del 1 del 2500 T.E., a las 0:000h |
67 |
FECHA0_SEGUNDO = 0 |
FECHA_R_MES = 1 |
68 |
|
FECHA_R_DIA = 1 |
69 |
FECHA0_REAL_ANNO = 2002 # Fecha0 real = 8 de Septiembre de 2002 D.C. a las 0:0:0h WET |
FECHA_R_HORA = 0 |
70 |
FECHA0_REAL_MES = 9 # (Western European Time, 1 hora más que GMT) |
FECHA_R_SEGUNDO = 0 |
71 |
FECHA0_REAL_DIA = 8 |
|
72 |
FECHA0_REAL_HORA = 0 |
FECHA_R_REAL_ANNO = 2002 # Fecha R real = 8 de Septiembre de 2002 D.C. a las 0:0:0h WET |
73 |
FECHA0_REAL_MINUTO = 0 |
FECHA_R_REAL_MES = 9 # (Western European Time, 1 hora más que GMT) |
74 |
FECHA0_REAL_SEGUNDO = 0 |
FECHA_R_REAL_DIA = 8 |
75 |
FECHA0_REAL_SEGUNDOS_TOTALES = -1 |
FECHA_R_REAL_HORA = 0 |
76 |
|
FECHA_R_REAL_MINUTO = 0 |
77 |
|
FECHA_R_REAL_SEGUNDO = 0 |
78 |
|
|
79 |
MESES_POR_ANNO = 12 # 1 año Minë = 45 dias reales (3.888.000 segundos) |
MESES_POR_ANNO = 12 # 1 año Minë = 45 dias reales (3.888.000 segundos) |
80 |
DIAS_POR_MES = 30 # 1 mes Minë = 3,75 dias reales (324.000 segundos) |
DIAS_POR_MES = 30 # 1 mes Minë = 3,75 dias reales (324.000 segundos) |
81 |
HORAS_POR_DIA = 24 # 1 dia Minë = 3 horas reales (10.800 segundos) |
HORAS_POR_DIA = 24 # 1 dia Minë = 3 horas reales (10.800 segundos) |
82 |
SEGUNDOS_POR_HORA = 450 # 1 hora Minë = 7,5 minutos reales (450 segundos) |
SEGUNDOS_POR_HORA = 450 # 1 hora Minë = 7,5 minutos reales (450 segundos) |
83 |
|
|
84 |
|
# La siguiente lista es para identificar secciones dentro de un dia. El |
85 |
|
# número indica la hora a la que empieza la sección. |
86 |
|
|
87 |
|
SECCIONES = [ (0, "Noche cerrada"), |
88 |
|
(4, "Madrugada"), |
89 |
|
(8, "Por la mañana"), |
90 |
|
(12, "Mediodia"), |
91 |
|
(16, "Por la tarde"), |
92 |
|
(20, "Por la noche") ] |
93 |
|
|
94 |
|
# Los siguientes valores son usados internamente para los cálculos. Se obtienen |
95 |
|
# automáticamente. No tocar. |
96 |
|
|
97 |
|
FECHA_R_REAL_SEGUNDOS_TOTALES = -1 |
98 |
|
SEGUNDOS_POR_ANNO = -1 |
99 |
|
SEGUNDOS_POR_MES = -1 |
100 |
|
SEGUNDOS_POR_DIA = -1 |
101 |
|
|
102 |
def __init__(self, segundos_totales): |
def __init__(self, segundos_totales): |
103 |
|
"""Constructor a partir del número de segundos totales. |
104 |
|
|
105 |
|
Normalmente desde fuera no se usará este constructor, sino más bien los |
106 |
|
métodos FechaHoraMine_crear() o FechaHoraMine_ahora(). |
107 |
|
""" |
108 |
self.__segundos_totales = segundos_totales |
self.__segundos_totales = segundos_totales |
109 |
self.__descomponer_segundos() |
self.__descomponer_segundos() |
110 |
|
|
111 |
|
|
112 |
def __repr__(self): |
def __repr__(self): |
113 |
return "%04d-%02d-%02d %02d:%03d" % (self.__anno, self.__mes, self.__dia, |
"""Devuelve un string representando la instancia, de una forma evaluable.""" |
114 |
self.__hora, self.__segundo) |
return "%d" % self.__segundos_totales |
115 |
|
|
116 |
|
|
117 |
def __str__(self): |
def __str__(self): |
118 |
return "%04d-%02d-%02d %02d:%03d" % (self.__anno, self.__mes, self.__dia, |
"""Devuelve un string con la fecha en formato imprimible.""" |
119 |
self.__hora, self.__segundo) |
return "%02d/%02d/%04d T.E. %02d:%03d" % (self.__dia, self.__mes, self.__anno, |
120 |
|
self.__hora, self.__segundo) |
121 |
|
|
122 |
def anno(self): |
def anno(self): |
123 |
return self.__anno |
return self.__anno |
139 |
return self.__segundo |
return self.__segundo |
140 |
|
|
141 |
|
|
142 |
def __descomponer_segundos(self): |
def seccion(self): |
143 |
"""Extrae los valores desglosados a partir de los segundos totales.""" |
"""Devuelve el índice de la sección del día en que estamos.""" |
144 |
self.__anno = (self.__segundos_totales / (FechaHoraMine.MESES_POR_ANNO * # supongamos que el compilador |
for i in range(len(FechaHoraMine.SECCIONES)-1, -1, -1): |
145 |
FechaHoraMine.DIAS_POR_MES * # optimiza esto :-P |
seccion = FechaHoraMine.SECCIONES[i] |
146 |
FechaHoraMine.HORAS_POR_DIA * |
if self.__hora >= seccion[0]: |
147 |
FechaHoraMine.SEGUNDOS_POR_HORA)) + \ |
return i |
|
FechaHoraMine.FECHA0_ANNO |
|
|
|
|
|
resto = self.__segundos_totales % (FechaHoraMine.MESES_POR_ANNO * |
|
|
FechaHoraMine.DIAS_POR_MES * |
|
|
FechaHoraMine.HORAS_POR_DIA * |
|
|
FechaHoraMine.SEGUNDOS_POR_HORA) |
|
|
|
|
|
self.__mes = (resto / (FechaHoraMine.DIAS_POR_MES * |
|
|
FechaHoraMine.HORAS_POR_DIA * |
|
|
FechaHoraMine.SEGUNDOS_POR_HORA)) + \ |
|
|
FechaHoraMine.FECHA0_MES |
|
|
|
|
|
resto = resto % (FechaHoraMine.DIAS_POR_MES * |
|
|
FechaHoraMine.HORAS_POR_DIA * |
|
|
FechaHoraMine.SEGUNDOS_POR_HORA) |
|
|
|
|
|
self.__dia = (resto / (FechaHoraMine.HORAS_POR_DIA * |
|
|
FechaHoraMine.SEGUNDOS_POR_HORA)) + \ |
|
|
FechaHoraMine.FECHA0_DIA |
|
148 |
|
|
|
resto = resto % (FechaHoraMine.HORAS_POR_DIA * |
|
|
FechaHoraMine.SEGUNDOS_POR_HORA) |
|
149 |
|
|
150 |
self.__hora = (resto / (FechaHoraMine.SEGUNDOS_POR_HORA)) + \ |
def desc_seccion(self): |
151 |
FechaHoraMine.FECHA0_HORA |
"""Devuelve la descripción de la sección del día en que estamos.""" |
152 |
|
for i in range(len(FechaHoraMine.SECCIONES)-1, -1, -1): |
153 |
|
seccion = FechaHoraMine.SECCIONES[i] |
154 |
|
if self.__hora >= seccion[0]: |
155 |
|
return seccion[1] |
156 |
|
|
157 |
|
|
158 |
|
def __descomponer_segundos(self): |
159 |
|
"""Extrae los valores desglosados a partir de los segundos totales.""" |
160 |
|
|
161 |
|
self.__anno = (self.__segundos_totales / FechaHoraMine.SEGUNDOS_POR_ANNO) \ |
162 |
|
+ FechaHoraMine.FECHA_R_ANNO |
163 |
|
|
164 |
|
resto = self.__segundos_totales % FechaHoraMine.SEGUNDOS_POR_ANNO |
165 |
|
|
166 |
|
self.__mes = (resto / FechaHoraMine.SEGUNDOS_POR_MES) \ |
167 |
|
+ FechaHoraMine.FECHA_R_MES |
168 |
|
|
169 |
|
resto = resto % FechaHoraMine.SEGUNDOS_POR_MES |
170 |
|
|
171 |
|
self.__dia = (resto / FechaHoraMine.SEGUNDOS_POR_DIA) \ |
172 |
|
+ FechaHoraMine.FECHA_R_DIA |
173 |
|
|
174 |
|
resto = resto % FechaHoraMine.SEGUNDOS_POR_DIA |
175 |
|
|
176 |
|
self.__hora = (resto / FechaHoraMine.SEGUNDOS_POR_HORA) \ |
177 |
|
+ FechaHoraMine.FECHA_R_HORA |
178 |
|
|
179 |
|
self.__segundo = (resto % FechaHoraMine.SEGUNDOS_POR_HORA) \ |
180 |
|
+ FechaHoraMine.FECHA_R_SEGUNDO |
181 |
|
|
182 |
|
|
183 |
|
def __cmp__(self, otra): |
184 |
|
"""Compara dos fechas. |
185 |
|
|
186 |
|
Devuelve -1, 0 o 1 si la segunda fecha es menor, igual o mayor que esta. |
187 |
|
""" |
188 |
|
if self.__segundos_totales < otra.__segundos_totales: |
189 |
|
return -1 |
190 |
|
elif self.__segundos_totales > otra.__segundos_totales: |
191 |
|
return 1 |
192 |
|
else: |
193 |
|
return 0 |
194 |
|
|
195 |
|
|
196 |
|
def __sub__(self, otra): |
197 |
|
"""Resta esta fecha menos la otra. |
198 |
|
|
199 |
|
Devuelve la diferencia como una FechaHoraMineRel. |
200 |
|
""" |
201 |
|
if self >= otra: |
202 |
|
signo = 1 |
203 |
|
mayor = self |
204 |
|
menor = otra |
205 |
|
else: |
206 |
|
signo = -1 |
207 |
|
mayor = otra |
208 |
|
menor = self |
209 |
|
|
210 |
|
return FechaHoraMineRel(signo, |
211 |
|
mayor.__anno - menor.__anno, |
212 |
|
mayor.__mes - menor.__mes, |
213 |
|
mayor.__dia - menor.__dia, |
214 |
|
mayor.__hora - menor.__hora, |
215 |
|
mayor.__segundo - menor.__segundo) |
216 |
|
|
217 |
|
|
218 |
|
def __add__(self, relativa): |
219 |
|
"""Suma una fecha relativa a esta. |
220 |
|
|
221 |
|
Devuelve otra fecha normal. |
222 |
|
""" |
223 |
|
if relativa.signo() >= 0: |
224 |
|
return FechaHoraMine_crear(self.__anno + relativa.annos(), |
225 |
|
self.__mes + relativa.meses(), |
226 |
|
self.__dia + relativa.dias(), |
227 |
|
self.__hora + relativa.horas(), |
228 |
|
self.__segundo + relativa.segundos()) |
229 |
|
else: |
230 |
|
return FechaHoraMine_crear(self.__anno - relativa.annos(), |
231 |
|
self.__mes - relativa.meses(), |
232 |
|
self.__dia - relativa.dias(), |
233 |
|
self.__hora - relativa.horas(), |
234 |
|
self.__segundo - relativa.segundos()) |
235 |
|
|
|
self.__segundo = (resto % (FechaHoraMine.SEGUNDOS_POR_HORA)) + \ |
|
|
FechaHoraMine.FECHA0_SEGUNDO |
|
236 |
|
|
237 |
|
|
238 |
def FechaHoraMine_ahora(): |
def FechaHoraMine_ahora(): |
239 |
"""Devuelve una FechaHoraMine correspondiente a la fecha y hora en este momento.""" |
"""Devuelve una FechaHoraMine correspondiente a la fecha y hora en este momento.""" |
240 |
return FechaHoraMine(int(time() + 0.5) - FechaHoraMine.FECHA0_REAL_SEGUNDOS_TOTALES) |
return FechaHoraMine(int(time() + 0.5) - FechaHoraMine.FECHA_R_REAL_SEGUNDOS_TOTALES) |
241 |
|
|
242 |
|
|
243 |
def FechaHoraMine_crear(anno = 0, mes = 0, dia = 0, hora = 0, segundo = 0): |
def FechaHoraMine_crear(anno = FechaHoraMine.FECHA_R_ANNO, \ |
244 |
|
mes = FechaHoraMine.FECHA_R_MES, \ |
245 |
|
dia = FechaHoraMine.FECHA_R_DIA, \ |
246 |
|
hora = FechaHoraMine.FECHA_R_HORA, \ |
247 |
|
segundo = FechaHoraMine.FECHA_R_SEGUNDO): |
248 |
"""Devuelve una FechaHoraMine correspondiente a los datos pasados.""" |
"""Devuelve una FechaHoraMine correspondiente a los datos pasados.""" |
249 |
segundos_totales = (anno - FechaHoraMine.FECHA0_ANNO) * (FechaHoraMine.MESES_POR_ANNO * |
segundos_totales = (anno - FechaHoraMine.FECHA_R_ANNO) * FechaHoraMine.SEGUNDOS_POR_ANNO \ |
250 |
FechaHoraMine.DIAS_POR_MES * |
+ (mes - FechaHoraMine.FECHA_R_MES) * FechaHoraMine.SEGUNDOS_POR_MES \ |
251 |
FechaHoraMine.HORAS_POR_DIA * |
+ (dia - FechaHoraMine.FECHA_R_DIA) * FechaHoraMine.SEGUNDOS_POR_DIA \ |
252 |
FechaHoraMine.SEGUNDOS_POR_HORA) + \ |
+ (hora - FechaHoraMine.FECHA_R_HORA) * FechaHoraMine.SEGUNDOS_POR_HORA \ |
253 |
(mes - FechaHoraMine.FECHA0_MES - 1) * (FechaHoraMine.DIAS_POR_MES * |
+ (segundo - FechaHoraMine.FECHA_R_SEGUNDO) |
|
FechaHoraMine.HORAS_POR_DIA * |
|
|
FechaHoraMine.SEGUNDOS_POR_HORA) + \ |
|
|
(dia - FechaHoraMine.FECHA0_DIA - 1) * (FechaHoraMine.HORAS_POR_DIA * |
|
|
FechaHoraMine.SEGUNDOS_POR_HORA) + \ |
|
|
(hora - FechaHoraMine.FECHA0_HORA) * (FechaHoraMine.SEGUNDOS_POR_HORA) + \ |
|
|
(segundo - FechaHoraMine.FECHA0_SEGUNDO) |
|
254 |
return FechaHoraMine(segundos_totales) |
return FechaHoraMine(segundos_totales) |
255 |
|
|
256 |
|
|
257 |
|
|
258 |
|
class FechaHoraMineRel: |
259 |
|
"""Objeto que contiene LA DIFERENCIA entre dos fechas y horas dentro de juego. |
260 |
|
|
261 |
|
Mientras que FechaHoraMine mide la distancia entre una fecha y el origen de la T.E., |
262 |
|
esta clase mide la distancia entre dos fechas arbitrarias, medida en años, meses, |
263 |
|
horas y segundos. |
264 |
|
|
265 |
|
La distancia puede ser positiva, o negativa, según si la fecha final es posterior o |
266 |
|
anterior a la origen, respectivamente. El 0 se considera positivo. |
267 |
|
|
268 |
|
Internamente NO guarda la conversión a número de segundos. Cuando haya años bisiestos |
269 |
|
y otras irregularidades, el número de segundos a que corresponde una FechaHoraMineRel |
270 |
|
es variable y depende de cuál sea la fecha origen. Por ejemplo, una diferencia de un |
271 |
|
mes no dura lo mismo en segundos si el mes origen tiene 30 días o si tiene 31. |
272 |
|
|
273 |
|
Nótese que mientras en FechaHoraMine los meses van de 1 a MESES_POR_ANNO, en ésta |
274 |
|
clase van de 0 a MESES_POR_ANNO-1, dado que es una diferencia. Lo mismo con los dias. |
275 |
|
|
276 |
|
Puede haber números fuera de rango, cuando provienen de una suma o resta de fechas. |
277 |
|
Por ejemplo, si el año tiene 12 meses, la fecha relativa meses=14, equivale a |
278 |
|
annos=1,meses=2. Otro ejemplo: si el mes tiene 30 dias, la fecha relativa |
279 |
|
meses=3,dias=-5 equivale a meses=2,dias=25. |
280 |
|
|
281 |
|
Invariantes: |
282 |
|
__signo in [-1, 1] |
283 |
|
__annos >= 0 |
284 |
|
""" |
285 |
|
|
286 |
|
def __init__(self, signo=1, annos=0, meses=0, dias=0, horas=0, segundos=0): |
287 |
|
"""Constructor a partir de los componentes. |
288 |
|
|
289 |
|
Requiere: |
290 |
|
signo in [-1, 1] |
291 |
|
annos >= 0 |
292 |
|
""" |
293 |
|
self.__signo = signo |
294 |
|
self.__annos = annos |
295 |
|
self.__meses = meses |
296 |
|
self.__dias = dias |
297 |
|
self.__horas = horas |
298 |
|
self.__segundos = segundos |
299 |
|
|
300 |
|
|
301 |
|
def __repr__(self): |
302 |
|
"""Devuelve un string representando la instancia, de una forma evaluable.""" |
303 |
|
return "%s%04d/%02d/%02d %02d:%03d" % (((self.__signo < 0) and "(-)" or ""), |
304 |
|
self.__annos, self.__meses, self.__dias, |
305 |
|
self.__horas, self.__segundos) |
306 |
|
|
307 |
|
|
308 |
|
def __str__(self): |
309 |
|
"""Devuelve un string con la fecha en formato imprimible.""" |
310 |
|
return "%s%04d/%02d/%02d %02d:%03d" % (((self.__signo < 0) and "(-)" or ""), |
311 |
|
self.__annos, self.__meses, self.__dias, |
312 |
|
self.__horas, self.__segundos) |
313 |
|
|
314 |
|
def signo(self): |
315 |
|
return self.__signo |
316 |
|
|
317 |
|
|
318 |
|
def annos(self): |
319 |
|
return self.__annos |
320 |
|
|
321 |
|
|
322 |
|
def meses(self): |
323 |
|
return self.__meses |
324 |
|
|
325 |
|
|
326 |
|
def dias(self): |
327 |
|
return self.__dias |
328 |
|
|
329 |
|
|
330 |
|
def horas(self): |
331 |
|
return self.__horas |
332 |
|
|
333 |
|
|
334 |
|
def segundos(self): |
335 |
|
return self.__segundos |
336 |
|
|
337 |
|
|
338 |
|
def inverso(self): |
339 |
|
"""Devuelve el mismo intervalo con el signo invertido.""" |
340 |
|
if otra.signo() >= 0: |
341 |
|
signo_inverso = -1 |
342 |
|
else: |
343 |
|
signo_inverso = 1 |
344 |
|
|
345 |
|
return FechaHoraMineRel(signo_inverso, |
346 |
|
self.annos(), |
347 |
|
self.meses(), |
348 |
|
self.dias(), |
349 |
|
self.horas(), |
350 |
|
self.segundos()) |
351 |
|
|
352 |
|
|
353 |
|
def abs(self): |
354 |
|
"""Devuelve el mismo intervalo eliminando el signo.""" |
355 |
|
return FechaHoraMineRel(1, |
356 |
|
self.annos(), |
357 |
|
self.meses(), |
358 |
|
self.dias(), |
359 |
|
self.horas(), |
360 |
|
self.segundos()) |
361 |
|
|
362 |
|
|
363 |
|
def __cmp__(self, otra): |
364 |
|
"""Compara dos intervalos de fechas. |
365 |
|
|
366 |
|
Devuelve -1, 0 o 1 si el segundo intervalo es más, igual o menos largo que éste. |
367 |
|
""" |
368 |
|
# Esto lo tengo que revisar un poco, no sé si funciona bien en todos los casos. |
369 |
|
if self.signo() > otra.signo(): |
370 |
|
return 1 |
371 |
|
elif self.signo() < otra.signo(): |
372 |
|
return -1 |
373 |
|
else: |
374 |
|
if self.anno() > otra.anno(): |
375 |
|
return 1 |
376 |
|
elif self.anno() < otra.anno(): |
377 |
|
return -1 |
378 |
|
else: |
379 |
|
if self.mes() > otra.mes(): |
380 |
|
return 1 |
381 |
|
elif self.mes() < otra.mes(): |
382 |
|
return -1 |
383 |
|
else: |
384 |
|
if self.dia() > otra.dia(): |
385 |
|
return 1 |
386 |
|
elif self.dia() < otra.dia(): |
387 |
|
return -1 |
388 |
|
else: |
389 |
|
if self.hora() > otra.hora(): |
390 |
|
return 1 |
391 |
|
elif self.hora() < otra.hora(): |
392 |
|
return -1 |
393 |
|
else: |
394 |
|
if self.segundo() > otra.segundo(): |
395 |
|
return 1 |
396 |
|
elif self.segundo() < otra.segundo(): |
397 |
|
return -1 |
398 |
|
else: |
399 |
|
return 0 |
400 |
|
|
401 |
|
|
402 |
|
def __sub__(self, otra): |
403 |
|
"""Resta este intervalo menos el otro. |
404 |
|
|
405 |
|
Devuelve la diferencia como una FechaHoraMineRel. |
406 |
|
""" |
407 |
|
# Restar es lo mismo que sumar el inverso. |
408 |
|
return self + otra.inverso() |
409 |
|
|
410 |
|
|
411 |
|
def __add__(self, otra): |
412 |
|
"""Suma un intervalo a este. |
413 |
|
|
414 |
|
Devuelve otra fecha relativa. |
415 |
|
""" |
416 |
|
if self.signo() == otra.signo(): |
417 |
|
signo = self.signo() |
418 |
|
else: |
419 |
|
if self.abs().signo() >= otra.abs().signo(): |
420 |
|
signo = self.signo() |
421 |
|
else: |
422 |
|
signo = otra.signo() |
423 |
|
|
424 |
|
if self.signo() == otra.signo(): |
425 |
|
return FechaHoraRelativa(signo, |
426 |
|
self.anno() + otra.anno(), |
427 |
|
self.mes() + otra.mes(), |
428 |
|
self.dia() + otra.dia(), |
429 |
|
self.hora() + otra.hora(), |
430 |
|
self.segundo() + otra.segundo()) |
431 |
|
else: |
432 |
|
return FechaHoraRelativa(signo, |
433 |
|
self.anno() - otra.anno(), |
434 |
|
self.mes() - otra.mes(), |
435 |
|
self.dia() - otra.dia(), |
436 |
|
self.hora() - otra.hora(), |
437 |
|
self.segundo() - otra.segundo()) |
438 |
|
|
439 |
|
|
440 |
|
|
441 |
|
# ------------------------------------ |
442 |
# Código de inicialización del módulo. |
# Código de inicialización del módulo. |
443 |
|
# ------------------------------------ |
444 |
|
|
445 |
|
# Este valor representa el número de segundos entre la Fecha R de Unix y la Fecha R real |
446 |
|
# de Minë. mktime() convierte una tupla de valores, en el número de segundos desde la |
447 |
|
# Fecha R de Unix. El número devuelto es float, así que lo convertimos a int redondeando. |
448 |
|
|
449 |
|
FechaHoraMine.FECHA_R_REAL_SEGUNDOS_TOTALES = int(mktime((FechaHoraMine.FECHA_R_REAL_ANNO, |
450 |
|
FechaHoraMine.FECHA_R_REAL_MES, |
451 |
|
FechaHoraMine.FECHA_R_REAL_DIA, |
452 |
|
FechaHoraMine.FECHA_R_REAL_HORA, |
453 |
|
FechaHoraMine.FECHA_R_REAL_MINUTO, |
454 |
|
FechaHoraMine.FECHA_R_REAL_SEGUNDO, |
455 |
|
-1, -1, -1)) + 0.5) |
456 |
|
|
457 |
# Este valor representa el número de segundos entre la Fecha 0 de Unix y la Fecha 0 real de Minë. |
# Los siguientes valores son simplemente para acelerar los cálculos internos |
458 |
# mktime() convierte una tupla de valores, en el número de segundos desde la Fecha 0 de Unix. |
|
459 |
# El número devuelto es float, así que lo convertimos a int redondeando. |
FechaHoraMine.SEGUNDOS_POR_DIA = FechaHoraMine.SEGUNDOS_POR_HORA * \ |
460 |
|
FechaHoraMine.HORAS_POR_DIA |
|
FechaHoraMine.FECHA0_REAL_SEGUNDOS_TOTALES = int(mktime((FechaHoraMine.FECHA0_REAL_ANNO, |
|
|
FechaHoraMine.FECHA0_REAL_MES, |
|
|
FechaHoraMine.FECHA0_REAL_DIA, |
|
|
FechaHoraMine.FECHA0_REAL_HORA, |
|
|
FechaHoraMine.FECHA0_REAL_MINUTO, |
|
|
FechaHoraMine.FECHA0_REAL_SEGUNDO, |
|
|
-1, -1, -1)) + 0.5) |
|
461 |
|
|
462 |
|
FechaHoraMine.SEGUNDOS_POR_MES = FechaHoraMine.SEGUNDOS_POR_DIA * \ |
463 |
|
FechaHoraMine.DIAS_POR_MES |
464 |
|
|
465 |
|
FechaHoraMine.SEGUNDOS_POR_ANNO = FechaHoraMine.SEGUNDOS_POR_MES * \ |
466 |
|
FechaHoraMine.MESES_POR_ANNO |
467 |
|
|
468 |
|
# ----------------------------------------- |
469 |
# Código para pruebas unitarias del módulo. |
# Código para pruebas unitarias del módulo. |
470 |
|
# ----------------------------------------- |
471 |
|
|
472 |
if (__name__ == '__main__'): |
if (__name__ == '__main__'): |
473 |
|
a = FechaHoraMine_crear(anno=2500, mes=8, dia=14) |
474 |
|
b = FechaHoraMine_crear(anno=2500, mes=9, dia=10) |
475 |
|
c = FechaHoraMine_crear(anno=2502, mes=5, dia=20) |
476 |
|
|
477 |
|
print "De [%s] a [%s] va [%s]" % (str(a), str(b), str(b - a)) |
478 |
|
print "De [%s] a [%s] va [%s]" % (str(c), str(a), str(a - c)) |
479 |
|
|
480 |
|
r = FechaHoraMineRel(signo=1, annos=4, meses=1, dias=40) |
481 |
|
|
482 |
|
print "[%s] mas [%s] es [%s]" % (str(a), str(r), str(a + r)) |
483 |
|
|
484 |
while 1: |
while 1: |
485 |
ahora = FechaHoraMine_ahora() |
ahora = FechaHoraMine_ahora() |
486 |
print ahora |
print "%s (%s)" % (ahora, ahora.desc_seccion()) |
487 |
sleep(1) |
sleep(1) |
488 |
|
|