Separate naive/aware datetime pickers

ipywidgets/widgets/trait_types.py

@@ -121,6 +121,54 @@ def datetime_from_json(js, manager):
 }
 
 
+def naive_to_json(pydt, manager):
+    """Serialize a naive Python datetime object to json.
+
+    Instantiating a JavaScript Date object with a string assumes that the
+    string is a UTC string, while instantiating it with constructor arguments
+    assumes that it's in local time:
+
+    >>> cdate = new Date('2015-05-12')
+    Mon May 11 2015 20:00:00 GMT-0400 (Eastern Daylight Time)
+    >>> cdate = new Date(2015, 4, 12) // Months are 0-based indices in JS
+    Tue May 12 2015 00:00:00 GMT-0400 (Eastern Daylight Time)
+
+    Attributes of this dictionary are to be passed to the JavaScript Date
+    constructor.
+    """
+    if pydt is None:
+        return None
+    else:
+        naivedt = pydt.replace(tzinfo=None)
+        return dict(
+            year=naivedt.year,
+            month=naivedt.month - 1,  # Months are 0-based indices in JS
+            date=naivedt.day,
+            hours=naivedt.hour,  # Hours, Minutes, Seconds and Milliseconds
+            minutes=naivedt.minute,  # are plural in JS
+            seconds=naivedt.second,
+            milliseconds=naivedt.microsecond / 1000,
+        )
+
+
+def naive_from_json(js, manager):
+    """Deserialize a naive Python datetime object from json."""
+    if js is None:
+        return None
+    else:
+        return dt.datetime(
+            js["year"],
+            js["month"] + 1,  # Months are 1-based in Python
+            js["date"],
+            js["hours"],
+            js["minutes"],
+            js["seconds"],
+            js["milliseconds"] * 1000,
+        )
+
+naive_serialization = {"from_json": naive_from_json, "to_json": naive_to_json}
+
+
 def date_to_json(pydate, manager):
     """Serialize a Python date object.
 

ipywidgets/widgets/widget_datetime.py

@@ -10,7 +10,7 @@
 
 from traitlets import Unicode, Bool, validate, TraitError
 
-from .trait_types import datetime_serialization, Datetime
+from .trait_types import datetime_serialization, Datetime, naive_serialization
 from .valuewidget import ValueWidget
 from .widget import register
 from .widget_core import CoreWidget
@@ -20,7 +20,7 @@
 @register
 class DatetimePicker(DescriptionWidget, ValueWidget, CoreWidget):
     """
-    Display a widget for picking times.
+    Display a widget for picking datetimes.
 
     Parameters
     ----------
@@ -42,7 +42,7 @@ class DatetimePicker(DescriptionWidget, ValueWidget, CoreWidget):
 
     >>> import datetime
     >>> import ipydatetime
