File pytimeparse2-1.7.1.obscpio of Package python-pytimeparse2

Overview Repositories Revisions Requests Users Attributes Meta

File pytimeparse2-1.7.1.obscpio of Package python-pytimeparse2 (Revision 7dfcb16f4b0066cfb3bc94ac593f45b5)

Currently displaying revision 7dfcb16f4b0066cfb3bc94ac593f45b5 , Show latest

07070100000000000081A4000000000000000000000001645D608F000000F5000000000000000000000000000000000000001F00000000pytimeparse2-1.7.1/.coveragerc[run]
source =
    pytimeparse2
    tests
parallel = True
concurrency =
    thread
    multiprocessing
omit =
    *.tox/*
    *setup.py

[report]
fail_under = 100
show_missing = True
exclude_lines =
    pragma: no cover
    nocv
    MemoryError
07070100000001000041ED000000000000000000000002645D608F00000000000000000000000000000000000000000000001B00000000pytimeparse2-1.7.1/.github07070100000002000041ED000000000000000000000002645D608F00000000000000000000000000000000000000000000002500000000pytimeparse2-1.7.1/.github/workflows07070100000003000081A4000000000000000000000001645D608F00000274000000000000000000000000000000000000002F00000000pytimeparse2-1.7.1/.github/workflows/check.ymlname: Python package

on:
  push:
    branches: [ master ]
  pull_request:
    branches: [ master ]

jobs:
  build:
    runs-on: ubuntu-20.04
    strategy:
      max-parallel: 4
      matrix:
        python-version: ['3.6.15', 3.7, 3.8, 3.9, '3.10', '3.11']

steps:
    - uses: actions/checkout@v2
    - name: Set up Python ${{ matrix.python-version }}
      uses: actions/setup-python@v2
      with:
        python-version: ${{ matrix.python-version }}
    - name: Install dependencies
      run: |
        python -m pip install --upgrade pip
        pip install tox tox-gh-actions
    - name: Test with tox
      run: tox
07070100000004000081A4000000000000000000000001645D608F0000006B000000000000000000000000000000000000001E00000000pytimeparse2-1.7.1/.gitignore*.pyc
*~
*.c
.DS_Store
/.coverage
/MANIFEST
/build/
/dist/
*.egg-info/
venv
.tox
.mypy_cache
.idea
.vscode
07070100000005000081A4000000000000000000000001645D608F00000054000000000000000000000000000000000000001900000000pytimeparse2-1.7.1/.pep8[flake8]
ignore =
exclude = /.tox/*
max-line-length = 120
import-order-style = pep8
07070100000006000081A4000000000000000000000001645D608F0000043A000000000000000000000000000000000000001F00000000pytimeparse2-1.7.1/LICENSE.rstThe MIT License (MIT)

Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:

The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
07070100000007000081A4000000000000000000000001645D608F00000039000000000000000000000000000000000000001F00000000pytimeparse2-1.7.1/MANIFEST.ininclude LICENSE.rst
include README.rst
include setup.cfg
07070100000008000081A4000000000000000000000001645D608F00000C1F000000000000000000000000000000000000001E00000000pytimeparse2-1.7.1/README.rstpytimeparse2: time expression parser
=====================================

.. image:: https://github.com/onegreyonewhite/pytimeparse2/actions/workflows/check.yml/badge.svg?branch=master
    :target: https://github.com/onegreyonewhite/pytimeparse2/actions
    :alt: Pipeline status

.. image:: https://badge.fury.io/py/pytimeparse2.svg
    :target: https://badge.fury.io/py/pytimeparse2

This is a `pytimeparse <https://github.com/wroberts/pytimeparse>`_ based project with the aim of optimizing functionality and providing stable support.

Licensed under the MIT License (see source file ``pytimeparse2.py`` for
details).

A small Python library to parse various kinds of time expressions,
inspired by
`this StackOverflow question <http://stackoverflow.com/questions/4628122/how-to-construct-a-timedelta-object-from-a-simple-string>`_.

The single function ``pytimeparse2.parse`` defined in the library parses time
expressions like the following:

- ``32m``
- ``2h32m``
- ``3d2h32m``
- ``1w3d2h32m``
- ``1w 3d 2h 32m``
- ``1 w 3 d 2 h 32 m``
- ``4:13``
- ``4:13:02``
- ``4:13:02.266``
- ``2:04:13:02.266``
- ``2 days,  4:13:02`` (``uptime`` format)
- ``2 days,  4:13:02.266``
- ``5hr34m56s``
- ``5 hours, 34 minutes, 56 seconds``
- ``5 hrs, 34 mins, 56 secs``
- ``2 days, 5 hours, 34 minutes, 56 seconds``
- ``1.2 m``
- ``1.2 min``
- ``1.2 mins``
- ``1.2 minute``
- ``1.2 minutes``
- ``172 hours``
- ``172 hr``
- ``172 h``
- ``172 hrs``
- ``172 hour``
- ``1.24 days``
- ``5 d``
- ``5 day``
- ``5 days``
- ``5.6 wk``
- ``5.6 week``
- ``5.6 weeks``

It returns the time as a number of seconds (an integer value if
possible, otherwise a floating-point number)::

>>> from pytimeparse import parse
    >>> parse('1.2 minutes')
    72

For months and years, the library does not consider complications such as leap-
years and leap-seconds. Instead, it assumes "30 days for a month" and "365 days
for a year" as the basis for calculations with those units.

- ``2 mo``
- ``2 months``
- ``3y``
- ``3 years``
- ``1y2mo3w4d5h6m7s8ms``

For better capability with dates, use keyword ``as_timedelta=True`` which mark for function returns
value as ``datetime.timedelta`` or ``dateutil.relitivedelta.relativedelta`` (if installed)::

>>> from pytimeparse import parse
    >>> parse('24h', as_timedelta=True)
    relativedelta(days=+1)

You can also forced disable dateutil support by calling ``disable_dateutil()`` before ``parse(...)``.
For returning support call ``enable_dateutil()``.

Notes
-----

A number of seconds can be converted back into a string using the
``datetime`` module in the standard library, as noted in
`this other StackOverflow question <http://stackoverflow.com/questions/538666/python-format-timedelta-to-string>`_::

>>> from pytimeparse import parse
    >>> import datetime
    >>> parse('1 day, 14:20:16')
    138016
    >>> str(datetime.timedelta(seconds=138016))
    '1 day, 14:20:16'

Future work
-----------

1. Speed up with Cython for some python versions.
2. Use github actions for testing and releasing.
07070100000009000081ED000000000000000000000001645D608F00000184000000000000000000000000000000000000002200000000pytimeparse2-1.7.1/autorelease.sh#!/usr/bin/env bash
CURRENT_VERSION=$(python3 setup.py --version | tr -d '\n')
TAG=$(git tag -l $CURRENT_VERSION)

if [ -z "${TAG}" ]; then
    echo "Creating new tag ${CURRENT_VERSION}.";
    git tag $CURRENT_VERSION > /dev/null 2>&1;
    git push origin $CURRENT_VERSION > /dev/null 2>&1;
else
    echo "Current release ${CURRENT_VERSION} already exists. Update version to release."
fi
0707010000000A000081A4000000000000000000000001645D608F00002357000000000000000000000000000000000000002300000000pytimeparse2-1.7.1/pytimeparse2.py#!/usr/bin/env python
# -*- coding: utf-8 -*-

"""
(c) Sergey Klyuykov <onegreyonewhite@mail.ru> 3 Nov 2021

Implements a single function, `parse`, which can parse various
kinds of time expressions.
"""

# MIT LICENSE
#
# Permission is hereby granted, free of charge, to any person
# obtaining a copy of this software and associated documentation files
# (the "Software"), to deal in the Software without restriction,
# including without limitation the rights to use, copy, modify, merge,
# publish, distribute, sublicense, and/or sell copies of the Software,
# and to permit persons to whom the Software is furnished to do so,
# subject to the following conditions:
#
# The above copyright notice and this permission notice shall be
# included in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.

__version__ = '1.7.1'

import typing
import re
from datetime import timedelta

try:
    from dateutil.relativedelta import relativedelta
    HAS_RELITIVE_TIMEDELTA = True
except ImportError:  # pragma: no cover
    HAS_RELITIVE_TIMEDELTA = False
    relativedelta = None  # type: ignore

SIGN = r'(?P<sign>[+|-]|\+)?'
YEARS = r'(?P<years>[\d.]+)\s*(?:ys?|yrs?.?|years?)'
MONTHS = r'(?P<months>[\d.]+)\s*(?:mos?.?|mths?.?|months?)'
WEEKS = r'(?P<weeks>[\d.]+)\s*(?:w|wks?|weeks?)'
DAYS = r'(?P<days>[\d.]+)\s*(?:d|dys?|days?)'
HOURS = r'(?P<hours>[\d.]+)\s*(?:h|hrs?|hours?)'
MINS = r'(?P<minutes>[\d.]+)\s*(?:m|(mins?)|(minutes?))'
SECS = r'(?P<seconds>[\d.]+)\s*(?:s|secs?|seconds?)'
MILLIS = r'(?P<milliseconds>[\d.]+)\s*(?:ms|msecs?|millis|milliseconds?)'
SEPARATORS = r'[,/]'
SECCLOCK = r':(?P<seconds>\d{2}(?:\.\d+)?)'
MINCLOCK = r'(?P<minutes>\d{1,2}):(?P<seconds>\d{2}(?:\.\d+)?)'
HOURCLOCK = r'(?P<hours>\d+):(?P<minutes>\d{2}):(?P<seconds>\d{2}(?:\.\d+)?)'
DAYCLOCK = (r'(?P<days>\d+):(?P<hours>\d{2}):'
            r'(?P<minutes>\d{2}):(?P<seconds>\d{2}(?:\.\d+)?)')

MULTIPLIERS = {
    'years': 60 * 60 * 24 * 365,
    'months': 60 * 60 * 24 * 30,
    'weeks': 60 * 60 * 24 * 7,
    'days': 60 * 60 * 24,
    'hours': 60 * 60,
    'minutes': 60,
    'seconds': 1,
    'milliseconds': 1e-3,
}

def OPT(x):
    return r'(?:{x})?'.format(x=x)

def OPTSEP(x):
    return r'(?:{x}\s*(?:{SEPARATORS}\s*)?)?'.format(x=x, SEPARATORS=SEPARATORS)

TIMEFORMATS = [
    (rf'{OPTSEP(YEARS)}\s*'
     rf'{OPTSEP(MONTHS)}\s*'
     rf'{OPTSEP(WEEKS)}\s*'
     rf'{OPTSEP(DAYS)}\s*'
     rf'{OPTSEP(HOURS)}\s*'
     rf'{OPTSEP(MINS)}\s*'
     rf'{OPT(SECS)}\s*'
     rf'{OPT(MILLIS)}'),
    rf'{OPTSEP(WEEKS)}\s*{OPTSEP(DAYS)}\s*{OPTSEP(HOURS)}\s*{OPTSEP(MINS)}\s*{OPT(SECS)}\s*{OPT(MILLIS)}',
    rf'{MINCLOCK}',
    rf'{OPTSEP(WEEKS)}\s*{OPTSEP(DAYS)}\s*{HOURCLOCK}',
    rf'{DAYCLOCK}',
    rf'{SECCLOCK}',
    rf'{YEARS}',
    rf'{MONTHS}',
]

COMPILED_SIGN = re.compile(r'\s*' + SIGN + r'\s*(?P<unsigned>.*)$')
COMPILED_TIMEFORMATS = [
    re.compile(r'\s*' + timefmt + r'\s*$', re.I)
    for timefmt in TIMEFORMATS
]

def _all_digits(mdict, delta_class):
    if HAS_RELITIVE_TIMEDELTA and issubclass(delta_class, relativedelta):
        if 'milliseconds' in mdict:
            mdict['microseconds'] = float(mdict.pop('milliseconds') or 0) * 1000
        return delta_class(**{k: float(v) for k, v in mdict.items() if v}).normalized()

delta = delta_class(**{
        key: float(mdict.pop(key) or 0)
        for key in mdict.copy()
        if key in ('hours', 'minutes', 'days', 'milliseconds')
    })

for time_type, value in mdict.items():
        if not value:
            continue
        if value.isdigit():
            delta += delta_class(seconds=MULTIPLIERS[time_type] * int(value, 10))
        elif value.replace('.', '', 1).isdigit():
            delta += delta_class(seconds=MULTIPLIERS[time_type] * float(value))

return delta

def _interpret_as_minutes(sval, mdict):
    """
    Times like "1:22" are ambiguous; do they represent minutes and seconds
    or hours and minutes?  By default, parse assumes the latter.  Call
    this function after parsing out a dictionary to change that assumption.

>>> import pprint
    >>> pprint.pprint(_interpret_as_minutes('1:24', {'seconds': '24', 'minutes': '1'}))
    {'hours': '1', 'minutes': '24'}
    """
    if sval.count(':') == 1 and '.' not in sval and (('hours' not in mdict) or (mdict['hours'] is None)) and (
            ('days' not in mdict) or (mdict['days'] is None)) and (('weeks' not in mdict) or (mdict['weeks'] is None)) \
            and (('months' not in mdict) or (mdict['months'] is None)) \
            and (('years' not in mdict) or (mdict['years'] is None)):
        mdict['hours'] = mdict['minutes']
        mdict['minutes'] = mdict['seconds']
        mdict.pop('seconds')
    return mdict

def _normilized_relativedelta(value: typing.Optional[timedelta]) -> typing.Optional[timedelta]:
    if relativedelta is not None and isinstance(value, relativedelta):
        return value.normalized()
    return value

def _parse(
        sval: typing.Union[str, int, float],
        granularity: str = 'seconds',
        delta_class: typing.Type[timedelta] = timedelta
) -> typing.Optional[timedelta]:
    if isinstance(sval, (int, float)):
        return _normilized_relativedelta(delta_class(seconds=float(sval)))
    if sval.replace('.', '', 1).replace('-', '', 1).replace('+', '', 1).isdigit():
        return _normilized_relativedelta(delta_class(seconds=float(sval)))

match = COMPILED_SIGN.match(sval)
    sign = -1 if match.groupdict()['sign'] == '-' else 1  # type: ignore
    sval = match.groupdict()['unsigned']  # type: ignore

for timefmt in COMPILED_TIMEFORMATS:
        match = timefmt.match(sval)

if not (match and match.group(0).strip()):
            continue

mdict = match.groupdict()
        if granularity == 'minutes':
            mdict = _interpret_as_minutes(sval, mdict)

return sign * _all_digits(mdict, delta_class)

return timedelta(seconds=float(sval)) * sign

def enable_dateutil():
    global HAS_RELITIVE_TIMEDELTA
    assert relativedelta is not None, 'Module python-dateutil should be installed before.'
    HAS_RELITIVE_TIMEDELTA = True

def disable_dateutil():
    global HAS_RELITIVE_TIMEDELTA
    HAS_RELITIVE_TIMEDELTA = False

def parse(
        sval: typing.Union[str, int, float],
        granularity: str = 'seconds',
        raise_exception: bool = False,
        as_timedelta: bool = False,
) -> typing.Optional[typing.Union[int, float, timedelta, typing.NoReturn]]:
    """
    Parse a time expression, returning it as a number of seconds.  If
    possible, the return value will be an `int`; if this is not
    possible, the return will be a `float`.  Returns `None` if a time
    expression cannot be parsed from the given string.

Arguments:
    - `sval`: the string value to parse
    - `granularity`: minimal type of digits after last colon (default is ``seconds``)
    - `raise_exception`: raise exception on parsing errors (default is ``False``)
    - `as_timedelta`: return ``datetime.timedelta`` object instead of ``int`` (default is ``False``)

>>> parse('1:24')
    84
    >>> parse(':22')
    22
    >>> parse('1 minute, 24 secs')
    84
    >>> parse('1m24s')
    84
    >>> parse('1.2 minutes')
    72
    >>> parse('1.2 seconds')
    1.2

Time expressions can be signed.

>>> parse('- 1 minute')
    -60
    >>> parse('+ 1 minute')
    60

If granularity is specified as ``minutes``, then ambiguous digits following
    a colon will be interpreted as minutes; otherwise they are considered seconds.

>>> parse('1:30')
    90
    >>> parse('1:30', granularity='minutes')
    5400

If ``as_timedelta`` is specified as ``True``, then return timedelta object.

>>> parse('24h', as_timedelta=True)
    relativedelta(days=+1)
    >>> parse('48:00', as_timedelta=True, granularity='minutes')
    relativedelta(days=+2)

If ``raise_exception`` is specified as ``True``, then exception will raised
    on failed parsing.

>>> parse(':1.1.1', raise_exception=True)
    Traceback (most recent call last):
        ...
    ValueError: could not convert string to float: ':1.1.1'
    """
    try:
        value = _parse(sval, granularity, relativedelta if HAS_RELITIVE_TIMEDELTA and as_timedelta else timedelta)
        if not as_timedelta and value is not None:
            new_value = value.total_seconds()
            if new_value.is_integer():
                return int(new_value)
            else:
                return new_value
        return value
    except Exception:
        if raise_exception:
            raise
        return None
0707010000000B000081A4000000000000000000000001645D608F0000051B000000000000000000000000000000000000001D00000000pytimeparse2-1.7.1/setup.cfg[metadata]
name = pytimeparse2
version = attr: pytimeparse2.__version__
description = Time expression parser.
long_description = file: README.rst
long_description_content_type = text/x-rst
license = MIT
author = Sergey Klyuykov
author_email = onegreyonewhite@mail.ru
url = https://github.com/onegreyonewhite/pytimeparse2
keywords = parsing, time, timeparsing, text
classifiers =
    Development Status :: 5 - Production/Stable
    Intended Audience :: Developers
    License :: OSI Approved :: MIT License
    Programming Language :: Python
    Programming Language :: Python :: 3
    Programming Language :: Python :: 3 :: Only
    Programming Language :: Python :: 3.6
    Programming Language :: Python :: 3.7
    Programming Language :: Python :: 3.8
    Programming Language :: Python :: 3.9
    Programming Language :: Python :: 3.10
    Programming Language :: Python :: 3.11
    Programming Language :: Python :: Implementation :: CPython
    Topic :: Software Development :: Libraries
    Topic :: Software Development :: Libraries :: Python Modules
    Topic :: Text Processing
    Topic :: Utilities

[options]
zip_safe = False
include_package_data = True
python_requires = >=3.6

[options.extras_require]
dateutil =
    python-dateutil~=2.8.2

[build_sphinx]
project = 'pytimeparse2'

[aliases]
0707010000000C000081A4000000000000000000000001645D608F00003870000000000000000000000000000000000000001C00000000pytimeparse2-1.7.1/setup.py#!/usr/bin/env python
# -*- coding: utf-8 -*-

"""
setup.py
(c) Sergey Klyuykov 3 Nov 2021

distutils setup script for pytimeparse2.
"""

# Compilation block
########################################################################################
import re
import os
import sys
import subprocess
import fnmatch
import codecs
import gzip
import shutil

# allow setup.py to be run from any path
os.chdir(os.path.normpath(os.path.join(os.path.abspath(__file__), os.pardir)))

from setuptools import find_packages, setup, errors, Command
from setuptools.extension import Extension
from setuptools.command.sdist import sdist as _sdist
from setuptools.command.build_py import build_py as build_py_orig
from setuptools.command.install_lib import install_lib as _install_lib
try:
    from Cython.Build import cythonize, build_ext as _build_ext
except ImportError:
    has_cython = False
else:
    has_cython = True

try:
    from sphinx.setup_command import BuildDoc
    import sphinx  # noqa: F401
    has_sphinx = True
except ImportError:
    has_sphinx = False

ignored_keys = ['-h', '--help', '--version']
is_help = any([a for a in ignored_keys if a in sys.argv])
is_develop = 'develop' in sys.argv
is_build = (any([a for a in ['compile', 'bdist_wheel', 'bdist'] if a in sys.argv]) or is_develop) and not is_help

def get_discription(file_path='README.rst', folder=os.getcwd()):
    with codecs.open("{}/{}".format(folder, file_path), 'r', encoding='utf-8') as readme:
        return readme.read()

def load_requirements(file_name, folder=os.getcwd()):
    with codecs.open(os.path.join(folder, file_name), 'r', encoding='utf-8')as req_file:
        return req_file.read().strip().split('\n')

def get_file_ext(ext):
    file_types = [".py", ".pyx", ".c", '.cpp'] if has_cython else [".c", '.cpp', ".py"]
    for ftype in file_types:
        fname = ext.replace(".", "/") + ftype
        if os.path.exists(fname):
            return fname
    return None

def listfiles(folder):
    if not isinstance(folder, (list, tuple)):
        folder = [folder]
    folder = filter(lambda p: os.path.isdir(p), folder)
    for one_folder in folder:
        for root, folders, files in os.walk(one_folder):
            for filename in folders + files:
                yield os.path.join(root, filename)

def clear_old_extentions(extensions_list, packages):
    for filename in listfiles(packages):
        _filename, _f_ext = os.path.splitext(filename)
        if os.path.isdir(_filename) or _f_ext not in ['.c', '.cpp']:
            continue
        has_py = (
            os.path.exists('{}.py'.format(_filename)) or
            os.path.exists('{}.pyx'.format(_filename))
        )

if has_py and filename.replace('/', '.').replace(_f_ext, '') in extensions_list:
            print('Removing old extention [{}].'.format(filename))
            os.remove(filename)

def make_extention(module_name, files, extra_compile_args, main_include_dir=os.path.join(os.getcwd(), 'include')):
    include_dirs = list(filter(
        lambda f: bool(f) and os.path.exists(f) and os.path.isdir(f),
        [os.path.join(module_name.split('.')[0], 'include'), main_include_dir]
    ))

return Extension(
        module_name, files,
        extra_compile_args=extra_compile_args,
        include_dirs=include_dirs
    )

def make_extensions(extensions_list, packages):
    if not isinstance(extensions_list, list):
        raise Exception("Extension list should be `list`.")

if not is_help:
        clear_old_extentions(extensions_list, packages)

extensions_dict = {}
    for ext in extensions_list:
        files = []
        module_name = ext
        if isinstance(ext, (list, tuple)):
            module_name = ext[0]
            for file_module in ext[1]:
                file_name = get_file_ext(file_module)
                files += [file_name] if file_name else []
        else:
            file_name = get_file_ext(ext)
            files += [file_name] if file_name else []
        if files:
            extensions_dict[module_name] = files

extra_compile_args = [
        '-g0', '-ggdb1',
        "-fno-strict-aliasing",
        "-ffast-math",
        "-fno-var-tracking-assignments",
        "-pipe", "-std=c99", '-Werror=sign-compare',
    ]
    if 'compile' in sys.argv:
        extra_compile_args.append("-DBUILD_FROM_SOURCE")
    ext_modules = list(
        make_extention(m, f, extra_compile_args)
        for m, f in extensions_dict.items()
    )
    ext_count = len(ext_modules)
    nthreads = ext_count if ext_count < 10 else 10

language_level = 3
    if is_help:
        pass
    elif has_cython and ('compile' in sys.argv or 'bdist_wheel' in sys.argv or 'build_ext' in sys.argv):
        cy_kwargs = dict(
            nthreads=nthreads,
            force=True,
            language_level=language_level,
            compiler_directives=dict(
                linetrace='CYTHON_TRACE_NOGIL' in sys.argv,
                profile=True,
                c_string_type='str',
                c_string_encoding='utf8'
            ),
        )
        return cythonize(ext_modules, **cy_kwargs), extensions_dict
    return ext_modules, extensions_dict

def minify_js_file(js_file, jsmin_func):
    return jsmin_func(js_file, quote_chars="'\"`")

def minify_css_file(css_file, cssmin_func):
    return cssmin_func(css_file)

def minify_static_files(base_dir, files, exclude=None):
    exclude = exclude or []
    patterns = dict()
    try:
        from jsmin import jsmin as jsmin_func
        patterns['*.js'] = (minify_js_file, jsmin_func)
    except:
        pass
    try:
        from csscompressor import compress as csscompressor_func
        patterns['*.css'] = (minify_css_file, csscompressor_func)
    except:
        pass

regex_exclude = [re.compile(r, re.MULTILINE) for r in exclude]

for fnext, funcs in patterns.items():
        for fext_file in filter(lambda f: fnmatch.fnmatch(f, fnext), files):
            if fnmatch.fnmatch(fext_file, '*.min.*'):
                continue
            fext_file = os.path.join(base_dir, fext_file)
            if os.path.exists(fext_file):
                if not any(filter(lambda fp: bool(fp.search(fext_file)), regex_exclude)):
                    func, subfunc = funcs
                    with codecs.open(fext_file, 'r', encoding='utf-8') as static_file_fd:
                        minified = func(static_file_fd.read(), subfunc)
                    with codecs.open(fext_file, 'w', encoding='utf-8') as static_file_fd:
                        static_file_fd.write(minified)
                    print('Minfied file {fext_file}.'.format(fext_file=fext_file))
                with open(fext_file, 'rb') as f_in:
                    with gzip.open("{}.gz".format(fext_file), 'wb') as f_out:
                        shutil.copyfileobj(f_in, f_out)
                print('Compressed file {fext_file}.'.format(fext_file=fext_file))

def compile_py_func(fullname, compile_file_func):
    if compile_file_func(fullname, ddir=os.path.dirname(fullname), legacy=True, optimize=0):
        os.remove(fullname)

def compile_python_sources(base_dir, files, exclude=None):
    exclude = exclude or []
    patterns = dict()
    try:
        from compileall import compile_file
        patterns['*.py'] = (compile_py_func, compile_file)
    except:
        pass

regex_exclude = [re.compile(r, re.MULTILINE) for r in exclude]

for fnext, funcs in patterns.items():
        for fext_file in filter(lambda f: fnmatch.fnmatch(f, fnext), files):
            fext_file = os.path.join(base_dir, fext_file)
            if os.path.exists(fext_file):
                if not any(filter(lambda fp: bool(fp.search(fext_file)), regex_exclude)):
                    func, subfunc = funcs
                    funcs[0](fext_file, funcs[1])
                    print('Compiled {fext_file}.'.format(fext_file=fext_file))

class _Compile(_sdist):
    extensions_dict = dict()
    static_exclude = []

def __filter_files(self, files):
        for _files in self.extensions_dict.values():
            for file in _files:
                if file in files:
                    files.remove(file)
        return files

def make_release_tree(self, base_dir, files):
        if has_cython:
            files = self.__filter_files(files)
        _sdist.make_release_tree(self, base_dir, files)
        minify_static_files(base_dir, files, self.static_exclude)

def run(self):
        return _sdist.run(self)

class GithubRelease(Command):
    '''
    Make release on github via githubrelease
    '''
    description = 'Make release on github via githubrelease'

user_options = [
        ('body=', 'b', 'Body message.'),
        ('assets=', 'a', 'Release assets patterns.'),
        ('repo=', 'r', 'Repository for release.'),
        ('release=', 'R', 'Release version.'),
        ('dry-run=', 'd', 'Dry run.'),
        ('publish=', 'p', 'Publish release or just create draft.'),
    ]

def initialize_options(self):
        self.body = None or os.getenv('CI_COMMIT_DESCRIPTION', None)
        self.assets = None
        self.repo = None
        self.dry_run = False
        self.publish = False
        self.release = None or self.distribution.metadata.version

def finalize_options(self):
        if self.repo is None:
            raise Exception("Parameter --repo is missing")
        if self.release is None:
            raise Exception("Parameter --release is missing")
        self._gh_args = (self.repo, self.release)
        self._gh_kwargs = dict(
            publish=self.publish, name=self.release, dry_run=self.dry_run
        )
        if self.assets:
            assets = self.assets.format(release=self.release)
            assets = list(filter(bool, assets.split('\n')))
            self._gh_kwargs['asset_pattern'] = assets
        if self.body:
            self._gh_kwargs['body'] = self.body

def run(self):
        from github_release import gh_release_create
        gh_release_create(*self._gh_args, **self._gh_kwargs)

class build_py(build_py_orig):
    exclude = []
    compile_extentions_types = ['.py', '.pyx']
    wheel_extentions_types = ['.c', '.cpp'] + compile_extentions_types

def _filter_modules(self, module_tuple):
        pkg, mod, file = module_tuple
        try:
            file_name, file_ext = os.path.splitext(file)
            module_name = file_name.replace('/', '.')
        except:
            return True
        if 'bdist_wheel' in sys.argv:
            exclude_list = self.wheel_extentions_types
        elif 'compile' in sys.argv:
            exclude_list = self.compile_extentions_types
        else:
            return True
        if module_name in self.exclude and file_ext in exclude_list:
            return False
        return True

def find_package_modules(self, package, package_dir):
        modules = build_py_orig.find_package_modules(self, package, package_dir)
        return list(filter(self._filter_modules, modules))

class install_lib(_install_lib):
    exclude = []
    static_exclude = []
    compile_exclude = []

def _filter_files_with_ext(self, filename):
        _filename, _fext = os.path.splitext(filename)
        if _fext in build_py.wheel_extentions_types:
            return True
        return False

def install(self):
        result = _install_lib.install(self)
        files = list(listfiles(self.install_dir))
        so_extentions = list(filter(lambda f: fnmatch.fnmatch(f, '*.so'), files))
        for source in filter(self._filter_files_with_ext, files):
            _source_name, _source_ext = os.path.splitext(source)
            if any(filter(lambda f: fnmatch.fnmatch(f, _source_name+"*.so"), so_extentions)):
                print('Removing extention sources [{}].'.format(source))
                os.remove(source)
        minify_static_files('', files, self.static_exclude)
        if os.getenv('BUILD_COMPILE', '') == 'true':
            compile_python_sources('', files, self.compile_exclude)
        return result

def get_compile_command(extensions_dict=None):
    extensions_dict = extensions_dict or dict()
    compile_class = _Compile
    compile_class.extensions_dict = extensions_dict
    return compile_class

def make_setup(**opts):
    if 'packages' not in opts:
        opts['packages'] = find_packages()
    ext_modules_list = opts.pop('ext_modules_list', [])
    ext_mod, ext_mod_dict = make_extensions(ext_modules_list, opts['packages'])
    opts['ext_modules'] = opts.get('ext_modules', []) + ext_mod
    cmdclass = opts.get('cmdclass', dict())
    static_exclude = opts.pop('static_exclude_min', [])
    if 'compile' not in cmdclass:
        compile_class = get_compile_command(ext_mod_dict)
        compile_class.static_exclude = static_exclude
        cmdclass.update({"compile": get_compile_command(ext_mod_dict)})
    if has_cython:
        build_py.exclude = ext_modules_list
        install_lib.static_exclude = static_exclude
        install_lib.compile_exclude = opts.pop('compile_modules_exclude', [])
        cmdclass.update({
            'build_ext': _build_ext,
            'build_py': build_py,
            'install_lib': install_lib
        })
    if has_sphinx and 'build_sphinx' not in cmdclass:
        cmdclass['build_sphinx'] = BuildDoc
    cmdclass['githubrelease'] = GithubRelease
    opts['cmdclass'] = cmdclass

webpack_path = os.path.join(os.getcwd(), 'webpack.config.js')
    if os.path.exists(webpack_path) and is_build and os.environ.get('DONT_YARN', "") != 'true':
        try:
            subprocess.check_call(['yarn', 'install', '--pure-lockfile', '--mutex network'], stdout=sys.stdout, stderr=sys.stderr)
            subprocess.check_call(['yarn', 'devBuild' if is_develop else 'build'], stdout=sys.stdout, stderr=sys.stderr)
        except Exception as err:
            raise errors.CompileError(str(err))

setup(**opts)

########################################################################################
# end block

ext_list = []

if 'develop' in sys.argv:
    ext_list = []

kwargs = dict(
    name='pytimeparse2',
    py_modules=['pytimeparse2'],
    ext_modules_list=ext_list,
    install_requires=[],
    project_urls={
        "Issue Tracker": "https://github.com/onegreyonewhite/pytimeparse2/-/issues",
        "Source Code": "https://github.com/onegreyonewhite/pytimeparse2.git",
        "Releases": "https://pypi.org/project/pytimeparse2/#history",
    },
)

make_setup(**kwargs)
0707010000000D000081A4000000000000000000000001645D608F0000A46A000000000000000000000000000000000000001C00000000pytimeparse2-1.7.1/tests.py#!/usr/bin/env python
# -*- coding: utf-8 -*-

"""
(c) Sergey Klyuykov <onegreyonewhite@mail.ru> 3 Nov 2021

Unit tests for the `parse` function.
"""

from __future__ import absolute_import

import datetime
import doctest
import re
import pytimeparse2 as timeparse
import unittest
from dateutil.relativedelta import relativedelta

class TestParsing(unittest.TestCase):
    """
    Unit tests for basic regex mat
    """

def test_mins(self):
        """Test parsing minutes."""
        self.assertEqual(re.match(timeparse.MINS, '32m').groupdict(),
                         {'minutes': '32'})
        self.assertEqual(re.match(timeparse.MINS, '32min').groupdict(),
                         {'minutes': '32'})
        self.assertEqual(re.match(timeparse.MINS, '32mins').groupdict(),
                         {'minutes': '32'})
        self.assertEqual(re.match(timeparse.MINS, '32minute').groupdict(),
                         {'minutes': '32'})
        self.assertEqual(re.match(timeparse.MINS, '32minutes').groupdict(),
                         {'minutes': '32'})
        self.assertEqual(re.match(timeparse.MINS, '32mins').groupdict(),
                         {'minutes': '32'})
        self.assertEqual(re.match(timeparse.MINS, '32min').groupdict(),
                         {'minutes': '32'})

def test_hrs(self):
        """Test parsing hours."""
        self.assertEqual(re.match(timeparse.HOURS, '32h').groupdict(),
                         {'hours': '32'})
        self.assertEqual(re.match(timeparse.HOURS, '32hr').groupdict(),
                         {'hours': '32'})
        self.assertEqual(re.match(timeparse.HOURS, '32hrs').groupdict(),
                         {'hours': '32'})
        self.assertEqual(re.match(timeparse.HOURS, '32hour').groupdict(),
                         {'hours': '32'})
        self.assertEqual(re.match(timeparse.HOURS, '32hours').groupdict(),
                         {'hours': '32'})
        self.assertEqual(re.match(timeparse.HOURS, '32 hours').groupdict(),
                         {'hours': '32'})
        self.assertEqual(re.match(timeparse.HOURS, '32 h').groupdict(),
                         {'hours': '32'})

def test_months(self):
        """Test parsing months."""
        self.assertEqual(re.match(timeparse.MONTHS, '32mo').groupdict(),
                         {'months': '32'})
        self.assertEqual(re.match(timeparse.MONTHS, '32mon').groupdict(),
                         {'months': '32'})
        self.assertEqual(re.match(timeparse.MONTHS, '32month').groupdict(),
                         {'months': '32'})
        self.assertEqual(re.match(timeparse.MONTHS, '32months').groupdict(),
                         {'months': '32'})
        self.assertEqual(re.match(timeparse.MONTHS, '32 mo').groupdict(),
                         {'months': '32'})
        self.assertEqual(re.match(timeparse.MONTHS, '32 months').groupdict(),
                         {'months': '32'})
        self.assertEqual(re.match(timeparse.MONTHS, '32mos').groupdict(),
                         {'months': '32'})
        self.assertEqual(re.match(timeparse.MONTHS, '32mths').groupdict(),
                         {'months': '32'})
        self.assertEqual(re.match(timeparse.MONTHS, '2.3mo').groupdict(),
                         {'months': '2.3'})
        self.assertEqual(re.match(timeparse.MONTHS, '2.5mo').groupdict(),
                         {'months': '2.5'})

def test_years(self):
        """Test parsing years."""
        self.assertEqual(re.match(timeparse.YEARS, '32y').groupdict(),
                         {'years': '32'})
        self.assertEqual(re.match(timeparse.YEARS, '32ys').groupdict(),
                         {'years': '32'})
        self.assertEqual(re.match(timeparse.YEARS, '32yrs').groupdict(),
                         {'years': '32'})
        self.assertEqual(re.match(timeparse.YEARS, '32year').groupdict(),
                         {'years': '32'})
        self.assertEqual(re.match(timeparse.YEARS, '32years').groupdict(),
                         {'years': '32'})
        self.assertEqual(re.match(timeparse.YEARS, '32 y').groupdict(),
                         {'years': '32'})
        self.assertEqual(re.match(timeparse.YEARS, '32 years').groupdict(),
                         {'years': '32'})
        self.assertEqual(re.match(timeparse.YEARS, '2.3y').groupdict(),
                         {'years': '2.3'})
        self.assertEqual(re.match(timeparse.YEARS, '2.5y').groupdict(),
                         {'years': '2.5'})

def test_time(self):
        """Test parsing time expression."""
        self.assertGreater(
            set(re.match(timeparse.TIMEFORMATS[0] + r'\s*$',
                         '16h32m64s  ').groupdict().items()),
            set([('hours', '16'), ('minutes', '32'), ('seconds', '64')]))

class TestNumberOutput(unittest.TestCase):
    """
    Unit tests to ensure that numerical outputs are correct
    """

def test_timeparse_multipliers(self):
        """Test parsing time unit multipliers."""
        self.assertEqual(timeparse.parse('32 min'),
                         1920)
        self.assertEqual(timeparse.parse('1 min'),
                         60)
        self.assertEqual(timeparse.parse('1 hours'),
                         3600)
        self.assertEqual(timeparse.parse('1 day'),
                         86400)
        self.assertEqual(timeparse.parse('1 sec'),
                         1)

def test_timeparse_signs(self):
        """Test parsing time signs."""
        self.assertEqual(timeparse.parse('+32 m 1 s'), 1921)
        self.assertEqual(timeparse.parse('+ 32 m 1 s'), 1921)
        self.assertEqual(timeparse.parse('-32 m 1 s'), -1921)
        self.assertEqual(timeparse.parse('- 32 m 1 s'), -1921)
        self.assertIsNone(timeparse.parse('32 m - 1 s'))
        self.assertIsNone(timeparse.parse('32 m + 1 s'))

def test_timeparse_1(self):
        """timeparse test case 1."""
        self.assertEqual(timeparse.parse('32m'), 1920)
        self.assertEqual(timeparse.parse('+32m'), 1920)
        self.assertEqual(timeparse.parse('-32m'), -1920)

def test_timeparse_2(self):
        """timeparse test case 2."""
        self.assertEqual(timeparse.parse('2h32m'), 9120)
        self.assertEqual(timeparse.parse('+2h32m'), 9120)
        self.assertEqual(timeparse.parse('-2h32m'), -9120)

def test_timeparse_3(self):
        """timeparse test case 3."""
        self.assertEqual(timeparse.parse('3d2h32m'), 268320)
        self.assertEqual(timeparse.parse('+3d2h32m'), 268320)
        self.assertEqual(timeparse.parse('-3d2h32m'), -268320)

def test_timeparse_4(self):
        """timeparse test case 4."""
        self.assertEqual(timeparse.parse('1w3d2h32m'), 873120)
        self.assertEqual(timeparse.parse('+1w3d2h32m'), 873120)
        self.assertEqual(timeparse.parse('-1w3d2h32m'), -873120)

def test_timeparse_5(self):
        """timeparse test case 5."""
        self.assertEqual(timeparse.parse('1w 3d 2h 32m'), 873120)
        self.assertEqual(timeparse.parse('+1w 3d 2h 32m'), 873120)
        self.assertEqual(timeparse.parse('-1w 3d 2h 32m'), -873120)

def test_timeparse_6(self):
        """timeparse test case 6."""
        self.assertEqual(timeparse.parse('1 w 3 d 2 h 32 m'), 873120)
        self.assertEqual(timeparse.parse('+1 w 3 d 2 h 32 m'), 873120)
        self.assertEqual(timeparse.parse('-1 w 3 d 2 h 32 m'), -873120)

def test_timeparse_7(self):
        """timeparse test case 7."""
        self.assertEqual(timeparse.parse('4:13'), 253)
        self.assertEqual(timeparse.parse('+4:13'), 253)
        self.assertEqual(timeparse.parse('-4:13'), -253)

def test_timeparse_bare_seconds(self):
        """timeparse test bare seconds, without minutes."""
        self.assertEqual(timeparse.parse(':13'), 13)
        self.assertEqual(timeparse.parse('+:13'), 13)
        self.assertEqual(timeparse.parse('-:13'), -13)

def test_timeparse_8(self):
        """timeparse test case 8."""
        self.assertEqual(timeparse.parse('4:13:02'), 15182)
        self.assertEqual(timeparse.parse('+4:13:02'), 15182)
        self.assertEqual(timeparse.parse('-4:13:02'), -15182)

def test_timeparse_9(self):
        """timeparse test case 9."""
        self.assertAlmostEqual(timeparse.parse('4:13:02.266'), 15182.266)
        self.assertAlmostEqual(timeparse.parse('+4:13:02.266'), 15182.266)
        self.assertAlmostEqual(timeparse.parse('-4:13:02.266'), -15182.266)

def test_timeparse_10(self):
        """timeparse test case 10."""
        self.assertAlmostEqual(timeparse.parse('2:04:13:02.266'),
                               187982.266)
        self.assertAlmostEqual(timeparse.parse('+2:04:13:02.266'),
                               187982.266)
        self.assertAlmostEqual(timeparse.parse('-2:04:13:02.266'),
                               -187982.266)

def test_timeparse_granularity_1(self):
        """Check that minute-level granularity applies correctly."""
        self.assertEqual(timeparse.parse('4:32', granularity='minutes'), 272*60)
        self.assertEqual(timeparse.parse('+4:32', granularity='minutes'), 272*60)
        self.assertEqual(timeparse.parse('-4:32', granularity='minutes'), -272*60)

def test_timeparse_granularity_2(self):
        """Check that minute-level granularity does not apply inappropriately."""
        self.assertEqual(timeparse.parse('4:32:02', granularity='minutes'), 272*60+2)
        self.assertEqual(timeparse.parse('+4:32:02', granularity='minutes'), 272*60+2)
        self.assertEqual(timeparse.parse('-4:32:02', granularity='minutes'), -(272*60+2))

def test_timeparse_granularity_3(self):
        """Check that minute-level granularity does not apply inappropriately."""
        self.assertAlmostEqual(timeparse.parse('7:02.223', granularity='minutes'), 7*60 + 2.223)
        self.assertAlmostEqual(timeparse.parse('+7:02.223', granularity='minutes'), 7*60 + 2.223)
        self.assertAlmostEqual(timeparse.parse('-7:02.223', granularity='minutes'), -(7*60 + 2.223))

def test_timeparse_granularity_4(self):
        """Check that minute-level granularity does not apply inappropriately."""
        self.assertEqual(timeparse.parse('0:02', granularity='seconds'), 2)
        self.assertEqual(timeparse.parse('+0:02', granularity='seconds'), 2)
        self.assertEqual(timeparse.parse('-0:02', granularity='seconds'), -2)

def test_timeparse_unparsed(self):
        """Check that unparsed values tries to converts into int(). """
        self.assertEqual(timeparse.parse(100), 100)
        self.assertEqual(timeparse.parse(-18.333), -18.333)
        self.assertEqual(timeparse.parse('99.1'), 99.1)
        self.assertEqual(timeparse.parse('-99.1'), -99.1)

def test_timeparse_11(self):
        """timeparse test case 11."""
        # uptime format
        self.assertEqual(timeparse.parse('2 days,  4:13:02'), 187982)
        self.assertEqual(timeparse.parse('+2 days,  4:13:02'), 187982)
        self.assertEqual(timeparse.parse('-2 days,  4:13:02'), -187982)

def test_timeparse_12(self):
        """timeparse test case 12."""
        self.assertAlmostEqual(timeparse.parse('2 days,  4:13:02.266'),
                               187982.266)
        self.assertAlmostEqual(timeparse.parse('+2 days,  4:13:02.266'),
                               187982.266)
        self.assertAlmostEqual(timeparse.parse('-2 days,  4:13:02.266'),
                               -187982.266)

def test_timeparse_13(self):
        """timeparse test case 13."""
        self.assertEqual(timeparse.parse('5hr34m56s'), 20096)
        self.assertEqual(timeparse.parse('+5hr34m56s'), 20096)
        self.assertEqual(timeparse.parse('-5hr34m56s'), -20096)

def test_timeparse_14(self):
        """timeparse test case 14."""
        self.assertEqual(timeparse.parse('5 hours, 34 minutes, 56 seconds'),
                         20096)
        self.assertEqual(timeparse.parse('+5 hours, 34 minutes, 56 seconds'),
                         20096)
        self.assertEqual(timeparse.parse('-5 hours, 34 minutes, 56 seconds'),
                         -20096)

def test_timeparse_15(self):
        """timeparse test case 15."""
        self.assertEqual(timeparse.parse('5 hrs, 34 mins, 56 secs'), 20096)
        self.assertEqual(timeparse.parse('+5 hrs, 34 mins, 56 secs'), 20096)
        self.assertEqual(timeparse.parse('-5 hrs, 34 mins, 56 secs'), -20096)

def test_timeparse_16(self):
        """timeparse test case 16."""
        self.assertEqual(
            timeparse.parse('2 days, 5 hours, 34 minutes, 56 seconds'),
            192896)
        self.assertEqual(
            timeparse.parse('+2 days, 5 hours, 34 minutes, 56 seconds'),
            192896)
        self.assertEqual(
            timeparse.parse('-2 days, 5 hours, 34 minutes, 56 seconds'),
            -192896)

def test_timeparse_16b(self):
        """timeparse test case 16b."""
        self.assertAlmostEqual(timeparse.parse('1.75 s'), 1.75)
        self.assertAlmostEqual(timeparse.parse('+1.75 s'), 1.75)
        self.assertAlmostEqual(timeparse.parse('-1.75 s'), -1.75)

def test_timeparse_16c(self):
        """timeparse test case 16c."""
        self.assertAlmostEqual(timeparse.parse('1.75 sec'), 1.75)
        self.assertAlmostEqual(timeparse.parse('+1.75 sec'), 1.75)
        self.assertAlmostEqual(timeparse.parse('-1.75 sec'), -1.75)

def test_timeparse_16d(self):
        """timeparse test case 16d."""
        self.assertAlmostEqual(timeparse.parse('1.75 secs'), 1.75)
        self.assertAlmostEqual(timeparse.parse('+1.75 secs'), 1.75)
        self.assertAlmostEqual(timeparse.parse('-1.75 secs'), -1.75)

def test_timeparse_16e(self):
        """timeparse test case 16e."""
        self.assertAlmostEqual(timeparse.parse('1.75 second'), 1.75)
        self.assertAlmostEqual(timeparse.parse('+1.75 second'), 1.75)
        self.assertAlmostEqual(timeparse.parse('-1.75 second'), -1.75)

def test_timeparse_16f(self):
        """timeparse test case 16f."""
        self.assertAlmostEqual(timeparse.parse('1.75 seconds'), 1.75)
        self.assertAlmostEqual(timeparse.parse('+1.75 seconds'), 1.75)
        self.assertAlmostEqual(timeparse.parse('-1.75 seconds'), -1.75)

def test_timeparse_17(self):
        """timeparse test case 17."""
        self.assertEqual(timeparse.parse('1.2 m'), 72)
        self.assertEqual(timeparse.parse('+1.2 m'), 72)
        self.assertEqual(timeparse.parse('-1.2 m'), -72)

def test_timeparse_18(self):
        """timeparse test case 18."""
        self.assertEqual(timeparse.parse('1.2 min'), 72)
        self.assertEqual(timeparse.parse('+1.2 min'), 72)
        self.assertEqual(timeparse.parse('-1.2 min'), -72)

def test_timeparse_19(self):
        """timeparse test case 19."""
        self.assertEqual(timeparse.parse('1.2 mins'), 72)
        self.assertEqual(timeparse.parse('+1.2 mins'), 72)
        self.assertEqual(timeparse.parse('-1.2 mins'), -72)

def test_timeparse_20(self):
        """timeparse test case 20."""
        self.assertEqual(timeparse.parse('1.2 minute'), 72)
        self.assertEqual(timeparse.parse('+1.2 minute'), 72)
        self.assertEqual(timeparse.parse('-1.2 minute'), -72)

def test_timeparse_21(self):
        """timeparse test case 21."""
        self.assertEqual(timeparse.parse('1.2 minutes'), 72)
        self.assertEqual(timeparse.parse('+1.2 minutes'), 72)
        self.assertEqual(timeparse.parse('-1.2 minutes'), -72)

def test_timeparse_22(self):
        """timeparse test case 22."""
        self.assertEqual(timeparse.parse('172 hours'), 619200)
        self.assertEqual(timeparse.parse('+172 hours'), 619200)
        self.assertEqual(timeparse.parse('-172 hours'), -619200)

def test_timeparse_23(self):
        """timeparse test case 23."""
        self.assertEqual(timeparse.parse('172 hr'), 619200)
        self.assertEqual(timeparse.parse('+172 hr'), 619200)
        self.assertEqual(timeparse.parse('-172 hr'), -619200)

def test_timeparse_24(self):
        """timeparse test case 24."""
        self.assertEqual(timeparse.parse('172 h'), 619200)
        self.assertEqual(timeparse.parse('+172 h'), 619200)
        self.assertEqual(timeparse.parse('-172 h'), -619200)

def test_timeparse_25(self):
        """timeparse test case 25."""
        self.assertEqual(timeparse.parse('172 hrs'), 619200)
        self.assertEqual(timeparse.parse('+172 hrs'), 619200)
        self.assertEqual(timeparse.parse('-172 hrs'), -619200)

def test_timeparse_26(self):
        """timeparse test case 26."""
        self.assertEqual(timeparse.parse('172 hour'), 619200)
        self.assertEqual(timeparse.parse('+172 hour'), 619200)
        self.assertEqual(timeparse.parse('-172 hour'), -619200)

def test_timeparse_27(self):
        """timeparse test case 27."""
        self.assertEqual(timeparse.parse('1.24 days'), 107136)
        self.assertEqual(timeparse.parse('+1.24 days'), 107136)
        self.assertEqual(timeparse.parse('-1.24 days'), -107136)

def test_timeparse_28(self):
        """timeparse test case 28."""
        self.assertEqual(timeparse.parse('5 d'), 432000)
        self.assertEqual(timeparse.parse('+5 d'), 432000)
        self.assertEqual(timeparse.parse('-5 d'), -432000)

def test_timeparse_29(self):
        """timeparse test case 29."""
        self.assertEqual(timeparse.parse('5 day'), 432000)
        self.assertEqual(timeparse.parse('+5 day'), 432000)
        self.assertEqual(timeparse.parse('-5 day'), -432000)

def test_timeparse_30(self):
        """timeparse test case 30."""
        self.assertEqual(timeparse.parse('5 days'), 432000)
        self.assertEqual(timeparse.parse('+5 days'), 432000)
        self.assertEqual(timeparse.parse('-5 days'), -432000)

def test_timeparse_31(self):
        """timeparse test case 31."""
        self.assertEqual(timeparse.parse('5.6 wk'), 3386880)
        self.assertEqual(timeparse.parse('+5.6 wk'), 3386880)
        self.assertEqual(timeparse.parse('-5.6 wk'), -3386880)

def test_timeparse_32(self):
        """timeparse test case 32."""
        self.assertEqual(timeparse.parse('5.6 week'), 3386880)
        self.assertEqual(timeparse.parse('+5.6 week'), 3386880)
        self.assertEqual(timeparse.parse('-5.6 week'), -3386880)

def test_timeparse_33(self):
        """timeparse test case 33."""
        self.assertEqual(timeparse.parse('5.6 weeks'), 3386880)
        self.assertEqual(timeparse.parse('+5.6 weeks'), 3386880)
        self.assertEqual(timeparse.parse('-5.6 weeks'), -3386880)

def test_milliseconds(self):
        self.assertEqual(timeparse.parse('3 ms'), 0.003)
        self.assertEqual(timeparse.parse('3 millis'), 0.003)
        self.assertEqual(timeparse.parse('3 msecs'), 0.003)
        self.assertEqual(timeparse.parse('3 milliseconds'), 0.003)

def test_plain_numbers(self):
        self.assertEqual(timeparse.parse('10'), 10)
        self.assertEqual(timeparse.parse('10.1'), 10.1)
        self.assertEqual(timeparse.parse('-10'), -10)
        self.assertEqual(timeparse.parse('-10.1'), -10.1)

def test_combined(self):
        self.assertEqual(timeparse.parse('1y2mo3w4d5h6m7s8ms'), 38898367.008)

class TestRelativeDeltaOutput(unittest.TestCase):
    """
    Unit tests to ensure that numerical outputs are correct
    """

def test_timeparse_multipliers(self):
        """Test parsing time unit multipliers."""
        self.assertEqual(timeparse.parse('32 min', as_timedelta=True), relativedelta(minutes=32))
        self.assertEqual(timeparse.parse('1 min', as_timedelta=True), relativedelta(minutes=1))
        self.assertEqual(timeparse.parse('1 hours', as_timedelta=True), relativedelta(hours=1))
        self.assertEqual(timeparse.parse('1 day', as_timedelta=True), relativedelta(days=1))
        self.assertEqual(timeparse.parse('1 sec', as_timedelta=True), relativedelta(seconds=1))

def test_timeparse_signs(self):
        """Test parsing time signs."""
        self.assertEqual(timeparse.parse('+32 m 1 s', as_timedelta=True), relativedelta(minutes=32, seconds=1))
        self.assertEqual(timeparse.parse('+ 32 m 1 s', as_timedelta=True), relativedelta(minutes=32, seconds=1))
        self.assertEqual(timeparse.parse('-32 m 1 s', as_timedelta=True), -relativedelta(minutes=32, seconds=1))
        self.assertEqual(timeparse.parse('- 32 m 1 s', as_timedelta=True), -relativedelta(minutes=32, seconds=1))
        self.assertIsNone(timeparse.parse('32 m - 1 s', as_timedelta=True))
        self.assertIsNone(timeparse.parse('32 m + 1 s', as_timedelta=True))

def test_timeparse_1(self):
        """timeparse test case 1."""
        self.assertEqual(timeparse.parse('32m', as_timedelta=True), relativedelta(minutes=32))
        self.assertEqual(timeparse.parse('+32m', as_timedelta=True), relativedelta(minutes=32))
        self.assertEqual(timeparse.parse('-32m', as_timedelta=True), -relativedelta(minutes=32))

def test_timeparse_2(self):
        """timeparse test case 2."""
        self.assertEqual(timeparse.parse('2h32m', as_timedelta=True), relativedelta(hours=2, minutes=32))
        self.assertEqual(timeparse.parse('+2h32m', as_timedelta=True), relativedelta(hours=2, minutes=32))
        self.assertEqual(timeparse.parse('-2h32m', as_timedelta=True), -relativedelta(hours=2, minutes=32))

def test_timeparse_3(self):
        """timeparse test case 3."""
        self.assertEqual(timeparse.parse('3d2h32m', as_timedelta=True), relativedelta(days=3, hours=2, minutes=32))
        self.assertEqual(timeparse.parse('+3d2h32m', as_timedelta=True), relativedelta(days=3, hours=2, minutes=32))
        self.assertEqual(timeparse.parse('-3d2h32m', as_timedelta=True), -relativedelta(days=3, hours=2, minutes=32))

def test_timeparse_4(self):
        """timeparse test case 4."""
        self.assertEqual(timeparse.parse('1w3d2h32m', as_timedelta=True), relativedelta(weeks=1, days=3, hours=2, minutes=32))
        self.assertEqual(timeparse.parse('+1w3d2h32m', as_timedelta=True), relativedelta(weeks=1, days=3, hours=2, minutes=32))
        self.assertEqual(timeparse.parse('-1w3d2h32m', as_timedelta=True), -relativedelta(weeks=1, days=3, hours=2, minutes=32))

def test_timeparse_5(self):
        """timeparse test case 5."""
        self.assertEqual(timeparse.parse('1w 3d 2h 32m', as_timedelta=True), relativedelta(weeks=1, days=3, hours=2, minutes=32))
        self.assertEqual(timeparse.parse('+1w 3d 2h 32m', as_timedelta=True), relativedelta(weeks=1, days=3, hours=2, minutes=32))
        self.assertEqual(timeparse.parse('-1w 3d 2h 32m', as_timedelta=True), -relativedelta(weeks=1, days=3, hours=2, minutes=32))

def test_timeparse_6(self):
        """timeparse test case 6."""
        self.assertEqual(timeparse.parse('1 w 3 d 2 h 32 m', as_timedelta=True), relativedelta(weeks=1, days=3, hours=2, minutes=32))
        self.assertEqual(timeparse.parse('+1 w 3 d 2 h 32 m', as_timedelta=True), relativedelta(weeks=1, days=3, hours=2, minutes=32))
        self.assertEqual(timeparse.parse('-1 w 3 d 2 h 32 m', as_timedelta=True), -relativedelta(weeks=1, days=3, hours=2, minutes=32))

def test_timeparse_7(self):
        """timeparse test case 7."""
        self.assertEqual(timeparse.parse('4:13', as_timedelta=True), relativedelta(minutes=4, seconds=13))
        self.assertEqual(timeparse.parse('+4:13', as_timedelta=True), relativedelta(minutes=4, seconds=13))
        self.assertEqual(timeparse.parse('-4:13', as_timedelta=True), -relativedelta(minutes=4, seconds=13))

def test_timeparse_bare_seconds(self):
        """timeparse test bare seconds, without minutes."""
        self.assertEqual(timeparse.parse(':13', as_timedelta=True), relativedelta(seconds=13))
        self.assertEqual(timeparse.parse('+:13', as_timedelta=True), relativedelta(seconds=13))
        self.assertEqual(timeparse.parse('-:13', as_timedelta=True), -relativedelta(seconds=13))

def test_timeparse_8(self):
        """timeparse test case 8."""
        self.assertEqual(timeparse.parse('4:13:02', as_timedelta=True), relativedelta(hours=4, minutes=13, seconds=2))
        self.assertEqual(timeparse.parse('+4:13:02', as_timedelta=True), relativedelta(hours=4, minutes=13, seconds=2))
        self.assertEqual(timeparse.parse('-4:13:02', as_timedelta=True), -relativedelta(hours=4, minutes=13, seconds=2))

def test_timeparse_9(self):
        """timeparse test case 9."""
        self.assertEqual(timeparse.parse('4:13:02.266', as_timedelta=True), relativedelta(hours=4, minutes=13, seconds=2, microseconds=266*1000))
        self.assertEqual(timeparse.parse('+4:13:02.266', as_timedelta=True), relativedelta(hours=4, minutes=13, seconds=2, microseconds=266*1000))
        self.assertEqual(timeparse.parse('-4:13:02.266', as_timedelta=True), -relativedelta(hours=4, minutes=13, seconds=2, microseconds=266*1000))

def test_timeparse_10(self):
        """timeparse test case 10."""
        self.assertEqual(timeparse.parse('2:04:13:02.266', as_timedelta=True), relativedelta(days=2, hours=4, minutes=13, seconds=2, microseconds=266*1000))
        self.assertEqual(timeparse.parse('+2:04:13:02.266', as_timedelta=True), relativedelta(days=2, hours=4, minutes=13, seconds=2, microseconds=266*1000))
        self.assertEqual(timeparse.parse('-2:04:13:02.266', as_timedelta=True), -relativedelta(days=2, hours=4, minutes=13, seconds=2, microseconds=266*1000))

def test_timeparse_granularity_1(self):
        """Check that minute-level granularity applies correctly."""
        self.assertEqual(timeparse.parse('4:32', granularity='minutes', as_timedelta=True), relativedelta(hours=4, minutes=32))
        self.assertEqual(timeparse.parse('+4:32', granularity='minutes', as_timedelta=True), relativedelta(hours=4, minutes=32))
        self.assertEqual(timeparse.parse('-4:32', granularity='minutes', as_timedelta=True), -relativedelta(hours=4, minutes=32))

def test_timeparse_granularity_2(self):
        """Check that minute-level granularity does not apply inappropriately."""
        self.assertEqual(timeparse.parse('4:32:02', granularity='minutes', as_timedelta=True), relativedelta(hours=4, minutes=32, seconds=2))
        self.assertEqual(timeparse.parse('+4:32:02', granularity='minutes', as_timedelta=True), relativedelta(hours=4, minutes=32, seconds=2))
        self.assertEqual(timeparse.parse('-4:32:02', granularity='minutes', as_timedelta=True), -relativedelta(hours=4, minutes=32, seconds=2))

def test_timeparse_granularity_3(self):
        """Check that minute-level granularity does not apply inappropriately."""
        self.assertEqual(timeparse.parse('7:02.223', granularity='minutes', as_timedelta=True), relativedelta(minutes=7, seconds=2, microseconds=1000*223))
        self.assertEqual(timeparse.parse('+7:02.223', granularity='minutes', as_timedelta=True), relativedelta(minutes=7, seconds=2, microseconds=1000*223))
        self.assertEqual(timeparse.parse('-7:02.223', granularity='minutes', as_timedelta=True), -relativedelta(minutes=7, seconds=2, microseconds=1000*223))

def test_timeparse_granularity_4(self):
        """Check that minute-level granularity does not apply inappropriately."""
        self.assertEqual(timeparse.parse('0:02', granularity='seconds', as_timedelta=True), relativedelta(seconds=2))
        self.assertEqual(timeparse.parse('+0:02', granularity='seconds', as_timedelta=True), relativedelta(seconds=2))
        self.assertEqual(timeparse.parse('-0:02', granularity='seconds', as_timedelta=True), -relativedelta(seconds=2))

def test_timeparse_unparsed(self):
        """Check that unparsed values tries to converts into int(). """
        self.assertEqual(timeparse.parse(100, as_timedelta=True), relativedelta(seconds=100))
        self.assertEqual(timeparse.parse(-18.333, as_timedelta=True), -relativedelta(seconds=18, microseconds=333*1000))
        self.assertEqual(timeparse.parse('99.1', as_timedelta=True), relativedelta(seconds=99, microseconds=100*1000))
        self.assertEqual(timeparse.parse('-99.1', as_timedelta=True), -relativedelta(seconds=99, microseconds=100*1000))

def test_timeparse_11(self):
        """timeparse test case 11."""
        # uptime format
        self.assertEqual(timeparse.parse('2 days,  4:13:02', as_timedelta=True), relativedelta(days=2, hours=4, minutes=13, seconds=2))
        self.assertEqual(timeparse.parse('+2 days,  4:13:02', as_timedelta=True), relativedelta(days=2, hours=4, minutes=13, seconds=2))
        self.assertEqual(timeparse.parse('-2 days,  4:13:02', as_timedelta=True), -relativedelta(days=2, hours=4, minutes=13, seconds=2))

def test_timeparse_12(self):
        """timeparse test case 12."""
        self.assertEqual(timeparse.parse('2 days,  4:13:02.266', as_timedelta=True), relativedelta(days=2, hours=4, minutes=13, seconds=2, microseconds=1000*266))
        self.assertEqual(timeparse.parse('+2 days,  4:13:02.266', as_timedelta=True), relativedelta(days=2, hours=4, minutes=13, seconds=2, microseconds=1000*266))
        self.assertEqual(timeparse.parse('-2 days,  4:13:02.266', as_timedelta=True), -relativedelta(days=2, hours=4, minutes=13, seconds=2, microseconds=1000*266))

def test_timeparse_13(self):
        """timeparse test case 13."""
        self.assertEqual(timeparse.parse('5hr34m56s', as_timedelta=True), relativedelta(hours=5, minutes=34, seconds=56))
        self.assertEqual(timeparse.parse('+5hr34m56s', as_timedelta=True), relativedelta(hours=5, minutes=34, seconds=56))
        self.assertEqual(timeparse.parse('-5hr34m56s', as_timedelta=True), -relativedelta(hours=5, minutes=34, seconds=56))

def test_timeparse_14(self):
        """timeparse test case 14."""
        self.assertEqual(timeparse.parse('5 hours, 34 minutes, 56 seconds', as_timedelta=True), relativedelta(hours=5, minutes=34, seconds=56))
        self.assertEqual(timeparse.parse('+5 hours, 34 minutes, 56 seconds', as_timedelta=True), relativedelta(hours=5, minutes=34, seconds=56))
        self.assertEqual(timeparse.parse('-5 hours, 34 minutes, 56 seconds', as_timedelta=True), -relativedelta(hours=5, minutes=34, seconds=56))

def test_timeparse_15(self):
        """timeparse test case 15."""
        self.assertEqual(timeparse.parse('5 hrs, 34 mins, 56 secs', as_timedelta=True), relativedelta(hours=5, minutes=34, seconds=56))
        self.assertEqual(timeparse.parse('+5 hrs, 34 mins, 56 secs', as_timedelta=True), relativedelta(hours=5, minutes=34, seconds=56))
        self.assertEqual(timeparse.parse('-5 hrs, 34 mins, 56 secs', as_timedelta=True), -relativedelta(hours=5, minutes=34, seconds=56))

def test_timeparse_16(self):
        """timeparse test case 16."""
        self.assertEqual(timeparse.parse('2 days, 5 hours, 34 minutes, 56 seconds', as_timedelta=True), relativedelta(days=2, hours=5, minutes=34, seconds=56))
        self.assertEqual(timeparse.parse('+2 days, 5 hours, 34 minutes, 56 seconds', as_timedelta=True), relativedelta(days=2, hours=5, minutes=34, seconds=56))
        self.assertEqual(timeparse.parse('-2 days, 5 hours, 34 minutes, 56 seconds', as_timedelta=True), -relativedelta(days=2, hours=5, minutes=34, seconds=56))

def test_timeparse_16b(self):
        """timeparse test case 16b."""
        self.assertEqual(timeparse.parse('1.75 s', as_timedelta=True), relativedelta(seconds=1, microseconds=75*10000))
        self.assertEqual(timeparse.parse('+1.75 s', as_timedelta=True), relativedelta(seconds=1, microseconds=75*10000))
        self.assertEqual(timeparse.parse('-1.75 s', as_timedelta=True), -relativedelta(seconds=1, microseconds=75*10000))

def test_timeparse_16c(self):
        """timeparse test case 16c."""
        self.assertEqual(timeparse.parse('1.75 sec', as_timedelta=True), relativedelta(seconds=1, microseconds=75*10000))
        self.assertEqual(timeparse.parse('+1.75 sec', as_timedelta=True), relativedelta(seconds=1, microseconds=75*10000))
        self.assertEqual(timeparse.parse('-1.75 sec', as_timedelta=True), -relativedelta(seconds=1, microseconds=75*10000))

def test_timeparse_16d(self):
        """timeparse test case 16d."""
        self.assertEqual(timeparse.parse('1.75 secs', as_timedelta=True), relativedelta(seconds=1, microseconds=75*10000))
        self.assertEqual(timeparse.parse('+1.75 secs', as_timedelta=True), relativedelta(seconds=1, microseconds=75*10000))
        self.assertEqual(timeparse.parse('-1.75 secs', as_timedelta=True), -relativedelta(seconds=1, microseconds=75*10000))

def test_timeparse_16e(self):
        """timeparse test case 16e."""
        self.assertEqual(timeparse.parse('1.75 second', as_timedelta=True), relativedelta(seconds=1, microseconds=75*10000))
        self.assertEqual(timeparse.parse('+1.75 second', as_timedelta=True), relativedelta(seconds=1, microseconds=75*10000))
        self.assertEqual(timeparse.parse('-1.75 second', as_timedelta=True), -relativedelta(seconds=1, microseconds=75*10000))

def test_timeparse_16f(self):
        """timeparse test case 16f."""
        self.assertEqual(timeparse.parse('1.75 seconds', as_timedelta=True), relativedelta(seconds=1, microseconds=75*10000))
        self.assertEqual(timeparse.parse('+1.75 seconds', as_timedelta=True), relativedelta(seconds=1, microseconds=75*10000))
        self.assertEqual(timeparse.parse('-1.75 seconds', as_timedelta=True), -relativedelta(seconds=1, microseconds=75*10000))

def test_timeparse_17(self):
        """timeparse test case 17."""
        self.assertEqual(timeparse.parse('1.2 m', as_timedelta=True), relativedelta(minutes=1, seconds=12))
        self.assertEqual(timeparse.parse('+1.2 m', as_timedelta=True), relativedelta(minutes=1, seconds=12))
        self.assertEqual(timeparse.parse('-1.2 m', as_timedelta=True), -relativedelta(minutes=1, seconds=12))

def test_timeparse_18(self):
        """timeparse test case 18."""
        self.assertEqual(timeparse.parse('1.2 min', as_timedelta=True), relativedelta(minutes=1, seconds=12))
        self.assertEqual(timeparse.parse('+1.2 min', as_timedelta=True), relativedelta(minutes=1, seconds=12))
        self.assertEqual(timeparse.parse('-1.2 min', as_timedelta=True), -relativedelta(minutes=1, seconds=12))

def test_timeparse_19(self):
        """timeparse test case 19."""
        self.assertEqual(timeparse.parse('1.2 mins', as_timedelta=True), relativedelta(minutes=1, seconds=12))
        self.assertEqual(timeparse.parse('+1.2 mins', as_timedelta=True), relativedelta(minutes=1, seconds=12))
        self.assertEqual(timeparse.parse('-1.2 mins', as_timedelta=True), -relativedelta(minutes=1, seconds=12))

def test_timeparse_20(self):
        """timeparse test case 20."""
        self.assertEqual(timeparse.parse('1.2 minute', as_timedelta=True), relativedelta(minutes=1, seconds=12))
        self.assertEqual(timeparse.parse('+1.2 minute', as_timedelta=True), relativedelta(minutes=1, seconds=12))
        self.assertEqual(timeparse.parse('-1.2 minute', as_timedelta=True), -relativedelta(minutes=1, seconds=12))

def test_timeparse_21(self):
        """timeparse test case 21."""
        self.assertEqual(timeparse.parse('1.2 minutes', as_timedelta=True), relativedelta(minutes=1, seconds=12))
        self.assertEqual(timeparse.parse('+1.2 minutes', as_timedelta=True), relativedelta(minutes=1, seconds=12))
        self.assertEqual(timeparse.parse('-1.2 minutes', as_timedelta=True), -relativedelta(minutes=1, seconds=12))

def test_timeparse_22(self):
        """timeparse test case 22."""
        self.assertEqual(timeparse.parse('172 hours', as_timedelta=True), relativedelta(hours=172))
        self.assertEqual(timeparse.parse('+172 hours', as_timedelta=True), relativedelta(hours=172))
        self.assertEqual(timeparse.parse('-172 hours', as_timedelta=True), -relativedelta(hours=172))

def test_timeparse_23(self):
        """timeparse test case 23."""
        self.assertEqual(timeparse.parse('172 hr', as_timedelta=True), relativedelta(hours=172))
        self.assertEqual(timeparse.parse('+172 hr', as_timedelta=True), relativedelta(hours=172))
        self.assertEqual(timeparse.parse('-172 hr', as_timedelta=True), -relativedelta(hours=172))

def test_timeparse_24(self):
        """timeparse test case 24."""
        self.assertEqual(timeparse.parse('172 h', as_timedelta=True), relativedelta(hours=172))
        self.assertEqual(timeparse.parse('+172 h', as_timedelta=True), relativedelta(hours=172))
        self.assertEqual(timeparse.parse('-172 h', as_timedelta=True), -relativedelta(hours=172))

def test_timeparse_25(self):
        """timeparse test case 25."""
        self.assertEqual(timeparse.parse('172 hrs', as_timedelta=True), relativedelta(hours=172))
        self.assertEqual(timeparse.parse('+172 hrs', as_timedelta=True), relativedelta(hours=172))
        self.assertEqual(timeparse.parse('-172 hrs', as_timedelta=True), -relativedelta(hours=172))

def test_timeparse_26(self):
        """timeparse test case 26."""
        self.assertEqual(timeparse.parse('172 hour', as_timedelta=True), relativedelta(hours=172))
        self.assertEqual(timeparse.parse('+172 hour', as_timedelta=True), relativedelta(hours=172))
        self.assertEqual(timeparse.parse('-172 hour', as_timedelta=True), -relativedelta(hours=172))

def test_timeparse_27(self):
        """timeparse test case 27."""
        self.assertEqual(timeparse.parse('1.24 days', as_timedelta=True), relativedelta(days=1, hours=5, minutes=45, seconds=36))
        self.assertEqual(timeparse.parse('+1.24 days', as_timedelta=True), relativedelta(days=1, hours=5, minutes=45, seconds=36))
        self.assertEqual(timeparse.parse('-1.24 days', as_timedelta=True), -relativedelta(days=1, hours=5, minutes=45, seconds=36))

def test_timeparse_28(self):
        """timeparse test case 28."""
        self.assertEqual(timeparse.parse('5 d', as_timedelta=True), relativedelta(days=5))
        self.assertEqual(timeparse.parse('+5 d', as_timedelta=True), relativedelta(days=5))
        self.assertEqual(timeparse.parse('-5 d', as_timedelta=True), -relativedelta(days=5))

def test_timeparse_29(self):
        """timeparse test case 29."""
        self.assertEqual(timeparse.parse('5 day', as_timedelta=True), relativedelta(days=5))
        self.assertEqual(timeparse.parse('+5 day', as_timedelta=True), relativedelta(days=5))
        self.assertEqual(timeparse.parse('-5 day', as_timedelta=True), -relativedelta(days=5))

def test_timeparse_30(self):
        """timeparse test case 30."""
        self.assertEqual(timeparse.parse('5 days', as_timedelta=True), relativedelta(days=5))
        self.assertEqual(timeparse.parse('+5 days', as_timedelta=True), relativedelta(days=5))
        self.assertEqual(timeparse.parse('-5 days', as_timedelta=True), -relativedelta(days=5))

def test_timeparse_31(self):
        """timeparse test case 31."""
        self.assertEqual(timeparse.parse('5.6 wk', as_timedelta=True), relativedelta(days=39, hours=4, minutes=48))
        self.assertEqual(timeparse.parse('+5.6 wk', as_timedelta=True), relativedelta(days=39, hours=4, minutes=48))
        self.assertEqual(timeparse.parse('-5.6 wk', as_timedelta=True), -relativedelta(days=39, hours=4, minutes=48))

def test_timeparse_32(self):
        """timeparse test case 32."""
        self.assertEqual(timeparse.parse('5.6 week', as_timedelta=True), relativedelta(days=39, hours=4, minutes=48))
        self.assertEqual(timeparse.parse('+5.6 week', as_timedelta=True), relativedelta(days=39, hours=4, minutes=48))
        self.assertEqual(timeparse.parse('-5.6 week', as_timedelta=True), -relativedelta(days=39, hours=4, minutes=48))

def test_timeparse_33(self):
        """timeparse test case 33."""
        self.assertEqual(timeparse.parse('5.6 weeks', as_timedelta=True), relativedelta(days=39, hours=4, minutes=48))
        self.assertEqual(timeparse.parse('+5.6 weeks', as_timedelta=True), relativedelta(days=39, hours=4, minutes=48))
        self.assertEqual(timeparse.parse('-5.6 weeks', as_timedelta=True), -relativedelta(days=39, hours=4, minutes=48))

def test_milliseconds(self):
        self.assertEqual(timeparse.parse('3 ms', as_timedelta=True), relativedelta(microseconds=3000))
        self.assertEqual(timeparse.parse('3 millis', as_timedelta=True), relativedelta(microseconds=3000))
        self.assertEqual(timeparse.parse('3 msecs', as_timedelta=True), relativedelta(microseconds=3000))
        self.assertEqual(timeparse.parse('3 milliseconds', as_timedelta=True), relativedelta(microseconds=3000))

def test_plain_numbers(self):
        self.assertEqual(timeparse.parse('10', as_timedelta=True), relativedelta(seconds=10))
        self.assertEqual(timeparse.parse('10.1', as_timedelta=True), relativedelta(seconds=10, microseconds=100000))
        self.assertEqual(timeparse.parse('-10', as_timedelta=True), -relativedelta(seconds=10))
        self.assertEqual(timeparse.parse('-10.1', as_timedelta=True), -relativedelta(seconds=10, microseconds=100000))

def test_combined(self):
        self.assertEqual(timeparse.parse('1y2mo3w4d5h6m7s8ms', as_timedelta=True), relativedelta(years=1, months=2, weeks=3, days=4, hours=5, minutes=6, seconds=7, microseconds=8000))

class MiscTests(unittest.TestCase):
    """
    Miscellaneous unit tests for the `timeparse` module.
    """

def test_strange(self):
        self.assertIsNone(timeparse.parse('1.1.1:22'))

def test_doctest(self):
        """Run timeparse doctests."""
        self.assertTrue(doctest.testmod(timeparse, raise_on_error=True))

def test_disable_dateutil(self):
        self.assertNotIsInstance(timeparse.parse('10:10', as_timedelta=True), datetime.timedelta)
        timeparse.disable_dateutil()
        self.assertIsInstance(timeparse.parse('10:10', as_timedelta=True), datetime.timedelta)
        timeparse.enable_dateutil()
        self.assertNotIsInstance(timeparse.parse('10:10', as_timedelta=True), datetime.timedelta)

if __name__ == '__main__':
    unittest.main('tests')
0707010000000E000081A4000000000000000000000001645D608F000006CC000000000000000000000000000000000000001B00000000pytimeparse2-1.7.1/tox.ini[tox]
envlist = flake,mypy,py36-coverage,py3{7,8,9,10,11}-install
skipsdist = True

[gh-actions]
python =
    3.6: flake,mypy,py36-coverage
    3.7: py37-install
    3.8: py38-install
    3.9: py39-install
    3.10: py310-install
    3.11: py311-install

[testenv]
setenv =
    CCACHE_DIR = {envdir}/.ccache
passenv =
    CC
allowlist_externals =
    rm
    ls
    ln
    bash
    pwd
    cd
    find
    xargs
commands =
  pwd
  pip uninstall pytimeparse2 -y
  install: rm -rfv {envdir}/dist/
  install: python {toxinidir}/setup.py bdist_wheel --dist-dir {envdir}/dist/
  install: bash -c "pip install -U {envdir}/dist/$(ls {envdir}/dist)[dateutil]"
  coverage: python setup.py install_egg_info
  coverage: pip install -U -e .[dateutil]
  install: bash -c "cd {envdir} && python {toxinidir}/tests.py -vv --failfast"
  coverage: coverage debug sys
  coverage: coverage erase
  coverage: coverage run tests.py -vv --failfast {posargs}
  coverage: coverage combine
  coverage: coverage report
  rm -rf .eggs build pytimeparse2.egg-info {envdir}/dist
  install: pip uninstall pytimeparse2 -y
deps =
    coverage: coverage~=5.1
    mock==3.0.5

[testenv:flake]
basepython = python3.6
deps =
    flake8
commands =
  flake8 --config=.pep8 pytimeparse2.py

[testenv:mypy]
basepython = python3.6
deps =
    mypy
    types-python-dateutil
commands =
  mypy pytimeparse2.py

[testenv:contrib]
basepython = python3.6
skipsdist = True
envdir = {toxinidir}/venv
passenv = *
allowlist_externals = *
commands =
    python setup.py install_egg_info
    pip install -U -e .
deps =
   tox

[testenv:build]
passenv = *
changedir = .
allowlist_externals =
    tox
    rm
commands =
    rm -rf dist build
    tox -c tox_build.ini --workdir {toxworkdir}
deps =
0707010000000F000081A4000000000000000000000001645D608F00000121000000000000000000000000000000000000002100000000pytimeparse2-1.7.1/tox_build.ini[tox]
envlist = py36-{wheel,build}
skipsdist = True

[testenv]
passenv = *
changedir = .
whitelist_externals =
    rm
    ls
    grep
    bash
commands =
  rm -rf build
  build: python setup.py compile -v
  wheel: python setup.py bdist_wheel -v
deps =
  wheel==0.31.1
  setuptools>=40.6.3
07070100000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000B00000000TRAILER!!!151 blocks

Places

File pytimeparse2-1.7.1.obscpio of Package python-pytimeparse2 (Revision 7dfcb16f4b0066cfb3bc94ac593f45b5)

Places