def localize_timestamp(timestamp, user):
    try:
        user_timezone = dates.get_timezone(user.timezone)
    except LookupError:
        user_timezone = dates.get_timezone('Etc/UTC')

    try:
        user_locale = Locale(user.locale)
    except core.UnknownLocaleError:
        user_locale = Locale('en')

    # Do our best to find a valid locale
    try:
        user_locale.date_formats
    except IOError:  # An IOError will be raised if locale's casing is incorrect, e.g. de_de vs. de_DE
        # Attempt to fix the locale, e.g. de_de -> de_DE
        try:
            user_locale = Locale(fix_locale(user.locale))
            user_locale.date_formats
        except (core.UnknownLocaleError, IOError):
            user_locale = Locale('en')

    formatted_date = dates.format_date(timestamp, format='full', locale=user_locale)
    formatted_time = dates.format_time(timestamp, format='short', tzinfo=user_timezone, locale=user_locale)

    return u'{time} on {date}'.format(time=formatted_time, date=formatted_date)

def localize_timestamp(timestamp, user):
    try:
        user_timezone = dates.get_timezone(user.timezone)
    except LookupError:
        user_timezone = dates.get_timezone('Etc/UTC')

    try:
        user_locale = Locale(user.locale)
    except core.UnknownLocaleError:
        user_locale = 'en'

    formatted_date = dates.format_date(timestamp, format='full', locale=user_locale)
    formatted_time = dates.format_time(timestamp, format='short', tzinfo=user_timezone, locale=user_locale)

    return u'{time} on {date}'.format(time=formatted_time, date=formatted_date)

    def value_from_raw(self, raw):
        if raw.value is None:
            return raw.missing_value('Missing datetime')
        try:
            chunks = raw.value.split(' ')
            date_info = [int(bit) for bit in chunks[0].split('-')]
            time_info = [int(bit) for bit in chunks[1].split(':')]
            datetime_info = date_info + time_info
            result = datetime(*datetime_info)

            if len(chunks) > 2:
                try:
                    tz = get_timezone(chunks[-1])
                except LookupError:
                    if len(chunks[-1]) > 5:
                        chunks[-1] = chunks[-1][-5:]
                    delta = int(chunks[-1][1:3]) * 60 + int(chunks[-1][3:])
                    if chunks[-1][0] == '-':
                        delta *= -1
                    tz = FixedOffset(delta)
                return tz.localize(result)

            return result
        except Exception:
            return raw.bad_value('Bad date format')

def server_to_utc(dt):
    """Converts the given datetime in the server's TZ to UTC.

    The given datetime **MUST** be naive but already contain the correct time in the server's TZ.
    """
    server_tz = get_timezone(config.DEFAULT_TIMEZONE)
    return server_tz.localize(dt).astimezone(pytz.utc)

def test_format():
    l10n = L10n()

    d = date(2007, 4, 1)
    dformat = "EEE, MMM d, ''yy"
    expected = u"Sun, Apr 1, '07"
    assert l10n.format(d, dformat, locale='en') == expected

    dt = datetime(2007, 4, 1, 15, 30)
    dformat = "yyyyy.MMMM.dd GGG hh:mm a"
    expected = u'02007.April.01 AD 03:30 PM'
    assert l10n.format(dt, dformat, locale='en') == expected

    dt = datetime(2007, 4, 1, 15, 30, tzinfo=UTC)
    eastern = get_timezone('US/Eastern')
    dformat = 'H:mm Z'
    expected = u'11:30 -0400'
    assert l10n.format(dt, dformat, tzinfo=eastern, locale='en_US') == expected

    t = time(15, 30)
    tformat = "hh 'o''clock' a"
    expected = u"03 o'clock PM"
    assert l10n.format(t, tformat, locale='en') == expected

    delta = timedelta(days=6)
    assert l10n.format(delta, locale='en_US') == u'1 week'

    assert l10n.format(delta, granularity='month', locale='en_US') == u'1 month'

    assert l10n.format(1099, locale='en_US') == u'1,099'

    assert l10n.format(1.2345, locale='en_US') == u'1.234'

    assert l10n.format('test', locale='en') == 'test'
    assert l10n.format(None, locale='en_US') == ''

