^Q\@sdZddlmZddlmZmZmZddlmZddl m Z ddl m Z ddl Z ddlZddlZddlmZmZmZmZGd d d eZejeje_ejeje_dS) z_ Provides the :class:`Arrow ` class, an enhanced ``datetime`` replacement. )absolute_import)datetime timedeltatzinfo)tz) relativedelta)truncN)utillocalesparser formatterc@seZdZdZejZdddddddgZd d eDZd Zd d d d d ddZ e d ddZ e ddZ e d ddZ e ddZe d ddZe d ddZe d ddZe d d d ddZe d d d d!Ze d"d d#d$Zd%d&Zd'd(Zd)d*Zd+d,Zd-d.Zed/d0Zejd1d0Zed2d3Zed4d5Zed6d7Zed8d9Zd:d;Z d<d=Z!d>d?Z"d@dAZ#d"dBdCZ$dDdEZ%dFdGZ&dHdIdJdKZ'd dIdLdMdNdOZ(dPdQZ)dRdSZ*dTdUZ+dVdWZ,dXdYZ-dZd[Z.d\d]Z/d^d_Z0d`daZ1dbdcZ2dddeZ3dfdgZ4dhdiZ5djdkZ6dldmZ7dndoZ8dpdqZ9drdsZ:dtduZ;dvdwZ<dxdyZ=dzd{Z>d|d}Z?d~ddZ@ddZAddZBddZCeDddZEe ddZFe ddZGe ddZHeDddZId S)ArrowaAn :class:`Arrow ` object. Implements the ``datetime`` interface, behaving as an aware ``datetime`` while implementing additional functionality. :param year: the calendar year. :param month: the calendar month. :param day: the calendar day. :param hour: (optional) the hour. Defaults to 0. :param minute: (optional) the minute, Defaults to 0. :param second: (optional) the second, Defaults to 0. :param microsecond: (optional) the microsecond. Defaults 0. :param tzinfo: (optional) A timezone expression. Defaults to UTC. .. _tz-expr: Recognized timezone expressions: - A ``tzinfo`` object. - A ``str`` describing a timezone, similar to 'US/Pacific', or 'Europe/Berlin'. - A ``str`` in ISO-8601 style, as in '+07:00'. - A ``str``, one of the following: 'local', 'utc', 'UTC'. Usage:: >>> import arrow >>> arrow.Arrow(2013, 5, 5, 12, 30, 45) yearmonthdayhourminutesecond microsecondcCsg|]}dj|qS)z{0}s)format).0ar@/var/www/dbchiro/venv/lib/python3.4/site-packages/arrow/arrow.py 9s zArrow.rNc Cs^tj|r$tjj|}n|p3tj}t|||||||||_dS)N) r Zisstrr TzinfoParserparse dateutil_tztzutcr _datetime) selfrrrrrrrrrrr__init__<s zArrow.__init__c Cs|tjjdtj}|j|dkr<tjn|}||j|j|j |j |j |j |j |jS)zConstructs an :class:`Arrow ` object, representing "now" in the given timezone. :param tzinfo: (optional) a ``tzinfo`` object. Defaults to local time. rN)rutcnowreplacerr astimezonetzlocalrrrrrrrr)clsrutcdtrrrnowIs ''z Arrow.nowc CsFtj}||j|j|j|j|j|j|jt j S)zk Constructs an :class:`Arrow ` object, representing "now" in UTC time. ) rr#rrrrrrrrr)r'r)rrrr#Xs 'z Arrow.utcnowc Csj|ptj}|j|}tj||}||j|j|j|j|j |j |j |j S)a Constructs an :class:`Arrow ` object from a timestamp, converted to the given timezone. :param timestamp: an ``int`` or ``float`` timestamp, or a ``str`` that converts to either. :param tzinfo: (optional) a ``tzinfo`` object. Defaults to local time. Timestamps should always be UTC. If you have a non-UTC timestamp:: >>> arrow.Arrow.utcfromtimestamp(1367900664).replace(tzinfo='US/Pacific') ) rr&_get_timestamp_from_inputr fromtimestamprrrrrrrr)r' timestamprr)rrrr,ds 'zArrow.fromtimestampc CsX|j|}tj|}||j|j|j|j|j|j|j t j S)zConstructs an :class:`Arrow ` object from a timestamp, in UTC time. :param timestamp: an ``int`` or ``float`` timestamp, or a ``str`` that converts to either. ) r+rutcfromtimestamprrrrrrrrr)r'r-r)rrrr.zs'zArrow.utcfromtimestampc CsO|p|jptj}||j|j|j|j|j|j|j |S)a@ Constructs an :class:`Arrow ` object from a ``datetime`` and optional replacement timezone. :param dt: the ``datetime`` :param tzinfo: (optional) A :ref:`timezone expression `. Defaults to ``dt``'s timezone, or UTC if naive. If you only want to replace the timezone of naive datetimes:: >>> dt datetime.datetime(2013, 5, 5, 0, 0, tzinfo=tzutc()) >>> arrow.Arrow.fromdatetime(dt, dt.tzinfo or 'US/Pacific') ) rrrrrrrrrr)r'r)rrrr fromdatetimes'zArrow.fromdatetimecCs1|ptj}||j|j|jd|S)a Constructs an :class:`Arrow ` object from a ``date`` and optional replacement timezone. Time values are set to 0. :param date: the ``date`` :param tzinfo: (optional) A :ref:`timezone expression `. Defaults to UTC. r)rrrrr)r'daterrrrfromdates zArrow.fromdatec CsUtj||}|p|j}||j|j|j|j|j|j|j |S)a Constructs an :class:`Arrow ` object from a date string and format, in the style of ``datetime.strptime``. Optionally replaces the parsed timezone. :param date_str: the date string. :param fmt: the format string. :param tzinfo: (optional) A :ref:`timezone expression `. Defaults to the parsed timezone if ``fmt`` contains a timezone directive, otherwise UTC. ) rstrptimerrrrrrrr)r'Zdate_strfmtrr)rrrr2s 'zArrow.strptimec s|j|\}}}|j|dkr3|jn|} |j|jd| }|j||\}}|j|jd| }|j|g} xn|krt| |kr| jfdd|j D} |d| | t i||6qW| S)a Returns a list of :class:`Arrow ` objects, representing an iteration of time between two inputs. :param frame: the timeframe. Can be any ``datetime`` property (day, hour, minute...). :param start: A datetime expression, the start of the range. :param end: (optional) A datetime expression, the end of the range. :param tz: (optional) A :ref:`timezone expression `. Defaults to ``start``'s timezone, or UTC if ``start`` is naive. :param limit: (optional) A maximum number of tuples to return. **NOTE**: The ``end`` or ``limit`` must be provided. Call with ``end`` alone to return the entire range. Call with ``limit`` alone to return a maximum # of results from the start. Call with both to cap a range at a maximum # of results. **NOTE**: ``tz`` internally **replaces** the timezones of both ``start`` and ``end`` before iterating. As such, either call with naive objects and ``tz``, or aware objects from the same timezone and no ``tz``. Supported frame values: year, quarter, month, week, day, hour, minute, second. Recognized datetime expressions: - An :class:`Arrow ` object. - A ``datetime`` object. Usage:: >>> start = datetime(2013, 5, 5, 12, 30) >>> end = datetime(2013, 5, 5, 17, 15) >>> for r in arrow.Arrow.range('hour', start, end): ... print(repr(r)) ... **NOTE**: Unlike Python's ``range``, ``end`` *may* be included in the returned list:: >>> start = datetime(2013, 5, 5, 12, 30) >>> end = datetime(2013, 5, 5, 13, 30) >>> for r in arrow.Arrow.range('hour', start, end): ... print(repr(r)) ... Nrcsg|]}t|qSr)getattr)rf)currentrrrs zArrow.range..) _get_frames _get_tzinfor _get_datetimer$_get_iteration_paramsr/lenappend_ATTRSr) r'framestartendrlimit_frame_relativerelative_stepsrresultsvaluesr)r6rranges4$! 'z Arrow.rangecsu|j|dkr|jn|}|j||jd}|j||||}fdd|DS)a Returns a list of tuples, each :class:`Arrow ` objects, representing a series of timespans between two inputs. :param frame: the timeframe. Can be any ``datetime`` property (day, hour, minute...). :param start: A datetime expression, the start of the range. :param end: (optional) A datetime expression, the end of the range. :param tz: (optional) A :ref:`timezone expression `. Defaults to ``start``'s timezone, or UTC if ``start`` is naive. :param limit: (optional) A maximum number of tuples to return. **NOTE**: The ``end`` or ``limit`` must be provided. Call with ``end`` alone to return the entire range. Call with ``limit`` alone to return a maximum # of results from the start. Call with both to cap a range at a maximum # of results. **NOTE**: ``tz`` internally **replaces** the timezones of both ``start`` and ``end`` before iterating. As such, either call with naive objects and ``tz``, or aware objects from the same timezone and no ``tz``. Supported frame values: year, quarter, month, week, day, hour, minute, second. Recognized datetime expressions: - An :class:`Arrow ` object. - A ``datetime`` object. **NOTE**: Unlike Python's ``range``, ``end`` will *always* be included in the returned list of timespans. Usage: >>> start = datetime(2013, 5, 5, 12, 30) >>> end = datetime(2013, 5, 5, 17, 15) >>> for r in arrow.Arrow.span_range('hour', start, end): ... print(r) ... (, ) (, ) (, ) (, ) (, ) (, ) Nrcsg|]}|jqSr)span)rr)r>rrr:s z$Arrow.span_range..)r8rr/rHrG)r'r>r?r@rrArZ_ranger)r>r span_range s.$zArrow.span_rangecsmdkrtdn|j||||t}fddtd|DS)a4 Returns an array of tuples, each :class:`Arrow ` objects, representing a series of intervals between two inputs. :param frame: the timeframe. Can be any ``datetime`` property (day, hour, minute...). :param start: A datetime expression, the start of the range. :param end: (optional) A datetime expression, the end of the range. :param interval: (optional) Time interval for the given time frame. :param tz: (optional) A timezone expression. Defaults to UTC. Supported frame values: year, quarter, month, week, day, hour, minute, second Recognized datetime expressions: - An :class:`Arrow ` object. - A ``datetime`` object. Recognized timezone expressions: - A ``tzinfo`` object. - A ``str`` describing a timezone, similar to 'US/Pacific', or 'Europe/Berlin'. - A ``str`` in ISO-8601 style, as in '+07:00'. - A ``str``, one of the following: 'local', 'utc', 'UTC'. Usage: >>> start = datetime(2013, 5, 5, 12, 30) >>> end = datetime(2013, 5, 5, 17, 15) >>> for r in arrow.Arrow.interval('hour', start, end, 2): ... print r ... (, ) (, ) (, ) rKz%interval has to be a positive integercs4g|]*}|d|ddfqS)rrKr)ri)interval spanRangerrrfs z"Arrow.interval..r) ValueErrorrJr;rG)r'r>r?r@rMrZboundr)rMrNrrM<s $ zArrow.intervalcCsdj|jj|jS)Nz <{0} [{1}]>)r __class____name____str__)r!rrr__repr__jszArrow.__repr__cCs |jjS)N)r isoformat)r!rrrrRmsz Arrow.__str__cCs)t|dkr|j|St|S)Nr)r;rstr)r!Z formatstrrrr __format__ps zArrow.__format__cCs |jjS)N)r __hash__)r!rrrrWwszArrow.__hash__cCs|dkr|jdS|dkrBt|jd|jdS|jdsyt|j|d}|dk ry|Sntj||S)NweekrKquarterrB) isocalendarintr_MONTHS_PER_QUARTER startswithr4r object__getattribute__)r!namevaluerrr __getattr__}s   zArrow.__getattr__cCs |jjS)zG Gets the ``tzinfo`` of the :class:`Arrow ` object. )r r)r!rrrrsz Arrow.tzinfocCs|jjd||_dS)zG Sets the ``tzinfo`` of the :class:`Arrow ` object. rN)r r$)r!rrrrrscCs|jS)zU Returns a datetime representation of the :class:`Arrow ` object. )r )r!rrrrszArrow.datetimecCs|jjddS)zc Returns a naive datetime representation of the :class:`Arrow ` object. rN)r r$)r!rrrnaivesz Arrow.naivecCstj|jjS)zk Returns a timestamp representation of the :class:`Arrow ` object, in UTC time. )calendartimegmr utctimetuple)r!rrrr-szArrow.timestampcCs|jt|jdS)zp Returns a floating-point representation of the :class:`Arrow ` object, in UTC time. i@B)r-floatr)r!rrrfloat_timestampszArrow.float_timestampcCs|j|jS)z Returns a new :class:`Arrow ` object, cloned from the current one. Usage: >>> arw = arrow.utcnow() >>> cloned = arw.clone() )r/r )r!rrrclones z Arrow.clonecKsdi}i}x|jD]\}}||jkrA|||` object with attributes updated according to inputs. Use property names to set their value absolutely:: >>> import arrow >>> arw = arrow.utcnow() >>> arw >>> arw.replace(year=2014, month=6) You can also replace the timezone without conversion, using a :ref:`timezone expression `:: >>> arw.replace(tzinfo=tz.tzlocal()) weeksquarterszOreplace() with plural property to shift valueis deprecated, use shift() insteadrXrYz%setting absolute {0} is not supportedrzunknown attribute: "{0}"monthsrN)zweeksrk)zweekzquarter)itemsr= _ATTRS_PLURALwarningswarnDeprecationWarningAttributeErrorr setdefaultpopr\r r$rgetr8r/)r!kwargsZabsolute_kwargsrelative_kwargskeyrar6rrrrr$s,     ! z Arrow.replacecKsi}xK|jD]=\}}||jks:|dkrG|||` object with attributes updated according to inputs. Use pluralized property names to shift their current value relatively: >>> import arrow >>> arw = arrow.utcnow() >>> arw >>> arw.shift(years=1, months=-1) Day-of-the-week relative shifting can use either Python's weekday numbers (Monday = 0, Tuesday = 1 .. Sunday = 6) or using dateutil.relativedelta's day instances (MO, TU .. SU). When using weekday numbers, the returned date will always be greater than or equal to the starting date. Using the above code (which is a Saturday) and asking it to shift to Saturday: >>> arw.shift(weekday=5) While asking for a Monday: >>> arw.shift(weekday=0) rjrkweekdayrlr)zweekszquarterszweekday) rmrnrrrsrtr\r rr/)r!rvrwrxrar6rrrshifts  !z Arrow.shiftc Cspt|ts$tjj|}n|jj|}|j|j|j |j |j |j |j |j|jS)a Returns a new :class:`Arrow ` object, converted to the target timezone. :param tz: A :ref:`timezone expression `. Usage:: >>> utc = arrow.utcnow() >>> utc >>> utc.to('US/Pacific') >>> utc.to(tz.tzlocal()) >>> utc.to('-07:00') >>> utc.to('local') >>> utc.to('local').to('utc') ) isinstancerr rrr r%rPrrrrrrr)r!rr)rrrto(s *zArrow.toc s]j|\}}}|dkr-d}n|dkrBd}n|}jj|}jd|d}fdd|D} x+td t| D]} | jdqWjd j| } |dkr| td j d } n.|dkr+| td j dd  } n| ti|||6td d} | | fS)a Returns two new :class:`Arrow ` objects, representing the timespan of the :class:`Arrow ` object in a given timeframe. :param frame: the timeframe. Can be any ``datetime`` property (day, hour, minute...). :param count: (optional) the number of frames to span. Supported frame values: year, quarter, month, week, day, hour, minute, second. Usage:: >>> arrow.utcnow() >>> arrow.utcnow().span('hour') (, ) >>> arrow.utcnow().span('day') (, ) >>> arrow.utcnow().span('day', count=2) (, ) rXrrYrNrKcsg|]}t|qSr)r4)rr5)r!rrrrs zArrow.span..rrdaysrl microseconds) r7r=indexrGr;r<rPrr isoweekdayr) r!r>countZframe_absoluterCrDattrrZframesrFrLfloorceilr)r!rrHMs$     ! "(z Arrow.spancCs|j|dS)a Returns a new :class:`Arrow ` object, representing the "floor" of the timespan of the :class:`Arrow ` object in a given timeframe. Equivalent to the first element in the 2-tuple returned by :func:`span `. :param frame: the timeframe. Can be any ``datetime`` property (day, hour, minute...). Usage:: >>> arrow.utcnow().floor('hour') r)rH)r!r>rrrrsz Arrow.floorcCs|j|dS)a Returns a new :class:`Arrow ` object, representing the "ceiling" of the timespan of the :class:`Arrow ` object in a given timeframe. Equivalent to the second element in the 2-tuple returned by :func:`span `. :param frame: the timeframe. Can be any ``datetime`` property (day, hour, minute...). Usage:: >>> arrow.utcnow().ceil('hour') rK)rH)r!r>rrrrsz Arrow.ceilzYYYY-MM-DD HH:mm:ssZZen_uscCstj|j|j|S)a Returns a string representation of the :class:`Arrow ` object, formatted according to a format string. :param fmt: the format string. Usage:: >>> arrow.utcnow().format('YYYY-MM-DD HH:mm:ss ZZ') '2013-05-09 03:56:47 -00:00' >>> arrow.utcnow().format('X') '1368071882' >>> arrow.utcnow().format('MMMM DD, YYYY') 'May 09, 2013' >>> arrow.utcnow().format() '2013-05-09 03:56:47 -00:00' )r ZDateTimeFormatterrr )r!r3localerrrrsz Arrow.formatFautocCstj|}|dkrQtjjdtj}|j|jj }nut |t rl|j}nZt |tr|j dkr|jd|jj }q|j|jj }n t t tj|j|}|dkrd+nd}t|} | }|dkrs| dkr7|jdd|S| d krc||} |jd | d|S| d kr|jd |d|S| d kr|t t|dd} |jd| d|S| dkr|jd|d|S| dkr%|t t|dd} |jd| d|S| dkrG|jd|d|S| dkr|t t|dd} |jd| d|S| dkr|jd|d|S| dkr|jjd|jj}|jd|j}|t tt||d}|jd|d|S| d kr=|jd!|d|S|t t|d"d}|jd#|d|Sn4|d$kr||}t|dkrl|jdd|Sn|d kr||td}n|dkr||td,}nu|dkr||td.}nR|dkr=||td1}n/|d!kr`||td4}n td(tt|dkr|d)7}n|j||dd*SdS)5ay Returns a localized, humanized representation of a relative difference in time. :param other: (optional) an :class:`Arrow ` or ``datetime`` object. Defaults to now in the current :class:`Arrow ` object's timezone. :param locale: (optional) a ``str`` specifying a locale. Defaults to 'en_us'. :param only_distance: (optional) returns only time difference eg: "11 seconds" without "in" or "ago" part. :param granularity: (optional) defines the precision of the output. Set it to strings 'second', 'minute', 'hour', 'day', 'month' or 'year'. Usage:: >>> earlier = arrow.utcnow().shift(hours=-2) >>> earlier.humanize() '2 hours ago' >>> later = later = earlier.shift(hours=4) >>> later.humanize(earlier) 'in 4 hours' NrrrKr r* only_distance-secondsZri <minutesiri`5ihoursi@ri iQr}iS;ri rli$ri3yearsrg>@gv@zError. Could not understand your level of granularity. Please select between "second", "minute", "hour", "day", "week", "month" or "year"sFriiiQiiQgDAiiQg~~A)r Z get_localerr#r$rrr%r rr{r TypeErrorr[r total_secondsabsZdescribemaxrrrgrrr)r!otherrrZ granularityr(r)deltasigndiffrrrr}Z self_monthsZ other_monthsrlrrrrhumanizes                #          zArrow.humanizecCs?t|ttfr2|j|j||jjStdS)N)r{rrr/r rr)r!rrrr__add__,sz Arrow.__add__cCs |j|S)N)r)r!rrrr__radd__3szArrow.__radd__cCsvt|ttfr2|j|j||jjSt|trL|j|St|tri|j|jStdS)N) r{rrr/r rrr r)r!rrrr__sub__6s z Arrow.__sub__cCs't|tr||jStdS)N)r{rr r)r!rrrr__rsub__Cs zArrow.__rsub__cCs(tdjt|t|dS)Nzcan't compare '{0}' to '{1}')rrtype)r!rrrr _cmperrorMs zArrow._cmperrorcCs/t|ttfsdS|j|j|kS)NF)r{r rr r9)r!rrrr__eq__Qsz Arrow.__eq__cCs|j| S)N)r)r!rrrr__ne__Xsz Arrow.__ne__cCs;t|ttfs%|j|n|j|j|kS)N)r{r rrr r9)r!rrrr__gt__[sz Arrow.__gt__cCs;t|ttfs%|j|n|j|j|kS)N)r{r rrr r9)r!rrrr__ge__bsz Arrow.__ge__cCs;t|ttfs%|j|n|j|j|kS)N)r{r rrr r9)r!rrrr__lt__isz Arrow.__lt__cCs;t|ttfs%|j|n|j|j|kS)N)r{r rrr r9)r!rrrr__le__psz Arrow.__le__cCs |jjS)z> Returns a ``date`` object with the same year, month and day. )r r0)r!rrrr0zsz Arrow.datecCs |jjS)zL Returns a ``time`` object with the same hour, minute, second, microsecond. )r time)r!rrrrsz Arrow.timecCs |jjS)z_ Returns a ``time`` object with the same hour, minute, second, microsecond and tzinfo. )r timetz)r!rrrrsz Arrow.timetzcCs|jj|S)zw Returns a ``datetime`` object, converted to the specified timezone. :param tz: a ``tzinfo`` object. )r r%)r!rrrrr%szArrow.astimezonecCs |jjS)zk Returns a ``timedelta`` object representing the whole number of minutes difference from UTC time. )r utcoffset)r!rrrrszArrow.utcoffsetcCs |jjS)z/ Returns the daylight savings time adjustment. )r dst)r!rrrrsz Arrow.dstcCs |jjS)z: Returns a ``time.struct_time``, in the current timezone. )r timetuple)r!rrrrszArrow.timetuplecCs |jjS)z. Returns a ``time.struct_time``, in UTC time. )r rf)r!rrrrfszArrow.utctimetuplecCs |jjS)z6 Returns the proleptic Gregorian ordinal of the date. )r toordinal)r!rrrrszArrow.toordinalcCs |jjS)z2 Returns the day of the week as an integer (0-6). )r ry)r!rrrrysz Arrow.weekdaycCs |jjS)z6 Returns the ISO day of the week as an integer (1-7). )r r)r!rrrrszArrow.isoweekdaycCs |jjS)z> Returns a 3-tuple, (ISO year, ISO week number, ISO weekday). )r rZ)r!rrrrZszArrow.isocalendarTcCs|jj|S)zCReturns an ISO 8601 formatted representation of the date and time. )r rT)r!seprrrrTszArrow.isoformatcCs |jjS)z@ Returns a ctime formatted representation of the date and time. )r ctime)r!rrrrsz Arrow.ctimecCs|jj|S)zd Formats in the style of ``datetime.strptime``. :param format: the format string. )r strftime)r!rrrrrszArrow.strftimecCs |jS)z7Serializes for the ``for_json`` protocol of simplejson.)rT)r!rrrfor_jsonszArrow.for_jsonc Csn|dkrtjSt|tr)|Sytjj|SWn*tjk ritdj |YnXdS)Nz"'{0}' not recognized as a timezone) rrr{rr rr ParserErrorrOr)Ztz_exprrrrr8s   zArrow._get_tzinfoc Csmt|tr|jSt|tr)|Sy t|}|j|jSWntdj|YnXdS)Nz/'{0}' not recognized as a timestamp or datetime)r{r rrgr.rOr)r'exprrrrr9s zArrow._get_datetimecCs||jkr%|dj|dfS|d kr5d S|d krEdSd j|jddgddg}td j||dS)Nz{0}srKrXrjrYrkrlrz, z>range/span over frame {0} not supported. Supported frames: {1})weekweeks)rrrK)quarterzquarters)rzmonthsr)r=rjoinrr)r'r`Z supportedrrrr7s  &zArrow._get_framescCs[|dkr4|dkr'tdn|j|fS|dkrM|tjfS||fSdS)Nz#one of 'end' or 'limit' is required) Exceptionrsysmaxsize)r'r@rArrrr:s     zArrow._get_iteration_paramsc Cs2yt|SWntdj|YnXdS)Nz!cannot parse '{0}' as a timestamp)rgrOr)r-rrrr+szArrow._get_timestamp_from_input)JrQ __module__ __qualname____doc__r resolutionr=rnr\r" classmethodr*r#r,r.r/r1r2rGrJrMrSrRrVrWrbpropertyrsetterrcr-rhrir$rzr|rHrrrrrrrrrrrrrrrr0rrr%rrrrfrryrrZrTrrr staticmethodr8r9r7r:r+rrrrr s      G2-      6 / %6  m                     r )r __future__rrrrZdateutilrrZdateutil.relativedeltarmathrrdrroarrowr r r r r^r r/minrrrrrs    "