예제 #1
0
파일: parser.py 프로젝트: mkodekar/sanctum
 def parse(self,
           timestr,
           default=None,
           ignoretz=False,
           tzinfos=None,
           **kwargs):
     if not default:
         default = datetime.datetime.now().replace(hour=0,
                                                   minute=0,
                                                   second=0,
                                                   microsecond=0)
     res = self._parse(timestr, **kwargs)
     if res is None:
         raise ValueError, "unknown string format"
     repl = {}
     for attr in [
             "year", "month", "day", "hour", "minute", "second",
             "microsecond"
     ]:
         value = getattr(res, attr)
         if value is not None:
             repl[attr] = value
     ret = default.replace(**repl)
     if res.weekday is not None and not res.day:
         ret = ret + relativedelta.relativedelta(weekday=res.weekday)
     if not ignoretz:
         if callable(tzinfos) or tzinfos and res.tzname in tzinfos:
             if callable(tzinfos):
                 tzdata = tzinfos(res.tzname, res.tzoffset)
             else:
                 tzdata = tzinfos.get(res.tzname)
             if isinstance(tzdata, datetime.tzinfo):
                 tzinfo = tzdata
             elif isinstance(tzdata, basestring):
                 tzinfo = tz.tzstr(tzdata)
             elif isinstance(tzdata, int):
                 tzinfo = tz.tzoffset(res.tzname, tzdata)
             else:
                 raise ValueError, "offset must be tzinfo subclass, " \
                                   "tz string, or int offset"
             ret = ret.replace(tzinfo=tzinfo)
         elif res.tzname and res.tzname in time.tzname:
             ret = ret.replace(tzinfo=tz.tzlocal())
         elif res.tzoffset == 0:
             ret = ret.replace(tzinfo=tz.tzutc())
         elif res.tzoffset:
             ret = ret.replace(tzinfo=tz.tzoffset(res.tzname, res.tzoffset))
     return ret
예제 #2
0
 def parse(self, timestr, default=None,
                 ignoretz=False, tzinfos=None,
                 pastweekdays=False,
                 **kwargs):
     if not default:
         default = datetime.datetime.now().replace(hour=0, minute=0,
                                                   second=0, microsecond=0)
     res = self._parse(timestr, **kwargs)
     if res is None:
         raise ValueError, "unknown string format"
     repl = {}
     for attr in ["year", "month", "day", "hour",
                  "minute", "second", "microsecond"]:
         value = getattr(res, attr)
         if value is not None:
             repl[attr] = value
     ret = default.replace(**repl)
     if res.weekday is not None and not res.day:
         wd = relativedelta.weekdays[res.weekday](pastweekdays and -1 or +1)
         ret = ret+relativedelta.relativedelta(weekday=wd)
     if not ignoretz:
         if callable(tzinfos) or tzinfos and res.tzname in tzinfos:
             if callable(tzinfos):
                 tzdata = tzinfos(res.tzname, res.tzoffset)
             else:
                 tzdata = tzinfos.get(res.tzname)
             if isinstance(tzdata, datetime.tzinfo):
                 tzinfo = tzdata
             elif isinstance(tzdata, basestring):
                 tzinfo = tz.tzstr(tzdata)
             elif isinstance(tzdata, int):
                 tzinfo = tz.tzoffset(res.tzname, tzdata)
             else:
                 raise ValueError, "offset must be tzinfo subclass, " \
                                   "tz string, or int offset"
             ret = ret.replace(tzinfo=tzinfo)
         elif res.tzname and res.tzname in time.tzname:
             ret = ret.replace(tzinfo=tz.tzlocal())
         elif res.tzoffset == 0:
             ret = ret.replace(tzinfo=tz.tzutc())
         elif res.tzoffset:
             ret = ret.replace(tzinfo=tz.tzoffset(res.tzname, res.tzoffset))
     return ret
예제 #3
0
 def parse(self, timestr, default=None, ignoretz=False, tzinfos=None, fuzzyreturn=False, **kwargs):
     if not default:
         default = datetime.datetime.now().replace(hour=0, minute=0, second=0, microsecond=0)
     res = self._parse(timestr, **kwargs)
     if res is None:
         raise ValueError, "unknown string format"
     repl = {}
     for attr in ["year", "month", "day", "hour", "minute", "second", "microsecond"]:
         value = getattr(res, attr)
         if value is not None:
             repl[attr] = value
     ret = default.replace(**repl)
     if res.weekday is not None and not res.day:
         ret = ret + relativedelta.relativedelta(weekday=res.weekday)
     if not ignoretz:
         if callable(tzinfos) or tzinfos and res.tzname in tzinfos:
             if callable(tzinfos):
                 tzdata = tzinfos(res.tzname, res.tzoffset)
             else:
                 tzdata = tzinfos.get(res.tzname)
             if isinstance(tzdata, datetime.tzinfo):
                 tzinfo = tzdata
             elif isinstance(tzdata, basestring):
                 tzinfo = tz.tzstr(tzdata)
             elif isinstance(tzdata, int):
                 tzinfo = tz.tzoffset(res.tzname, tzdata)
             else:
                 raise ValueError, "offset must be tzinfo subclass, " "tz string, or int offset"
             ret = ret.replace(tzinfo=tzinfo)
         elif res.tzname and res.tzname in time.tzname:
             ret = ret.replace(tzinfo=tz.tzlocal())
         elif res.tzoffset == 0:
             ret = ret.replace(tzinfo=tz.tzutc())
         elif res.tzoffset:
             ret = ret.replace(tzinfo=tz.tzoffset(res.tzname, res.tzoffset))
     if fuzzyreturn:
         if not repl.has_key("month"):
             # return a fuzzy answer: an object representing a whole year
             return relativedelta.relativedelta(year=ret.year, years=+1)
         elif not repl.has_key("day"):
             # return a fuzzy answer: an object representing a whole month
             return relativedelta.relativedelta(year=ret.year, month=ret.month, months=+1)
         elif not repl.has_key("hour"):
             # return a fuzzy answer: an object representing a whole day
             return relativedelta.relativedelta(year=ret.year, month=ret.month, day=ret.day, days=+1)
         elif not repl.has_key("minute"):
             # return a fuzzy answer: an object representing a whole hour
             return relativedelta.relativedelta(year=ret.year, month=ret.month, day=ret.day, hour=ret.hour, hours=+1)
         elif not repl.has_key("second"):
             # return a fuzzy answer: an object representing a whole minute
             return relativedelta.relativedelta(
                 year=ret.year, month=ret.month, day=ret.day, hour=ret.hour, minute=ret.minute, minutes=+1
             )
         elif not repl.has_key("microsecond"):
             # return a fuzzy answer: an object representing a whole second
             return relativedelta.relativedelta(
                 year=ret.year,
                 month=ret.month,
                 day=ret.day,
                 hour=ret.hour,
                 minute=ret.minute,
                 second=ret.second,
                 seconds=+1,
             )
     return ret