def event_to_utc(dt, event):
    """Converts a datetime of an event to UTC.

    :param dt: A naive :class:`datetime.datetime` object in UTC
    :param event: An :class:`.Conference` object from which to take the timezone
    """
    timezone = DisplayTZ(conf=event).getDisplayTZ()
    return get_timezone(timezone).localize(dt).astimezone(pytz.utc)

 def scheduled_dt(self):
     if self.schedule_type.data == 'absolute':
         dt = datetime.combine(self.absolute_date.data, self.absolute_time.data)
         return get_timezone(self.timezone).localize(dt).astimezone(pytz.utc)
     elif self.schedule_type.data == 'relative':
         return self.event.getStartDate() - self.relative_delta.data
     elif self.schedule_type.data == 'now':
         return now_utc()

def test_format_datetime_tzinfo():
    l10n = L10n()
    dt = datetime(2007, 4, 1, 15, 30, tzinfo=UTC)
    eastern = get_timezone('US/Eastern')

    dformat = 'H:mm Z'
    expected = u'11:30 -0400'
    assert l10n.format_datetime(dt, dformat, tzinfo=eastern, locale='en_US') == expected

def getdatelocalized(value):
    if value:
        from datetime import datetime
        from babel.dates import format_datetime, get_timezone

        return format_datetime(value, tzinfo=get_timezone(TIMEZONE), locale=LOCALE, format="d 'de' MMMM 'em' HH':'mm")
    else:
        return u"-"

def format_datetime(value, format='medium'):
    print(value)
    value = parse(str(value))

    if format == 'full':
        format="EEEE, d. MMMM y 'at' HH:mm"
    elif format == 'medium':
        format="EE dd.MM.y HH:mm"
    return dates.format_datetime(value, format, tzinfo=dates.get_timezone('Asia/Vladivostok'))

 def __init__(self,
              date_format='E MMMM d YYYY, h:mm a',
              timezone=None,
              ):
     self.date_format = date_format
     if timezone is not None:
         self.tzinfo = get_timezone(timezone)
     else:
         self.tzinfo = LOCALTZ

def normalize_timezone(tzinfo):
    if not tzinfo:
        return
    if isinstance(tzinfo, datetime.tzinfo):
        return tzinfo
    try:
        return get_timezone(tzinfo)
    except LookupError:
        return

def datetime_formatter(request, value, format='medium',
                       tzname=None, locale_name=None):
    """DateTime formatter

    Short::

      >> dt = datetime(2011, 2, 6, 10, 35, 45, 80, pytz.UTC)

      >> request.fmt.datetime(dt, 'short')
      '02/06/11 04:35 AM'


    Medium::

      >> request.fmt.datetime(dt, 'medium')
      'Feb 06, 2011 04:35 AM'

    Long::

      >> request.fmt.datetime(dt, 'long')
      'February 06, 2011 04:35 AM -0600'

    Full::

      >> request.fmt.datetime(dt, 'full')
      'Sunday, February 06, 2011 04:35:45 AM CST'

    """
    if not isinstance(value, datetime):
        return value

    tzinfo = None

    if tzname:
        tzinfo = get_timezone(tzname)

    if not tzinfo:
        settings = request.registry.settings
        tzinfo = get_timezone(settings['ptah.timezone'])

    if not locale_name:
        locale_name = request.locale_name

    return text_type(format_datetime(value, format, tzinfo, locale_name))

 def _get_defaults(self):
     reminder = self.reminder
     if reminder.is_relative:
         defaults_kwargs = {"schedule_type": "relative", "relative_delta": reminder.event_start_delta}
     else:
         # Use the user's preferred event timezone
         tz = get_timezone(DisplayTZ(conf=self.event).getDisplayTZ())
         dt = reminder.scheduled_dt.astimezone(tz)
         defaults_kwargs = {"schedule_type": "absolute", "absolute_date": dt.date(), "absolute_time": dt.time()}
     return FormDefaults(reminder, **defaults_kwargs)

