/[ambar]/ambar/fechahoramine.py
ViewVC logotype

Diff of /ambar/fechahoramine.py

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.1 by amoyav, Sun Oct 20 10:46:59 2002 UTC revision 1.2 by amoyav, Sun Oct 27 10:16:28 2002 UTC
# Line 21  Line 21 
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
# Line 42  class FechaHoraMine: Line 50  class FechaHoraMine:
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
# Line 106  class FechaHoraMine: Line 139  class FechaHoraMine:
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    

Legend:
Removed from v.1.1  
changed lines
  Added in v.1.2

savannah-hackers-public@gnu.org
ViewVC Help
Powered by ViewVC 1.1.26