[GR-12896] time.gmtime() doesn't work without parameter.

PullRequest: graalpython/315

Author: ppisl

graalpython/com.oracle.graal.python.test/src/tests/test_time.py

@@ -71,6 +71,32 @@ def test_new_struct_time(self):
         self.assertRaises(TypeError, time.struct_time, (2018, 11, 26, 17, 34, 12, 0, 340))
         self.assertRaises(TypeError, time.struct_time, (2018, 11, 26, 17, 34, 12, 0, 340, 9, 10, 11, 12))
 
+    def test_from_times(self):
+        gt = time.gmtime()
+        self.assertNotEqual(gt.tm_zone, None)
+        self.assertNotEqual(gt.tm_gmtoff, None)
+        
+        lt = time.localtime()
+        self.assertNotEqual(lt.tm_zone, None)
+        self.assertNotEqual(lt.tm_gmtoff, None)
+        
+    def test_destructuring_assignment(self):
+        t = time.struct_time((1,2,3,4,5,6,7,8,9))
+        y,m,d,h,mi,s,wd,yd,dst = t
+        self.assertEqual(y, 1)
+        self.assertEqual(mi, 5)
+        self.assertEqual(dst, 9)
+        self.assertEqual(t.tm_zone, None)
+        self.assertEqual(t.tm_gmtoff, None)
+        
+        t = time.struct_time((11,12,13,14,15,16,17,18,19,20, 21))
+        y,m,d,h,mi,s,wd,yd,dst = t
+        self.assertEqual(y, 11)
+        self.assertEqual(mi, 15)
+        self.assertEqual(dst, 19)
+        self.assertEqual(t.tm_zone, 20)
+        self.assertEqual(t.tm_gmtoff, 21)
+
 class StrftimeTests(unittest.TestCase):
 
     def check_format(self, format, date, expectedStr):

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/TimeModuleBuiltins.java

@@ -71,9 +71,8 @@ public static double timeSeconds() {
 
     @TruffleBoundary
     private static Object[] getTimeStruct(double seconds, boolean local) {
-        Object[] timeStruct = new Object[9];
+        Object[] timeStruct = new Object[11];
         Instant instant = Instant.ofEpochSecond((long) seconds);
-
         ZoneId zone = (local) ? ZoneId.systemDefault() : ZoneId.of("GMT");
         ZonedDateTime zonedDateTime = LocalDateTime.ofInstant(instant, zone).atZone(zone);
         timeStruct[0] = zonedDateTime.getYear();
@@ -85,6 +84,8 @@ private static Object[] getTimeStruct(double seconds, boolean local) {
         timeStruct[6] = zonedDateTime.getDayOfWeek().getValue();
         timeStruct[7] = zonedDateTime.getDayOfYear();
         timeStruct[8] = (zonedDateTime.getZone().getRules().isDaylightSavings(instant)) ? 1 : 0;
+        timeStruct[9] = zone.getId();
+        timeStruct[10] = zonedDateTime.getOffset().getTotalSeconds();
 
         return timeStruct;
     }
@@ -94,6 +95,17 @@ private static Object[] getTimeStruct(double seconds, boolean local) {
     @GenerateNodeFactory
     @TypeSystemReference(PythonArithmeticTypes.class)
     public abstract static class PythonGMTimeNode extends PythonBuiltinNode {
+
+        @Specialization
+        public PTuple gmtime(@SuppressWarnings("unused") PNone seconds) {
+            return factory().createTuple(getTimeStruct(timeSeconds(), false));
+        }
+
+        @Specialization
+        public PTuple gmtime(long seconds) {
+            return factory().createTuple(getTimeStruct(seconds, false));
+        }
+
         @Specialization
         public PTuple gmtime(double seconds) {
             return factory().createTuple(getTimeStruct(seconds, false));

graalpython/lib-graalpython/time.py

@@ -40,23 +40,30 @@
 
 def make_struct_time():
     from _descriptor import make_named_tuple_class
-    fields = ["tm_year", "tm_mon", "tm_mday", "tm_hour", "tm_min", "tm_sec", "tm_wday", "tm_yday", "tm_isdst", "tm_zone", "tm_gmtoff"]
+    fields = ["tm_year", "tm_mon", "tm_mday", "tm_hour", "tm_min", "tm_sec", "tm_wday", "tm_yday", "tm_isdst"]
     struct_time_type = make_named_tuple_class("struct_time", fields)
 
     class struct_time(struct_time_type):
-
+        
         def __new__(cls, iterable):
+            def create_struct(iter, zone, gmtoff):
+                result = tuple.__new__(cls, iter)
+                result.tm_zone = zone
+                result.tm_gmtoff = gmtoff
+                return result
+
             count = len(iterable)
             if (count < 9):
                 raise TypeError("time.struct_time() takes an at least 9-sequence (%d-sequence given)" % count)
             if (count > 11):
                 raise TypeError("time.struct_time() takes an at most 11-sequence (%d-sequence given)" % count)
             if count == 11:
-                return tuple.__new__(cls, iterable)
+                return create_struct(iterable[0:9], iterable[9], iterable[10])
             if count == 10:
-                return tuple.__new__(cls, iterable + (None, ))
+                return create_struct(iterable[0:9], iterable[9], None)
             if count == 9:
-                return tuple.__new__(cls, iterable + (None,  None)) 
+                return create_struct(iterable, None, None)
+                
 
         def __repr__(self):
             text = "{}(".format(self.__class__.__name__)
@@ -74,8 +81,10 @@ def __repr__(self):
 struct_time = make_struct_time()
 del make_struct_time
 
+_STRUCT_TM_ITEMS = 11
+
 @__builtin__
-def gmtime(seconds):
+def gmtime(seconds=None):
     return struct_time(__truffle_gmtime_tuple__(seconds))