def get_cert_date(force_date, locale, timezone):
    """
    Get pertinent date for display on cert
    """
    locale = locale or settings.DEFAULT_LOCALE
    timezone = timezone or settings.TIMEZONE

    if force_date:
        date = datetime.strptime(force_date, '%Y-%m-%d')
    else:
        from_zone = get_timezone(settings.TIMEZONE)
        to_zone = get_timezone(timezone)
        date = get_today()
        date = date.replace(tzinfo=from_zone)
        date = date.astimezone(to_zone)
    date = date.date()
    date = format_date(date, 'long', locale=locale)
    date = unicode(date)
    return date

def time_formatter(request, value, format='medium',
                   tzname=None, locale_name=None):
    """Time formatters
    """
    if not isinstance(value, datetime) and not isinstance(value, time):
        return value
    tzinfo = None

    if tzname:
        tzinfo = get_timezone(tzname)

    if not tzinfo:
        settings = request.registry.settings
        tzinfo = get_timezone(settings['ptah.timezone'])

    if not locale_name:
        locale_name = request.locale_name

    return text_type(format_time(value, format, tzinfo, locale_name))

def test_datetime_timezone_est(env, pad):
    field = make_field(env, 'datetime')
    with Context(pad=pad):
        # Known timezone name, EST
        rv = field.deserialize_value('2016-04-30 01:02:03 EST', pad=pad)
        assert isinstance(rv, datetime.datetime)
        assert rv.year == 2016
        assert rv.month == 4
        assert rv.day == 30
        assert rv.hour == 1
        assert rv.minute == 2
        assert rv.second == 3
        assert rv.tzinfo is get_timezone('EST')

def timezones_choices():
    """Timezones values and their labels for current locale.

    :return: an iterable of `(code, label)`, code being a timezone code and label
    the timezone name in current locale.
    """
    utcnow = pytz.utc.localize(datetime.utcnow())
    locale = _get_locale()
    for tz in sorted(pytz.common_timezones):
        tz = get_timezone(tz)
        now = tz.normalize(utcnow.astimezone(tz))
        label = "({}) {}".format(get_timezone_gmt(now, locale=locale), tz.zone)
        yield (tz, label)  # get_timezone_name(tz, locale=locale))

def format_time(t, format='short', locale=None, timezone=None, server_tz=False):
    """
    Basically a wrapper around Babel's own format_time
    """
    if not locale:
        locale = currentLocale()
    if not timezone and t.tzinfo:
        timezone = DisplayTZ().getDisplayTZ()
    elif server_tz:
        timezone = HelperMaKaCInfo.getMaKaCInfoInstance().getTimezone()
    if timezone:
        timezone = get_timezone(timezone)

    return _format_time(t, format=format, locale=locale, tzinfo=timezone).encode('utf-8')

def test_datetime_timezone_location(env, pad):
    field = make_field(env, 'datetime')
    with Context(pad=pad):
        # Known location name, Asia/Seoul
        rv = field.deserialize_value('2016-04-30 01:02:03 Asia/Seoul', pad=pad)
        assert isinstance(rv, datetime.datetime)
        assert rv.year == 2016
        assert rv.month == 4
        assert rv.day == 30
        assert rv.hour == 1
        assert rv.minute == 2
        assert rv.second == 3
        tzinfos = get_timezone('Asia/Seoul')._tzinfos  # pylint: disable=no-member
        assert rv.tzinfo in itervalues(tzinfos)