-    >>> datetime_pick = ipydatetime.TimePicker()
+    >>> datetime_pick = ipydatetime.DatetimePicker()
     >>> datetime_pick.value = datetime.datetime(2018, 09, 5, 12, 34, 3)
     """
 
@@ -55,10 +55,16 @@ class DatetimePicker(DescriptionWidget, ValueWidget, CoreWidget):
     min = Datetime(None, allow_none=True).tag(sync=True, **datetime_serialization)
     max = Datetime(None, allow_none=True).tag(sync=True, **datetime_serialization)
 
+    def _validate_tz(self, value):
+        if value.tzinfo is None:
+            raise TraitError('%s values needs to be timezone aware' % (self.__class__.__name__,))
+        return value
+
     @validate("value")
     def _validate_value(self, proposal):
         """Cap and floor value"""
         value = proposal["value"]
+        value = self._validate_tz(value)
         if self.min and self.min > value:
             value = max(value, self.min)
         if self.max and self.max < value:
@@ -69,6 +75,7 @@ def _validate_value(self, proposal):
     def _validate_min(self, proposal):
         """Enforce min <= value <= max"""
         min = proposal["value"]
+        min = self._validate_tz(min)
         if self.max and min > self.max:
             raise TraitError("Setting min > max")
         if self.value and min > self.value:
@@ -79,8 +86,53 @@ def _validate_min(self, proposal):
     def _validate_max(self, proposal):
         """Enforce min <= value <= max"""
         max = proposal["value"]
+        max = self._validate_tz(max)
         if self.min and max < self.min:
             raise TraitError("setting max < min")
         if self.value and max < self.value:
             self.value = max
         return max
+
+
+@register
+class NaiveDatetimePicker(DatetimePicker):
+    """
+    Display a widget for picking naive datetimes (i.e. timezone unaware).
+
+    Parameters
+    ----------
+
+    value: datetime.datetime
+        The current value of the widget.
+
+    disabled: bool
+        Whether to disable user changes.
+
+    min: datetime.datetime
+        The lower allowed datetime bound
+
+    max: datetime.datetime
+        The upper allowed datetime bound
+
+    Examples
+    --------
+
+    >>> import datetime
+    >>> import ipydatetime
+    >>> datetime_pick = ipydatetime.NaiveDatetimePicker()
+    >>> datetime_pick.value = datetime.datetime(2018, 09, 5, 12, 34, 3)
+    """
+
+    # Replace the serializers and model names:
+
+    _model_name = Unicode("NaiveDatetimeModel").tag(sync=True)
+
+    value = Datetime(None, allow_none=True).tag(sync=True, **naive_serialization)
+
+    min = Datetime(None, allow_none=True).tag(sync=True, **naive_serialization)
+    max = Datetime(None, allow_none=True).tag(sync=True, **naive_serialization)
+
+    def _validate_tz(self, value):
+        if value.tzinfo is not None:
+            raise TraitError('%s values needs to be timezone unaware' % (self.__class__.__name__,))
+        return value

packages/controls/src/widget_datetime.ts

@@ -305,3 +305,94 @@ namespace Private {
     return value ? dt_as_dt_string(value).split('T', 2)[1] : '';
   }
 }
+
+export interface ISerializedNaiveDatetime {
+  /**
+   * full year
+   */
+  year: number;
+
+  /**
+   * zero-based month (0 means January, 11 means December)
+   */
+  month: number;
+
+  /**
+   * day of month
+   */
+  date: number;
+
+  /**
+   * hour (24H format)
+   */
+  hours: number;
+
+  /**
+   * minutes
+   */
+  minutes: number;
+
+  /**
+   * seconds
+   */
+  seconds: number;
+
+  /**
+   * millisconds
+   */
+  milliseconds: number;
+}
+
+export function serialize_naive(
+  value: Date | null
+): ISerializedNaiveDatetime | null {
+  if (value === null) {
+    return null;
+  } else {
+    return {
+      year: value.getFullYear(),
+      month: value.getMonth(),
+      date: value.getDate(),
+      hours: value.getHours(),
+      minutes: value.getMinutes(),
+      seconds: value.getSeconds(),
+      milliseconds: value.getMilliseconds()
+    };
+  }
+}
+
+export function deserialize_naive(
+  value: ISerializedNaiveDatetime
+): Date | null {
+  if (value === null) {
+    return null;
+  } else {
+    const date = new Date();
+    date.setFullYear(value.year, value.month, value.date);
+    date.setHours(
+      value.hours,
+      value.minutes,
+      value.seconds,
+      value.milliseconds
+    );
+    return date;
+  }
+}
+
+export const naive_serializers = {
+  serialize: serialize_naive,
+  deserialize: deserialize_naive
+};
+
+export class NaiveDatetimeModel extends DatetimeModel {
+  defaults(): Backbone.ObjectHash {
+    return { ...super.defaults(), _model_name: 'NaiveDatetimeModel' };
+  }
+
+  static serializers: ISerializers = {
+    ...CoreDescriptionModel.serializers,
+    value: naive_serializers,
+    min: naive_serializers,
+    max: naive_serializers
+  };
+}

packages/controls/test/src/widget_datetime_test.ts

@@ -11,7 +11,7 @@ import {
   createTestModelFromSerialized
 } from './utils';
 
-import { DatetimeModel, DatetimeView } from '../../lib';
+import { DatetimeModel, DatetimeView, NaiveDatetimeModel } from '../../lib';
 
 describe('Datetime', () => {
   const date = new Date();
@@ -112,4 +112,89 @@ describe('Datetime', () => {
       expect(view.model).to.equal(model);
     });
   });
+
+  describe('NaiveDatetimeModel', () => {
+    it('should be createable', () => {
+      const model = createTestModel(NaiveDatetimeModel);
+      expect(model).to.be.an.instanceof(NaiveDatetimeModel);
+      expect(model.get('value')).to.be.a('null');
+    });
+
+    it('should be createable with a value', () => {
+      const state = { value: date };
+      const model = createTestModel(NaiveDatetimeModel, state);
+      expect(model).to.be.an.instanceof(NaiveDatetimeModel);
+      expect(model.get('value')).to.eql(date);
+    });
+
+    it('should serialize as expected', async () => {
+      const state_in = {
+        value: {
+          year: 2002,
+          month: 2,
+          date: 20,
+          hours: 20,
+          minutes: 2,
+          seconds: 20,
+          milliseconds: 2
+        }
+      };
+
+      const model = await createTestModelFromSerialized(
+        NaiveDatetimeModel,
+        state_in
+      );
+      model.widget_manager.register_model(
+        model.model_id,
+        Promise.resolve(model)
+      );
+
+      const state_out = await (model.widget_manager as DummyManager).get_state();
+      const models = Object.keys(state_out.state).map(
+        k => state_out.state[k].state
+      );
+      expect(models.length).to.eql(1);
+      expect(models[0]._model_name).to.be('NaiveDatetimeModel');
+      expect(models[0].value).to.eql(state_in.value);
+    });
+
+    it('should deserialize to Date object', async () => {
+      const state_in = {
+        value: {
+          year: 2002,
+          month: 2,
+          date: 20,
+          hours: 20,
+          minutes: 2,
+          seconds: 20,
+          milliseconds: 2
+        }
+      };
+
+      const model = await createTestModelFromSerialized(
+        NaiveDatetimeModel,
+        state_in
+      );
+      expect(model.get('value')).to.eql(new Date(2002, 2, 20, 20, 2, 20, 2));
+    });
+
+    it('should deserialize null', async () => {
+      const state_in = { value: null };
+
+      const model = await createTestModelFromSerialized(
+        NaiveDatetimeModel,
+        state_in
+      );
+      expect(model.get('value')).to.be.a('null');
+    });
+
+    it('should deserialize undefined', async () => {
+      const state_in = {};
+      const model = await createTestModelFromSerialized(
+        NaiveDatetimeModel,
+        state_in
+      );
+      expect(model.get('value')).to.be.a('null');
+    });
+  });
 });