diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index 1c5d050d3..71b3913c5 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -45,7 +45,7 @@ jobs:
         with:
           python-version: '${{ matrix.python-version }}'
       - name: Install language-pack-fr
-        run: sudo apt-get install language-pack-fr
+        run: sudo apt-get update && sudo apt-get install language-pack-fr
       - name: Install python dependencies
         run: pip install tox
       - name: tox
diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml
new file mode 100644
index 000000000..77a416bd6
--- /dev/null
+++ b/.github/workflows/publish.yml
@@ -0,0 +1,27 @@
+name: Upload Python Package
+
+on:
+  release:
+    types: [created]
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v2
+      - name: Set up Python
+        uses: actions/setup-python@v2
+        with:
+          python-version: "3.x"
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install setuptools wheel twine
+      - name: Build and publish
+        env:
+          TWINE_USERNAME: __token__
+          TWINE_PASSWORD: ${{ secrets.PYPI_TOKEN }}
+        run: |
+          python setup.py sdist bdist_wheel
+          twine upload dist/*
diff --git a/.gitignore b/.gitignore
index afa82848f..669c9f718 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,5 @@
 *.py[cod]
+.python-version
 
 # C extensions
 *.so
@@ -47,6 +48,7 @@ docs/_build
 # Editors
 *.swp
 .idea
+.vscode/
 
 # Other
 raw_data
diff --git a/CONTRIBUTING.rst b/CONTRIBUTING.rst
index dabd1b87b..ecd87fd65 100644
--- a/CONTRIBUTING.rst
+++ b/CONTRIBUTING.rst
@@ -89,7 +89,7 @@ tests, including testing other Python versions with tox::
 
     $ tox
 
-   To get flake8 and tox, just pip install them into your virtualenv. (Note that we use ``max-line-length = 100`` for flake8, this is configured in ``setup.cfg`` file.)
+   To get ``tox``, just ``pip install`` it into your virtualenv. In addition to tests, ``tox`` checks for code style and maximum line length (119 characters).
 
 6. Commit your changes and push your branch to GitHub::
 
@@ -169,7 +169,7 @@ language, you must:
    :hidden:
 
    template
-   
+
 Updating the List of Supported Languages and Locales
 ----------------------------------------------------
 
diff --git a/HISTORY.rst b/HISTORY.rst
index 09f1de667..a0c1a9473 100644
--- a/HISTORY.rst
+++ b/HISTORY.rst
@@ -3,6 +3,50 @@
 History
 =======
 
+1.1.1 (2022-03-17)
+------------------
+
+Improvements:
+
+- Fixed issue with regex library by pinning dependencies to an earlier version (< 2022.3.15, #1046).
+- Extended support for Russian language dates starting with lowercase (#999).
+- Allowed to use_given_order for languages too (#997).
+- Fixed link to settings section (#1018).
+- Defined UTF-8 encoding for Windows (#998).
+- Fixed directories creation error in CLI utils (#1022).
+
+
+1.1.0 (2021-10-04)
+------------------
+
+New features:
+
+* Support language detection based on ``langdetect``, ``fastText``, or a
+  custom implementation (see #932)
+* Add support for 'by <time>' (see #839)
+* Sort default language list by internet usage (see #805)
+
+Improvements:
+
+* Improved support of Chinese (#910), Czech (#977)
+* Improvements in ``search_dates`` (see #953)
+* Make order of previous locales deterministic (see #851)
+* Fix parsing with trailing space (see #841)
+* Consider ``RETURN_TIME_AS_PERIOD`` for timestamp times (see #922)
+* Exclude failing regex version (see #974)
+* Ongoing work multithreading support (see #881, #885)
+* Add demo URL (see #883)
+
+QA:
+
+* Migrate pipelines from Travis CI to Github Actions (see #859, #879, #884,
+  #886, #911, #966)
+* Use versioned CLDR data (see #825)
+* Add a script to update table of supported languages and locales (see #601)
+* Sort 'skip' keys in yaml files (see #844)
+* Improve test coverage (see #827)
+* Code cleanup (see #888, #907, #951, #958, #957)
+
 
 1.0.0 (2020-10-29)
 ------------------
diff --git a/README.rst b/README.rst
index 7d0bf7ede..f33418f38 100644
--- a/README.rst
+++ b/README.rst
@@ -133,7 +133,7 @@ You can control multiple behaviors by using the ``settings`` parameter:
     datetime.datetime(1992, 1, 2, 0, 0)
 
 To see more examples on how to use the ``settings``, check the `settings
-section <https://dateparser.readthedocs.io/en/latest/usage.html#settings>`__
+section <https://dateparser.readthedocs.io/en/latest/settings.html>`__
 in the docs.
 
 False positives
diff --git a/dateparser/__init__.py b/dateparser/__init__.py
index 05cb9cc02..01122ee3f 100644
--- a/dateparser/__init__.py
+++ b/dateparser/__init__.py
@@ -1,4 +1,4 @@
-__version__ = '1.0.0'
+__version__ = '1.1.1'
 
 from .date import DateDataParser
 from .conf import apply_settings
@@ -7,7 +7,8 @@
 
 
 @apply_settings
-def parse(date_string, date_formats=None, languages=None, locales=None, region=None, settings=None):
+def parse(date_string, date_formats=None, languages=None, locales=None,
+          region=None, settings=None, detect_languages_function=None):
     """Parse date and time from given date string.
 
     :param date_string:
@@ -39,6 +40,12 @@ def parse(date_string, date_formats=None, languages=None, locales=None, region=N
         Configure customized behavior using settings defined in :mod:`dateparser.conf.Settings`.
     :type settings: dict
 
+    :param detect_languages_function:
+        A function for language detection that takes as input a string (the `date_string`) and
+        a `confidence_threshold`, and returns a list of detected language codes.
+        Note: this function is only used if ``languages`` and ``locales`` are not provided.
+    :type detect_languages_function: function
+
     :return: Returns :class:`datetime <datetime.datetime>` representing parsed date if successful, else returns None
     :rtype: :class:`datetime <datetime.datetime>`.
     :raises:
@@ -47,9 +54,9 @@ def parse(date_string, date_formats=None, languages=None, locales=None, region=N
     """
     parser = _default_parser
 
-    if languages or locales or region or not settings._default:
+    if languages or locales or region or detect_languages_function or not settings._default:
         parser = DateDataParser(languages=languages, locales=locales,
-                                region=region, settings=settings)
+                                region=region, settings=settings, detect_languages_function=detect_languages_function)
 
     data = parser.get_date_data(date_string, date_formats)
 
diff --git a/dateparser/conf.py b/dateparser/conf.py
index c14374a3f..3a7c41f89 100644
--- a/dateparser/conf.py
+++ b/dateparser/conf.py
@@ -2,6 +2,7 @@
 from datetime import datetime
 from functools import wraps
 
+from dateparser.data.languages_info import language_order
 from .parser import date_order_chart
 from .utils import registry
 
@@ -25,6 +26,8 @@ class Settings:
     * `NORMALIZE`
     * `RETURN_TIME_AS_PERIOD`
     * `PARSERS`
+    * `DEFAULT_LANGUAGES`
+    * `LANGUAGE_DETECTION_CONFIDENCE_THRESHOLD`
     """
 
     _default = True
@@ -117,7 +120,7 @@ def _check_require_part(setting_name, setting_value):
 def _check_parsers(setting_name, setting_value):
     """Returns `True` if the provided list of parsers contains valid values"""
     existing_parsers = [
-        'timestamp', 'relative-time', 'custom-formats', 'absolute-time', 'no-spaces-time'
+        'timestamp', 'relative-time', 'custom-formats', 'absolute-time', 'no-spaces-time', 'negative-timestamp'
     ]  # FIXME: Extract the list of existing parsers from another place (#798)
     unknown_parsers = set(setting_value) - set(existing_parsers)
     if unknown_parsers:
@@ -129,6 +132,28 @@ def _check_parsers(setting_name, setting_value):
     _check_repeated_values(setting_name, setting_value)
 
 
+def _check_default_languages(setting_name, setting_value):
+    unsupported_languages = set(setting_value) - set(language_order)
+    if unsupported_languages:
+        raise SettingValidationError(
+            "Found invalid languages in the '{}' setting: {}".format(
+                setting_name, ', '.join(map(repr, unsupported_languages))
+            )
+        )
+    _check_repeated_values(setting_name, setting_value)
+
+
+def _check_between_0_and_1(setting_name, setting_value):
+    is_valid = 0 <= setting_value <= 1
+    if not is_valid:
+        raise SettingValidationError(
+            '{} is not a valid value for {}. It can take values between 0 and '
+            '1.'.format(
+                setting_value, setting_name,
+            )
+        )
+
+
 def check_settings(settings):
     """
     Check if provided settings are valid, if not it raises `SettingValidationError`.
@@ -193,6 +218,14 @@ def check_settings(settings):
         'PREFER_LOCALE_DATE_ORDER': {
             'type': bool
         },
+        'DEFAULT_LANGUAGES': {
+            'type': list,
+            'extra_check': _check_default_languages
+        },
+        'LANGUAGE_DETECTION_CONFIDENCE_THRESHOLD': {
+            'type': float,
+            'extra_check': _check_between_0_and_1
+        },
     }
 
     modified_settings = settings._mod_settings  # check only modified settings
diff --git a/dateparser/custom_language_detection/__init__.py b/dateparser/custom_language_detection/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/dateparser/custom_language_detection/fasttext.py b/dateparser/custom_language_detection/fasttext.py
new file mode 100644
index 000000000..2adec5add
--- /dev/null
+++ b/dateparser/custom_language_detection/fasttext.py
@@ -0,0 +1,45 @@
+import os
+
+import fasttext
+
+from dateparser_cli.fasttext_manager import fasttext_downloader
+from dateparser_cli.utils import dateparser_model_home, create_data_model_home
+from dateparser_cli.exceptions import FastTextModelNotFoundException
+
+
+_supported_models = ["large.bin", "small.bin"]
+_DEFAULT_MODEL = "small"
+
+
+class _FastTextCache:
+    model = None
+
+
+def _load_fasttext_model():
+    if _FastTextCache.model:
+        return _FastTextCache.model
+    create_data_model_home()
+    downloaded_models = [
+        file for file in os.listdir(dateparser_model_home)
+        if file in _supported_models
+    ]
+    if not downloaded_models:
+        fasttext_downloader(_DEFAULT_MODEL)
+        return _load_fasttext_model()
+    model_path = os.path.join(dateparser_model_home, downloaded_models[0])
+    if not os.path.isfile(model_path):
+        raise FastTextModelNotFoundException('Fasttext model file not found')
+    _FastTextCache.model = fasttext.load_model(model_path)
+    return _FastTextCache.model
+
+
+def detect_languages(text, confidence_threshold):
+    _language_parser = _load_fasttext_model()
+    text = text.replace('\n', ' ').replace('\r', '')
+    language_codes = []
+    parser_data = _language_parser.predict(text)
+    for idx, language_probability in enumerate(parser_data[1]):
+        if language_probability > confidence_threshold:
+            language_code = parser_data[0][idx].replace("__label__", "")
+            language_codes.append(language_code)
+    return language_codes
diff --git a/dateparser/custom_language_detection/langdetect.py b/dateparser/custom_language_detection/langdetect.py
new file mode 100644
index 000000000..5ef8f6220
--- /dev/null
+++ b/dateparser/custom_language_detection/langdetect.py
@@ -0,0 +1,37 @@
+import langdetect
+
+
+# The below _Factory is set to prevent setting global state of the library
+# but still get consistent results.
+# Refer : https://github.com/Mimino666/langdetect
+
+class _Factory:
+    data = None
+
+
+def _init_factory():
+    if _Factory.data is None:
+        _Factory.data = langdetect.detector_factory.DetectorFactory()
+        _Factory.data.load_profile(langdetect.detector_factory.PROFILES_DIRECTORY)
+        _Factory.data.seed = 0
+
+
+def _get_language_probablities(text):
+    _init_factory()
+    detector = _Factory.data.create()
+    detector.append(text)
+    return detector.get_probabilities()
+
+
+def detect_languages(text, confidence_threshold):
+    language_codes = []
+    try:
+        parser_data = _get_language_probablities(text)
+        for language_candidate in parser_data:
+            if language_candidate.prob > confidence_threshold:
+                language_codes.append(language_candidate.lang)
+    except langdetect.lang_detect_exception.LangDetectException:
+        # This exception can be produced with empty strings or inputs without letters like `10-10-2021`.
+        # As this could be really common, we ignore them.
+        pass
+    return language_codes
diff --git a/dateparser/custom_language_detection/language_mapping.py b/dateparser/custom_language_detection/language_mapping.py
new file mode 100644
index 000000000..a76030828
--- /dev/null
+++ b/dateparser/custom_language_detection/language_mapping.py
@@ -0,0 +1,18 @@
+from dateparser.data.languages_info import language_map
+
+
+def map_languages(language_codes):
+    """
+    Returns the candidates from the supported languages codes.
+    :param language_codes:
+        A list of language codes, e.g. ['en', 'es'] in ISO 639 Standard.
+    :type language_codes: list
+    :return: Returns list[str] representing supported languages
+    :rtype: list[str]
+    """
+    return [
+        language_code
+        for language in language_codes
+        if language in language_map
+        for language_code in language_map[language]
+    ]
diff --git a/dateparser/data/languages_info.py b/dateparser/data/languages_info.py
index 14047cf21..02ab3df43 100644
--- a/dateparser/data/languages_info.py
+++ b/dateparser/data/languages_info.py
@@ -206,6 +206,594 @@
     "tl"
 ]
 
+language_map = {
+    "af": [
+        "af"
+    ],
+    "agq": [
+        "agq"
+    ],
+    "ak": [
+        "ak"
+    ],
+    "am": [
+        "am"
+    ],
+    "ar": [
+        "ar"
+    ],
+    "as": [
+        "as"
+    ],
+    "asa": [
+        "asa"
+    ],
+    "ast": [
+        "ast"
+    ],
+    "az": [
+        "az",
+        "az-Cyrl",
+        "az-Latn"
+    ],
+    "bas": [
+        "bas"
+    ],
+    "be": [
+        "be"
+    ],
+    "bem": [
+        "bem"
+    ],
+    "bez": [
+        "bez"
+    ],
+    "bg": [
+        "bg"
+    ],
+    "bm": [
+        "bm"
+    ],
+    "bn": [
+        "bn"
+    ],
+    "bo": [
+        "bo"
+    ],
+    "br": [
+        "br"
+    ],
+    "brx": [
+        "brx"
+    ],
+    "bs": [
+        "bs",
+        "bs-Cyrl",
+        "bs-Latn"
+    ],
+    "ca": [
+        "ca"
+    ],
+    "ce": [
+        "ce"
+    ],
+    "cgg": [
+        "cgg"
+    ],
+    "chr": [
+        "chr"
+    ],
+    "ckb": [
+        "ckb"
+    ],
+    "cs": [
+        "cs"
+    ],
+    "cy": [
+        "cy"
+    ],
+    "da": [
+        "da"
+    ],
+    "dav": [
+        "dav"
+    ],
+    "de": [
+        "de"
+    ],
+    "dje": [
+        "dje"
+    ],
+    "dsb": [
+        "dsb"
+    ],
+    "dua": [
+        "dua"
+    ],
+    "dyo": [
+        "dyo"
+    ],
+    "dz": [
+        "dz"
+    ],
+    "ebu": [
+        "ebu"
+    ],
+    "ee": [
+        "ee"
+    ],
+    "el": [
+        "el"
+    ],
+    "en": [
+        "en"
+    ],
+    "eo": [
+        "eo"
+    ],
+    "es": [
+        "es"
+    ],
+    "et": [
+        "et"
+    ],
+    "eu": [
+        "eu"
+    ],
+    "ewo": [
+        "ewo"
+    ],
+    "fa": [
+        "fa"
+    ],
+    "ff": [
+        "ff"
+    ],
+    "fi": [
+        "fi"
+    ],
+    "fil": [
+        "fil"
+    ],
+    "fo": [
+        "fo"
+    ],
+    "fr": [
+        "fr"
+    ],
+    "fur": [
+        "fur"
+    ],
+    "fy": [
+        "fy"
+    ],
+    "ga": [
+        "ga"
+    ],
+    "gd": [
+        "gd"
+    ],
+    "gl": [
+        "gl"
+    ],
+    "gsw": [
+        "gsw"
+    ],
+    "gu": [
+        "gu"
+    ],
+    "guz": [
+        "guz"
+    ],
+    "gv": [
+        "gv"
+    ],
+    "ha": [
+        "ha"
+    ],
+    "haw": [
+        "haw"
+    ],
+    "he": [
+        "he"
+    ],
+    "hi": [
+        "hi"
+    ],
+    "hr": [
+        "hr"
+    ],
+    "hsb": [
+        "hsb"
+    ],
+    "hu": [
+        "hu"
+    ],
+    "hy": [
+        "hy"
+    ],
+    "id": [
+        "id"
+    ],
+    "ig": [
+        "ig"
+    ],
+    "ii": [
+        "ii"
+    ],
+    "is": [
+        "is"
+    ],
+    "it": [
+        "it"
+    ],
+    "ja": [
+        "ja"
+    ],
+    "jgo": [
+        "jgo"
+    ],
+    "jmc": [
+        "jmc"
+    ],
+    "ka": [
+        "ka"
+    ],
+    "kab": [
+        "kab"
+    ],
+    "kam": [
+        "kam"
+    ],
+    "kde": [
+        "kde"
+    ],
+    "kea": [
+        "kea"
+    ],
+    "khq": [
+        "khq"
+    ],
+    "ki": [
+        "ki"
+    ],
+    "kk": [
+        "kk"
+    ],
+    "kl": [
+        "kl"
+    ],
+    "kln": [
+        "kln"
+    ],
+    "km": [
+        "km"
+    ],
+    "kn": [
+        "kn"
+    ],
+    "ko": [
+        "ko"
+    ],
+    "kok": [
+        "kok"
+    ],
+    "ks": [
+        "ks"
+    ],
+    "ksb": [
+        "ksb"
+    ],
+    "ksf": [
+        "ksf"
+    ],
+    "ksh": [
+        "ksh"
+    ],
+    "kw": [
+        "kw"
+    ],
+    "ky": [
+        "ky"
+    ],
+    "lag": [
+        "lag"
+    ],
+    "lb": [
+        "lb"
+    ],
+    "lg": [
+        "lg"
+    ],
+    "lkt": [
+        "lkt"
+    ],
+    "ln": [
+        "ln"
+    ],
+    "lo": [
+        "lo"
+    ],
+    "lrc": [
+        "lrc"
+    ],
+    "lt": [
+        "lt"
+    ],
+    "lu": [
+        "lu"
+    ],
+    "luo": [
+        "luo"
+    ],
+    "luy": [
+        "luy"
+    ],
+    "lv": [
+        "lv"
+    ],
+    "mas": [
+        "mas"
+    ],
+    "mer": [
+        "mer"
+    ],
+    "mfe": [
+        "mfe"
+    ],
+    "mg": [
+        "mg"
+    ],
+    "mgh": [
+        "mgh"
+    ],
+    "mgo": [
+        "mgo"
+    ],
+    "mk": [
+        "mk"
+    ],
+    "ml": [
+        "ml"
+    ],
+    "mn": [
+        "mn"
+    ],
+    "mr": [
+        "mr"
+    ],
+    "ms": [
+        "ms"
+    ],
+    "mt": [
+        "mt"
+    ],
+    "mua": [
+        "mua"
+    ],
+    "my": [
+        "my"
+    ],
+    "mzn": [
+        "mzn"
+    ],
+    "naq": [
+        "naq"
+    ],
+    "nb": [
+        "nb"
+    ],
+    "nd": [
+        "nd"
+    ],
+    "ne": [
+        "ne"
+    ],
+    "nl": [
+        "nl"
+    ],
+    "nmg": [
+        "nmg"
+    ],
+    "nn": [
+        "nn"
+    ],
+    "nnh": [
+        "nnh"
+    ],
+    "nus": [
+        "nus"
+    ],
+    "nyn": [
+        "nyn"
+    ],
+    "om": [
+        "om"
+    ],
+    "or": [
+        "or"
+    ],
+    "os": [
+        "os"
+    ],
+    "pa": [
+        "pa",
+        "pa-Arab",
+        "pa-Guru"
+    ],
+    "pl": [
+        "pl"
+    ],
+    "ps": [
+        "ps"
+    ],
+    "pt": [
+        "pt"
+    ],
+    "qu": [
+        "qu"
+    ],
+    "rm": [
+        "rm"
+    ],
+    "rn": [
+        "rn"
+    ],
+    "ro": [
+        "ro"
+    ],
+    "rof": [
+        "rof"
+    ],
+    "ru": [
+        "ru"
+    ],
+    "rw": [
+        "rw"
+    ],
+    "rwk": [
+        "rwk"
+    ],
+    "sah": [
+        "sah"
+    ],
+    "saq": [
+        "saq"
+    ],
+    "sbp": [
+        "sbp"
+    ],
+    "se": [
+        "se"
+    ],
+    "seh": [
+        "seh"
+    ],
+    "ses": [
+        "ses"
+    ],
+    "sg": [
+        "sg"
+    ],
+    "shi": [
+        "shi",
+        "shi-Latn",
+        "shi-Tfng"
+    ],
+    "si": [
+        "si"
+    ],
+    "sk": [
+        "sk"
+    ],
+    "sl": [
+        "sl"
+    ],
+    "smn": [
+        "smn"
+    ],
+    "sn": [
+        "sn"
+    ],
+    "so": [
+        "so"
+    ],
+    "sq": [
+        "sq"
+    ],
+    "sr": [
+        "sr",
+        "sr-Cyrl",
+        "sr-Latn"
+    ],
+    "sv": [
+        "sv"
+    ],
+    "sw": [
+        "sw"
+    ],
+    "ta": [
+        "ta"
+    ],
+    "te": [
+        "te"
+    ],
+    "teo": [
+        "teo"
+    ],
+    "th": [
+        "th"
+    ],
+    "ti": [
+        "ti"
+    ],
+    "tl": [
+        "tl"
+    ],
+    "to": [
+        "to"
+    ],
+    "tr": [
+        "tr"
+    ],
+    "twq": [
+        "twq"
+    ],
+    "tzm": [
+        "tzm"
+    ],
+    "ug": [
+        "ug"
+    ],
+    "uk": [
+        "uk"
+    ],
+    "ur": [
+        "ur"
+    ],
+    "uz": [
+        "uz",
+        "uz-Arab",
+        "uz-Cyrl",
+        "uz-Latn"
+    ],
+    "vi": [
+        "vi"
+    ],
+    "vun": [
+        "vun"
+    ],
+    "wae": [
+        "wae"
+    ],
+    "xog": [
+        "xog"
+    ],
+    "yav": [
+        "yav"
+    ],
+    "yi": [
+        "yi"
+    ],
+    "yo": [
+        "yo"
+    ],
+    "yue": [
+        "yue"
+    ],
+    "zgh": [
+        "zgh"
+    ],
+    "zh": [
+        "zh",
+        "zh-Hans",
+        "zh-Hant"
+    ],
+    "zu": [
+        "zu"
+    ]
+}
+
 language_locale_dict = {
     "en": [
         "en-001",
diff --git a/dateparser/date.py b/dateparser/date.py
index 8cc3d2d57..c24ec5c77 100644
--- a/dateparser/date.py
+++ b/dateparser/date.py
@@ -16,6 +16,7 @@
 from dateparser.utils import apply_timezone_from_settings, \
     set_correct_day_from_settings, \
     get_timezone_from_tz_string
+from dateparser.custom_language_detection.language_mapping import map_languages
 
 APOSTROPHE_LOOK_ALIKE_CHARS = [
     '\N{RIGHT SINGLE QUOTATION MARK}',     # '\u2019'
@@ -34,13 +35,14 @@
 RE_TRIM_SPACES = re.compile(r'^\s+(\S.*?)\s+$')
 RE_TRIM_COLONS = re.compile(r'(\S.*?):*$')
 
-RE_SANITIZE_SKIP = re.compile(r'\t|\n|\r|\u00bb|,\s\u0432|\u200e|\xb7|\u200f|\u064e|\u064f', flags=re.M)
+RE_SANITIZE_SKIP = re.compile(r'\t|\n|\r|\u00bb|,\s\u0432\b|\u200e|\xb7|\u200f|\u064e|\u064f', flags=re.M)
 RE_SANITIZE_RUSSIAN = re.compile(r'([\W\d])\u0433\.', flags=re.I | re.U)
 RE_SANITIZE_PERIOD = re.compile(r'(?<=\D+)\.', flags=re.U)
 RE_SANITIZE_ON = re.compile(r'^.*?on:\s+(.*)')
 RE_SANITIZE_APOSTROPHE = re.compile('|'.join(APOSTROPHE_LOOK_ALIKE_CHARS))
 
 RE_SEARCH_TIMESTAMP = re.compile(r'^(\d{10})(\d{3})?(\d{3})?(?![^.])')
+RE_SEARCH_NEGATIVE_TIMESTAMP = re.compile(r'^([-]\d{10})(\d{3})?(\d{3})?(?![^.])')
 
 
 def sanitize_spaces(date_string):
@@ -113,8 +115,12 @@ def sanitize_date(date_string):
     return date_string
 
 
-def get_date_from_timestamp(date_string, settings):
-    match = RE_SEARCH_TIMESTAMP.search(date_string)
+def get_date_from_timestamp(date_string, settings, negative=False):
+    if negative:
+        match = RE_SEARCH_NEGATIVE_TIMESTAMP.search(date_string)
+    else:
+         match = RE_SEARCH_TIMESTAMP.search(date_string)
+
     if match:
         if settings is not None and settings.TIMEZONE is not None and 'local' not in settings.TIMEZONE.lower():
             local_timezone = get_timezone_from_tz_string(settings.TIMEZONE)
@@ -174,6 +180,7 @@ def __init__(self, locale, date_string, date_formats, settings=None):
         self._translated_date_with_formatting = None
         self._parsers = {
             'timestamp': self._try_timestamp,
+            'negative-timestamp': self._try_negative_timestamp,
             'relative-time': self._try_freshness_parser,
             'custom-formats': self._try_given_formats,
             'absolute-time': self._try_absolute_parser,
@@ -193,12 +200,18 @@ def _parse(self):
         else:
             return None
 
-    def _try_timestamp(self):
+    def _try_timestamp_parser(self, negative=False):
         return DateData(
-            date_obj=get_date_from_timestamp(self.date_string, self._settings),
-            period='day',
+            date_obj=get_date_from_timestamp(self.date_string, self._settings, negative=negative),
+            period='time' if self._settings.RETURN_TIME_AS_PERIOD else 'day',
         )
 
+    def _try_timestamp(self):
+        return self._try_timestamp_parser()
+
+    def _try_negative_timestamp(self):
+        return self._try_timestamp_parser(negative=True)
+
     def _try_freshness_parser(self):
         try:
             return freshness_date_parser.get_date_data(self._get_translated_date(), self._settings)
@@ -330,6 +343,12 @@ class DateDataParser:
         Configure customized behavior using settings defined in :mod:`dateparser.conf.Settings`.
     :type settings: dict
 
+    :param detect_languages_function:
+        A function for language detection that takes as input a `text` and a `confidence_threshold`,
+        and returns a list of detected language codes.
+        Note: this function is only used if ``languages`` and ``locales`` are not provided.
+    :type detect_languages_function: function
+
     :return: A parser instance
 
     :raises:
@@ -341,7 +360,7 @@ class DateDataParser:
 
     @apply_settings
     def __init__(self, languages=None, locales=None, region=None, try_previous_locales=False,
-                 use_given_order=False, settings=None):
+                 use_given_order=False, settings=None, detect_languages_function=None):
 
         if languages is not None and not isinstance(languages, (list, tuple, Set)):
             raise TypeError("languages argument must be a list (%r given)" % type(languages))
@@ -360,17 +379,18 @@ def __init__(self, languages=None, locales=None, region=None, try_previous_local
             raise TypeError("use_given_order argument must be a boolean (%r given)"
                             % type(use_given_order))
 
-        if not locales and use_given_order:
-            raise ValueError("locales must be given if use_given_order is True")
+        if not locales and not languages and use_given_order:
+            raise ValueError("locales or languages must be given if use_given_order is True")
 
         check_settings(settings)
 
         self._settings = settings
         self.try_previous_locales = try_previous_locales
         self.use_given_order = use_given_order
-        self.languages = languages
+        self.languages = list(languages) if languages else None
         self.locales = locales
         self.region = region
+        self.detect_languages_function = detect_languages_function
         self.previous_locales = collections.OrderedDict()
 
     def get_date_data(self, date_string, date_formats=None):
@@ -470,6 +490,13 @@ def date_strings():
                     if self._is_applicable_locale(locale, s):
                         yield locale
 
+        if self.detect_languages_function and not self.languages and not self.locales:
+            detected_languages = self.detect_languages_function(
+                text=date_string, confidence_threshold=self._settings.LANGUAGE_DETECTION_CONFIDENCE_THRESHOLD
+            )
+
+            self.languages = map_languages(detected_languages)
+
         for locale in self._get_locale_loader().get_locales(
                 languages=self.languages, locales=self.locales, region=self.region,
                 use_given_order=self.use_given_order):
@@ -477,6 +504,13 @@ def date_strings():
                 if self._is_applicable_locale(locale, s):
                     yield locale
 
+        if self._settings.DEFAULT_LANGUAGES:
+            for locale in self._get_locale_loader().get_locales(
+                languages=self._settings.DEFAULT_LANGUAGES, locales=None,
+                region=self.region, use_given_order=self.use_given_order
+            ):
+                yield locale
+
     def _is_applicable_locale(self, locale, date_string):
         return locale.is_applicable(
             date_string,
diff --git a/dateparser/date_parser.py b/dateparser/date_parser.py
index 7c36a2fbc..7c1b817df 100644
--- a/dateparser/date_parser.py
+++ b/dateparser/date_parser.py
@@ -1,3 +1,5 @@
+import sys
+
 from tzlocal import get_localzone
 
 from .timezone_parser import pop_tz_offset_from_string
@@ -31,7 +33,7 @@ def parse(self, date_string, parse_method, settings=None):
         else:
             if 'local' in _settings_tz:
                 stz = get_localzone()
-                if hasattr(stz, 'localize'):
+                if hasattr(stz, 'localize') and sys.version_info < (3, 6):
                     date_obj = stz.localize(date_obj)
                 else:
                     date_obj = date_obj.replace(tzinfo=stz)
diff --git a/dateparser/languages/locale.py b/dateparser/languages/locale.py
index dba5528b0..0cb578552 100644
--- a/dateparser/languages/locale.py
+++ b/dateparser/languages/locale.py
@@ -176,6 +176,7 @@ def _generate_relative_translations(self, normalize=False):
 
     def translate_search(self, search_string, settings=None):
         dashes = ['-', '——', '—', '～']
+        word_joint_unsupported_languages = ["zh", "ja"]
         sentences = self._sentence_split(search_string, settings=settings)
         dictionary = self._get_dictionary(settings=settings)
         translated = []
@@ -184,10 +185,28 @@ def translate_search(self, search_string, settings=None):
             original_tokens, simplified_tokens = self._simplify_split_align(sentence, settings=settings)
             translated_chunk = []
             original_chunk = []
+            last_token_index = len(simplified_tokens) - 1
+            skip_next_token = False
             for i, word in enumerate(simplified_tokens):
+                next_word = simplified_tokens[i + 1] if i < last_token_index else ""
+                current_and_next_joined = self._join_chunk([word, next_word], settings=settings)
+                if skip_next_token:
+                    skip_next_token = False
+                    continue
+
                 if word == '' or word == ' ':
                     translated_chunk.append(word)
                     original_chunk.append(original_tokens[i])
+                elif (
+                    current_and_next_joined in dictionary
+                    and word not in dashes
+                    and self.shortname not in word_joint_unsupported_languages
+                ):
+                    translated_chunk.append(dictionary[current_and_next_joined])
+                    original_chunk.append(
+                        self._join_chunk([original_tokens[i], original_tokens[i + 1]], settings=settings)
+                    )
+                    skip_next_token = True
                 elif word in dictionary and word not in dashes:
                     translated_chunk.append(dictionary[word])
                     original_chunk.append(original_tokens[i])
diff --git a/dateparser/parser.py b/dateparser/parser.py
index 025b0d44d..e2df66b03 100644
--- a/dateparser/parser.py
+++ b/dateparser/parser.py
@@ -354,7 +354,7 @@ def _get_datetime_obj(self, **params):
         except ValueError as e:
             error_text = e.__str__()
             error_msgs = ['day is out of range', 'day must be in']
-            if (error_msgs[0] in error_text or error_msgs[1] in error_text):
+            if error_msgs[0] in error_text or error_msgs[1] in error_text:
                 if not(self._token_day or hasattr(self, '_token_weekday')):
                     # if day is not available put last day of the month
                     params['day'] = get_last_day_of_month(params['year'], params['month'])
diff --git a/dateparser/search/__init__.py b/dateparser/search/__init__.py
index fe6306606..67205d4b0 100644
--- a/dateparser/search/__init__.py
+++ b/dateparser/search/__init__.py
@@ -4,7 +4,7 @@
 _search_with_detection = DateSearchWithDetection()
 
 
-def search_dates(text, languages=None, settings=None, add_detected_language=False):
+def search_dates(text, languages=None, settings=None, add_detected_language=False, detect_languages_function=None):
     """Find all substrings of the given string which represent date and/or time and parse them.
 
         :param text:
@@ -17,17 +17,23 @@ def search_dates(text, languages=None, settings=None, add_detected_language=Fals
         :type languages: list
 
         :param settings:
-               Configure customized behavior using settings defined in :mod:`dateparser.conf.Settings`.
+            Configure customized behavior using settings defined in :mod:`dateparser.conf.Settings`.
         :type settings: dict
 
         :param add_detected_language:
-               Indicates if we want the detected language returned in the tuple.
+            Indicates if we want the detected language returned in the tuple.
         :type add_detected_language: bool
 
+        :param detect_languages_function:
+            A function for language detection that takes as input a `text` and a `confidence_threshold`,
+            and returns a list of detected language codes.
+            Note: detect_languages_function is only uses if `languages` are not provided.
+        :type detect_languages_function: function
+
         :return: Returns list of tuples containing:
-                 substrings representing date and/or time, corresponding :mod:`datetime.datetime`
-                 object and detected language if *add_detected_language* is True.
-                 Returns None if no dates that can be parsed are found.
+            substrings representing date and/or time, corresponding :mod:`datetime.datetime`
+            object and detected language if *add_detected_language* is True.
+            Returns None if no dates that can be parsed are found.
         :rtype: list
         :raises: ValueError - Unknown Language
 
@@ -47,7 +53,7 @@ def search_dates(text, languages=None, settings=None, add_detected_language=Fals
 
         """
     result = _search_with_detection.search_dates(
-        text=text, languages=languages, settings=settings
+        text=text, languages=languages, settings=settings, detect_languages_function=detect_languages_function
     )
     dates = result.get('Dates')
     if dates:
diff --git a/dateparser/search/search.py b/dateparser/search/search.py
index aa71c7299..3fc657810 100644
--- a/dateparser/search/search.py
+++ b/dateparser/search/search.py
@@ -1,9 +1,10 @@
 from collections.abc import Set
 
 from dateparser.languages.loader import LocaleDataLoader
-from dateparser.conf import apply_settings, Settings
+from dateparser.conf import apply_settings, check_settings, Settings
 from dateparser.date import DateDataParser
 from dateparser.search.text_detection import FullTextLanguageDetector
+from dateparser.custom_language_detection.language_mapping import map_languages
 import regex as re
 
 
@@ -171,15 +172,21 @@ def __init__(self):
         self.available_language_map = self.loader.get_locale_map()
         self.search = _ExactLanguageSearch(self.loader)
 
-    def detect_language(self, text, languages):
-        if isinstance(languages, (list, tuple, Set)):
+    @apply_settings
+    def detect_language(self, text, languages, settings=None, detect_languages_function=None):
+        if detect_languages_function and not languages:
+            detected_languages = detect_languages_function(
+                text, confidence_threshold=settings.LANGUAGE_DETECTION_CONFIDENCE_THRESHOLD
+            )
+            detected_languages = map_languages(detected_languages) or settings.DEFAULT_LANGUAGES
+            return detected_languages[0] if detected_languages else None
 
+        if isinstance(languages, (list, tuple, Set)):
             if all([language in self.available_language_map for language in languages]):
                 languages = [self.available_language_map[language] for language in languages]
             else:
                 unsupported_languages = set(languages) - set(self.available_language_map.keys())
-                raise ValueError(
-                    "Unknown language(s): %s" % ', '.join(map(repr, unsupported_languages)))
+                raise ValueError("Unknown language(s): %s" % ', '.join(map(repr, unsupported_languages)))
         elif languages is not None:
             raise TypeError("languages argument must be a list (%r given)" % type(languages))
 
@@ -188,24 +195,34 @@ def detect_language(self, text, languages):
         else:
             self.language_detector = FullTextLanguageDetector(list(self.available_language_map.values()))
 
-        return self.language_detector._best_language(text)
+        detected_language = self.language_detector._best_language(text) or (
+            settings.DEFAULT_LANGUAGES[0] if settings.DEFAULT_LANGUAGES else None
+        )
+        return detected_language
 
     @apply_settings
-    def search_dates(self, text, languages=None, settings=None):
+    def search_dates(self, text, languages=None, settings=None, detect_languages_function=None):
         """
         Find all substrings of the given string which represent date and/or time and parse them.
 
         :param text:
             A string in a natural language which may contain date and/or time expressions.
         :type text: str
+
         :param languages:
             A list of two letters language codes.e.g. ['en', 'es']. If languages are given, it will not attempt
             to detect the language.
         :type languages: list
+
         :param settings:
                Configure customized behavior using settings defined in :mod:`dateparser.conf.Settings`.
         :type settings: dict
 
+        :param detect_languages_function:
+               A function for language detection that takes as input a `text` and a `confidence_threshold`,
+               returns a list of detected language codes.
+        :type detect_languages_function: function
+
         :return: a dict mapping keys to two letter language code and a list of tuples of pairs:
                 substring representing date expressions and corresponding :mod:`datetime.datetime` object.
             For example:
@@ -215,7 +232,11 @@ def search_dates(self, text, languages=None, settings=None):
         :raises: ValueError - Unknown Language
         """
 
-        language_shortname = self.detect_language(text=text, languages=languages)
+        check_settings(settings)
+
+        language_shortname = self.detect_language(
+            text=text, languages=languages, settings=settings, detect_languages_function=detect_languages_function
+        )
         if not language_shortname:
             return {'Language': None, 'Dates': None}
         return {'Language': language_shortname, 'Dates': self.search.search_parse(language_shortname, text,
diff --git a/dateparser/timezones.py b/dateparser/timezones.py
index f5a4699b5..bd7816635 100644
--- a/dateparser/timezones.py
+++ b/dateparser/timezones.py
@@ -370,7 +370,9 @@
              ('SCT', 14400),
              ('SDMT', -16800),
              ('SDT', -36000),
+             ('SEČ', 3600),
              ('SET', 3600),
+             ('SELČ', 7200),
              ('SGT', 28800),
              ('SHEST', 21600),
              ('SHET', 18000),
@@ -414,6 +416,7 @@
              ('UYT', -10800),
              ('UZST', 21600),
              ('UZT', 18000),
+             ('VEČ', 7200),
              ('VET', -16200),
              ('VLAST', 39600),
              ('VLAT', 36000),
@@ -458,6 +461,7 @@
              ('YST', -32400),
              ('YWT', -28800),
              ('zzz', 0),
-             ('Z', 0)]
+             ('Z', 0),
+             ('ZEČ', 0)]
     },
 ]
diff --git a/dateparser_cli/__init__.py b/dateparser_cli/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/dateparser_cli/cli.py b/dateparser_cli/cli.py
new file mode 100644
index 000000000..ec96d1482
--- /dev/null
+++ b/dateparser_cli/cli.py
@@ -0,0 +1,34 @@
+import argparse
+import logging
+
+from .fasttext_manager import fasttext_downloader
+from .utils import clear_cache
+
+
+def entrance():
+    dateparser_argparse = argparse.ArgumentParser(
+        description='dateparser download manager.'
+    )
+    dateparser_argparse.add_argument(
+        '--fasttext',
+        type=str,
+        help='To download a fasttext language detection models. Supported models are "small" and "large"'
+    )
+    dateparser_argparse.add_argument(
+        '--clear',
+        '--clear-cache',
+        help='To clear all cached models',
+        action='store_true'
+    )
+
+    args = dateparser_argparse.parse_args()
+
+    if args.clear:
+        clear_cache()
+        logging.info("dateparser-download: All cache deleted")
+
+    if args.fasttext:
+        fasttext_downloader(args.fasttext)
+
+    if not (args.clear or args.fasttext):
+        dateparser_argparse.error("dateparser-download: You need to specify the command (i.e.: --fasttext or --clear)")
diff --git a/dateparser_cli/exceptions.py b/dateparser_cli/exceptions.py
new file mode 100644
index 000000000..8bf38679b
--- /dev/null
+++ b/dateparser_cli/exceptions.py
@@ -0,0 +1,2 @@
+class FastTextModelNotFoundException(Exception):
+    pass
diff --git a/dateparser_cli/fasttext_manager.py b/dateparser_cli/fasttext_manager.py
new file mode 100644
index 000000000..e7535bba5
--- /dev/null
+++ b/dateparser_cli/fasttext_manager.py
@@ -0,0 +1,32 @@
+from pathlib import Path
+import urllib.request
+import os
+import logging
+
+from .exceptions import FastTextModelNotFoundException
+from .utils import dateparser_model_home, create_data_model_home
+
+
+def fasttext_downloader(model_name):
+    create_data_model_home()
+    models = {
+        "small": "https://dl.fbaipublicfiles.com/fasttext/supervised-models/lid.176.ftz",
+        "large": "https://dl.fbaipublicfiles.com/fasttext/supervised-models/lid.176.bin"
+    }
+    if model_name not in models:
+        message = "dateparser-download: Couldn't find a model called \"{}\". Supported models are: {}".format(
+            model_name, ", ".join(models.keys())
+        )
+        raise FastTextModelNotFoundException(message)
+
+    models_directory_path = os.path.join(dateparser_model_home, (model_name + ".bin"))
+
+    if not Path(models_directory_path).is_file():
+        model_url = models[model_name]
+        logging.info("dateparser-download: Downloading model \"{}\" from \"{}\"...".format(model_name, model_url))
+        try:
+            urllib.request.urlretrieve(model_url, models_directory_path)
+        except urllib.error.HTTPError as e:
+            raise Exception("dateparser-download: Fasttext model cannot be downloaded due to HTTP error") from e
+    else:
+        logging.info("dateparser-download: The model \"{}\" is already downloaded".format(model_name))
diff --git a/dateparser_cli/utils.py b/dateparser_cli/utils.py
new file mode 100644
index 000000000..fb57c78f3
--- /dev/null
+++ b/dateparser_cli/utils.py
@@ -0,0 +1,33 @@
+import sys
+import os
+from pathlib import Path
+
+DEFAULT_DIR_NAME = 'dateparser_models'
+DEFAULT_UNIX_CACHE_DIR = '~/.cache'
+
+if sys.version_info < (3, 6):  # python 3.5 compatibility
+    DEFAULT_WINDOWS_CACHE_DIR = os.path.join(str(Path.home()), "AppData", "Roaming")
+else:
+    DEFAULT_WINDOWS_CACHE_DIR = os.path.join(Path.home(), "AppData", "Roaming")
+
+
+if sys.platform.startswith('win'):
+    # For Windows:
+    _cache_dir = DEFAULT_WINDOWS_CACHE_DIR
+else:
+    # UNIX & OS X:
+    _cache_dir = DEFAULT_UNIX_CACHE_DIR
+
+dateparser_model_home = os.path.expanduser(
+    os.path.join(_cache_dir, DEFAULT_DIR_NAME)
+)
+
+
+def create_data_model_home():
+    if not os.path.isdir(dateparser_model_home):
+        os.makedirs(dateparser_model_home, exist_ok=True)
+
+
+def clear_cache(*args):
+    for path in Path(dateparser_model_home).rglob('*.*'):
+        os.remove(path)
diff --git a/dateparser_data/settings.py b/dateparser_data/settings.py
index 8b1fdb16e..c38d10061 100644
--- a/dateparser_data/settings.py
+++ b/dateparser_data/settings.py
@@ -25,6 +25,10 @@
     # Language detection
     'SKIP_TOKENS': ['t'],
     'NORMALIZE': True,
+    'DEFAULT_LANGUAGES': [],
+
+    # Optional language detection
+    'LANGUAGE_DETECTION_CONFIDENCE_THRESHOLD': 0.5,
 
     # Other settings
     'RETURN_TIME_AS_PERIOD': False,
diff --git a/dateparser_scripts/get_cldr_data.py b/dateparser_scripts/get_cldr_data.py
index fb2e186ba..42d8d7781 100644
--- a/dateparser_scripts/get_cldr_data.py
+++ b/dateparser_scripts/get_cldr_data.py
@@ -32,9 +32,9 @@
 
 
 def _filter_relative_string(relative_string):
-    return (isinstance(relative_string, str) and
-            RELATIVE_PATTERN.search(relative_string) and
-            not PARENTHESIS_PATTERN.search(relative_string))
+    return (isinstance(relative_string, str)
+            and RELATIVE_PATTERN.search(relative_string)
+            and not PARENTHESIS_PATTERN.search(relative_string))
 
 
 def _filter_month_name(month_name):
@@ -70,11 +70,12 @@ def _retrieve_locale_data(locale):
 
     try:
         date_format_string = gregorian_dict["dateFormats"]["short"].upper()
-    except:
+    except AttributeError:
         date_format_string = gregorian_dict["dateFormats"]["short"]["_value"].upper()
 
     json_dict["date_order"] = DATE_ORDER_PATTERN.sub(
-            r'\1\2\3', DATE_ORDER_PATTERN.search(date_format_string).group())
+        r'\1\2\3', DATE_ORDER_PATTERN.search(date_format_string).group()
+    )
 
     json_dict["january"] = list(filter(_filter_month_name,
                                        [gregorian_dict["months"][key1][key2]["1"]
diff --git a/dateparser_scripts/order_languages.py b/dateparser_scripts/order_languages.py
index c10545d0b..ca055047d 100644
--- a/dateparser_scripts/order_languages.py
+++ b/dateparser_scripts/order_languages.py
@@ -56,12 +56,12 @@ def _get_language_order(language_locale_dict):
                     language_population_dict[language] += language_population
                 else:
                     language_population_dict[language] = language_population
-        except:
+        except Exception:
             pass
 
     language_order_with_duplicates = (
-        most_common_locales +
-        sorted(
+        most_common_locales
+        + sorted(
             language_population_dict.keys(),
             key=lambda x: (language_population_dict[x], x), reverse=True
         )
@@ -92,6 +92,16 @@ def _get_language_order(language_locale_dict):
     return language_order
 
 
+def generate_language_map(language_order):
+    data = {}
+    for lang in sorted(language_order):
+        if '-' not in lang:
+            data[lang] = [lang]
+        else:
+            data[lang.split('-')[0]].append(lang)
+    return data
+
+
 def main():
     get_raw_data()
     language_locale_dict = _get_language_locale_dict()
@@ -102,7 +112,8 @@ def main():
     if not os.path.isdir(parent_directory):
         os.mkdir(parent_directory)
     language_order_string = 'language_order = ' + json.dumps(
-            language_order, separators=(',', ': '), indent=4)
+        language_order, separators=(',', ': '), indent=4
+    )
 
     complete_language_locale_dict = OrderedDict()
     for key in language_order:
@@ -112,8 +123,14 @@ def main():
             complete_language_locale_dict[key] = []
 
     language_locale_dict_string = 'language_locale_dict = ' + json.dumps(
-            complete_language_locale_dict, separators=(',', ': '), indent=4)
-    languages_info_string = language_order_string + '\n\n' + language_locale_dict_string + '\n'
+        complete_language_locale_dict, separators=(',', ': '), indent=4
+    )
+    language_map_data = generate_language_map(language_order)
+    language_map_data_string = 'language_map = ' + json.dumps(
+        language_map_data, separators=(',', ': '), indent=4
+    )
+
+    languages_info_string = language_order_string + '\n\n' + language_map_data_string + '\n\n' + language_locale_dict_string + '\n'
     with open(filename, 'w') as f:
         f.write(languages_info_string)
 
diff --git a/dateparser_scripts/utils.py b/dateparser_scripts/utils.py
index 05f953be0..d43843892 100644
--- a/dateparser_scripts/utils.py
+++ b/dateparser_scripts/utils.py
@@ -10,18 +10,18 @@ def get_raw_data():
     raw_data_directory = "../raw_data"
 
     cldr_data = {
-       'dates_full': {
-           'url': 'https://github.com/unicode-cldr/cldr-dates-full.git',
-           'dir': "{}/cldr_dates_full/".format(raw_data_directory)
-       },
-       'core': {
-           'url': 'https://github.com/unicode-cldr/cldr-core.git',
-           'dir': "{}/cldr_core/".format(raw_data_directory)
-       },
-       'rbnf': {
-           'url': 'https://github.com/unicode-cldr/cldr-rbnf.git',
-           'dir': "{}/cldr_rbnf/".format(raw_data_directory)
-       },
+        'dates_full': {
+            'url': 'https://github.com/unicode-cldr/cldr-dates-full.git',
+            'dir': "{}/cldr_dates_full/".format(raw_data_directory)
+        },
+        'core': {
+            'url': 'https://github.com/unicode-cldr/cldr-core.git',
+            'dir': "{}/cldr_core/".format(raw_data_directory)
+        },
+        'rbnf': {
+            'url': 'https://github.com/unicode-cldr/cldr-rbnf.git',
+            'dir': "{}/cldr_rbnf/".format(raw_data_directory)
+        },
     }
 
     if os.path.isdir(raw_data_directory):
@@ -43,7 +43,7 @@ def get_dict_difference(parent_dict, child_dict):
         if not parent_value:
             child_specific_value = child_value
         elif isinstance(child_value, list):
-            child_specific_value = sorted(set(child_value)-set(parent_value))
+            child_specific_value = sorted(set(child_value) - set(parent_value))
         elif isinstance(child_value, dict):
             child_specific_value = get_dict_difference(parent_value, child_value)
         elif child_value != parent_value:
diff --git a/docs/custom_language_detection.rst b/docs/custom_language_detection.rst
new file mode 100644
index 000000000..f05c0176b
--- /dev/null
+++ b/docs/custom_language_detection.rst
@@ -0,0 +1,96 @@
+=========================
+Custom language detection
+=========================
+
+`dateparser` allows to customize the language detection behavior by using the ``detect_languages_function`` parameter. 
+It currently supports two language detection libraries out of the box: `fastText <https://github.com/facebookresearch/fastText>`_ 
+and `langdetect <https://github.com/Mimino666/langdetect>`_, and allows you to implement your own custom language detection.
+
+.. warning::
+
+    For short strings the language detection could fail, so it's highly recommended to use ``detect_languages_function``
+    along with ``DEFAULT_LANGUAGES``.
+
+Built-in implementations
+========================
+
+fastText
+~~~~~~~~
+Language detection with fastText.
+
+Import the fastText wrapper and pass it as ``detect_languages_function``
+parameter. Example::
+
+    >>> from dateparser.custom_language_detection.fasttext import detect_languages
+    >>> dateparser.parse('12/12/12', detect_languages_function=detect_languages)
+
+The fastText integration currently supports the large and the small models.
+Find more information about `fasttext <https://fasttext.cc/blog/2017/10/02/blog-post.html>`_ models.
+You can download your model of choice using ``dateparser-download``.
+
+Downloading small model::
+
+    >>> dateparser-download --fasttext small
+
+Downloading large model::
+
+    >>> dateparser-download --fasttext large
+
+Deleting all cached models::
+
+    >>> dateparser-download --clear_cache
+
+.. note::
+
+    If no model has been downloaded, the fastText wrapper downloads and uses 
+    the small model by default.
+
+langdetect
+~~~~~~~~~~
+Language detection with langdetect.
+
+Import the langdetect wrapper and pass it as ``detect_languages_function``
+parameter. Example::
+
+    >>> from dateparser.custom_language_detection.langdetect import detect_languages
+    >>> dateparser.parse('12/12/12', detect_languages_function=detect_languages)
+
+
+.. note::
+
+    From some tests we did, we recommend to use ``fastText`` for faster and more accurate results.
+
+Custom implementation
+=====================
+
+``dateparser`` allows the integration of any library to detect languages by
+wrapping that library in a function that accepts 2 parameters, ``text`` and
+``confidence_threshold``, and returns a list of the detected language codes in
+ISO 639 standards.
+
+
+Wrapper for boilerplate for implementing custom language detections::
+
+    def detect_languages(text, confidence_threshold):
+        """
+        Takes 2 parameters, `text` and `confidence_threshold`, and returns
+        a list of `languages codes`.
+        
+        * `text` is the input string whose language needs to be detected.
+        
+        * `confidence_threshold` is a number between 0 and 1 that indicates the 
+        minimum confidence required for language matches.
+        
+        For language detection libraries that, for each language, indicate how 
+        confident they are that the language matches the input text, you should 
+        filter out languages with a confidence lower than this value (adjusted,
+        if needed, to the confidence range of the target library).
+        
+        This value comes from the dateparser setting 
+        `LANGUAGE_DETECTION_CONFIDENCE_THRESHOLD`.
+        
+        The result must be a list of languages codes (strings).
+        """
+        # here you can apply your own logic
+        return language_codes
+
diff --git a/docs/index.rst b/docs/index.rst
index 1e1c6ec51..0159b6adc 100644
--- a/docs/index.rst
+++ b/docs/index.rst
@@ -49,6 +49,7 @@ Contents:
    installation
    usage
    settings
+   custom_language_detection
    supported_locales
    contributing
    modules
diff --git a/docs/settings.rst b/docs/settings.rst
index 1ae658781..337b8e713 100644
--- a/docs/settings.rst
+++ b/docs/settings.rst
@@ -141,6 +141,26 @@ Language Detection
     datetime.datetime(2015, 12, 4, 0, 0)
 
 
+Default Languages
++++++++++++++++++
+
+``DEFAULT_LANGUAGES``: It is a ``list`` of language codes in ISO 639 that will be used as default
+languages for parsing when language detection fails. eg. ["en", "fr"]:
+
+    >>> from dateparser import parse
+    >>> parse('3 de marzo de 2020', settings={'DEFAULT_LANGUAGES': ["es"]})
+
+.. note:: When using this setting, these languages will be tried after trying with the detected languages with no success. It is especially useful when using the ``detect_languages_function`.
+
+Optional language detection
++++++++++++++++++++++++++++
+
+``LANGUAGE_DETECTION_CONFIDENCE_THRESHOLD``: defaults to ``0.5``. It is a ``float`` of minimum required confidence for the custom language detection:
+
+    >>> from dateparser import parse
+    >>> parse('3 de marzo de 2020', settings={'LANGUAGE_DETECTION_CONFIDENCE_THRESHOLD': 0.5}, detect_languages_function=detect_languages)
+
+
 Other settings
 ++++++++++++++
 
@@ -161,6 +181,9 @@ The following parsers exist:
     followed by additional digits or a period (``.``), those first 10 digits
     are interpreted as `Unix time <https://en.wikipedia.org/wiki/Unix_time>`_.
 
+-    ``'negative-timestamp'``: ``'timestamp'`` for negative timestamps. For
+    example, parses ``-186454800000`` as ``1964-02-03T23:00:00``.
+
 -   ``'relative-time'``: Parses dates and times expressed in relation to the
     current date and time (e.g. “1 day ago”, “in 2 weeks”).
 
diff --git a/flake8 b/flake8
deleted file mode 100644
index 7da1f9608..000000000
--- a/flake8
+++ /dev/null
@@ -1,2 +0,0 @@
-[flake8]
-max-line-length = 100
diff --git a/pytest.ini b/pytest.ini
index 5cfe06991..1a75689bf 100644
--- a/pytest.ini
+++ b/pytest.ini
@@ -2,22 +2,3 @@
 addopts =
     --doctest-modules
     --assert=plain
-flake8-max-line-length = 119
-flake8-ignore =
-    # This rule goes against the PEP 8 recommended style and it's incompatible
-    # with W504
-    W503
-
-    # Exclude automatically generated files
-    # E501: Line too long
-    dateparser/data/date_translation_data/* E501
-
-    # Exclude files that are meant to provide top-level imports
-    # F401: Module imported but unused
-    dateparser/data/__init__.py F401
-    dateparser/languages/__init__.py F401
-
-    # Issues pending a review:
-    dateparser/freshness_date_parser.py E722
-    dateparser/parser.py E722
-    dateparser/docs/conf.py E402
diff --git a/setup.cfg b/setup.cfg
index d6e10b155..cd6d2dfce 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -2,4 +2,22 @@
 universal = 1
 
 [flake8]
-max-line-length = 100
+max-line-length = 119
+ignore =
+    # This rule goes against the PEP 8 recommended style and it's incompatible
+    # with W504
+    W503
+
+    # Exclude automatically generated files
+    # E501: Line too long
+    dateparser/data/date_translation_data/* E501
+
+    # Exclude files that are meant to provide top-level imports
+    # F401: Module imported but unused
+    dateparser/data/__init__.py F401
+    dateparser/languages/__init__.py F401
+
+    # Issues pending a review:
+    dateparser/freshness_date_parser.py E722
+    dateparser/parser.py E722
+    dateparser/docs/conf.py E402
diff --git a/setup.py b/setup.py
index 422a8f833..5da6268e2 100644
--- a/setup.py
+++ b/setup.py
@@ -1,10 +1,12 @@
 import re
 from setuptools import setup, find_packages
 
-__version__ = re.search(r"__version__.*\s*=\s*[']([^']+)[']", open('dateparser/__init__.py').read()).group(1)
+__version__ = re.search(r"__version__.*\s*=\s*[']([^']+)[']",
+                        open('dateparser/__init__.py').read()).group(1)
 
-introduction = re.sub(r':members:.+|..\sautomodule::.+|:class:|:func:|:ref:', '', open('docs/introduction.rst').read())
-history = re.sub(r':mod:|:class:|:func:', '', open('HISTORY.rst').read())
+introduction = re.sub(r':members:.+|..\sautomodule::.+|:class:|:func:|:ref:',
+                      '', open('docs/introduction.rst', encoding='utf-8').read())
+history = re.sub(r':mod:|:class:|:func:', '', open('HISTORY.rst', encoding='utf-8').read())
 
 test_requirements = open('tests/requirements.txt').read().splitlines()
 
@@ -25,12 +27,17 @@
         'python-dateutil',
         'pytz',
         # https://bitbucket.org/mrabarnett/mrab-regex/issues/314/import-error-no-module-named
-        'regex !=2019.02.19',
+        'regex !=2019.02.19,!=2021.8.27,<2022.3.15',
         'tzlocal',
     ],
+    entry_points={
+        'console_scripts': ['dateparser-download = dateparser_cli.cli:entrance'],
+    },
     extras_require={
         'calendars:python_version<"3.6"': ['convertdate'],
         'calendars:python_version>="3.6"': ['hijri-converter', 'convertdate'],
+        'fasttext': ['fasttext'],
+        'langdetect': ['langdetect'],
     },
     license="BSD",
     zip_safe=False,
diff --git a/tests/test_date.py b/tests/test_date.py
index c1d87fa64..98958ee91 100644
--- a/tests/test_date.py
+++ b/tests/test_date.py
@@ -655,10 +655,13 @@ def test_error_raised_for_invalid_use_given_order_argument(self, use_given_order
             TypeError, ["use_given_order argument must be a boolean (%r given)"
                         % type(use_given_order)])
 
-    def test_error_is_raised_when_use_given_order_is_True_and_locales_is_None(self):
+    def test_error_is_raised_when_use_given_order_is_True_and_locales_and_languages_is_None(self):
         self.when_parser_is_initialized(use_given_order=True)
         self.then_error_was_raised(
-            ValueError, ["locales must be given if use_given_order is True"])
+            ValueError, ["locales or languages must be given if use_given_order is True"])
+
+    def test_no_error_for_order_with_languages_without_locales(self):
+        self.when_parser_is_initialized(languages=['en', 'fr'], use_given_order=True)
 
     def when_parser_is_initialized(self, languages=None, locales=None, region=None,
                                    try_previous_locales=True, use_given_order=False):
@@ -787,6 +790,34 @@ def test_timestamp_in_microseconds(self):
             datetime.fromtimestamp(1570308760).replace(microsecond=263111)
         )
 
+    @parameterized.expand([
+        param(
+            input_timestamp='-1570308760',
+            negative=True,
+            result=datetime.fromtimestamp(-1570308760)
+        ),
+        param(
+            input_timestamp='-1570308760',
+            negative=False,
+            result=None
+        ),
+        param(
+            input_timestamp='1570308760',
+            negative=True,
+            result=None
+        ),
+        param(
+            input_timestamp='1570308760',
+            negative=False,
+            result=datetime.fromtimestamp(1570308760)
+        )
+    ])
+    def test_timestamp_with_negative(self, input_timestamp, negative, result):
+        self.assertEqual(
+            date.get_date_from_timestamp(input_timestamp, None, negative=negative),
+            result
+        )
+
     @parameterized.expand([
         param(date_string='15703087602631'),
         param(date_string='157030876026xx'),
diff --git a/tests/test_date_parser.py b/tests/test_date_parser.py
index 342ea2f30..b9d7bf076 100644
--- a/tests/test_date_parser.py
+++ b/tests/test_date_parser.py
@@ -91,6 +91,7 @@ def setUp(self):
         param('13 авг. 2005 19:13', datetime(2005, 8, 13, 19, 13)),
         param('13 авг. 2005г. 19:13', datetime(2005, 8, 13, 19, 13)),
         param('13 авг. 2005 г. 19:13', datetime(2005, 8, 13, 19, 13)),
+        param('21 сентября 2021г., вторник', datetime(2021, 9, 21, 0, 0)),
         # Turkish dates
         param('11 Ağustos, 2014', datetime(2014, 8, 11)),
         param('08.Haziran.2014, 11:07', datetime(2014, 6, 8, 11, 7)),  # forum.andronova.net
@@ -642,6 +643,34 @@ def test_parse_timestamp(self, date_string, expected):
         self.given_parser(settings={'TO_TIMEZONE': 'UTC'})
         self.when_date_is_parsed(date_string)
         self.then_date_obj_exactly_is(expected)
+        self.then_period_is('day')
+
+    @parameterized.expand([
+        param('-1484823450', expected=datetime(1922, 12, 13, 13, 2, 30)),
+        param('-1436745600000', expected=datetime(1924, 6, 22, 0, 0)),
+        param('-1015673450000001', expected=datetime(1937, 10, 25, 12, 29, 10, 1))
+    ])
+    def test_parse_negative_timestamp(self, date_string, expected):
+        self.given_local_tz_offset(0)
+        self.given_parser(settings={'TO_TIMEZONE': 'UTC', 'PARSERS': ['negative-timestamp']})
+        self.when_date_is_parsed(date_string)
+        self.then_date_obj_exactly_is(expected)
+        self.then_period_is('day')
+
+    @parameterized.expand([
+        # Epoch timestamps.
+        param('1484823450', expected=datetime(2017, 1, 19, 10, 57, 30)),
+        param('1436745600000', expected=datetime(2015, 7, 13, 0, 0)),
+        param('1015673450', expected=datetime(2002, 3, 9, 11, 30, 50)),
+        param('2016-09-23T02:54:32.845Z', expected=datetime(2016, 9, 23, 2, 54, 32, 845000,
+              tzinfo=StaticTzInfo('Z', timedelta(0))))
+    ])
+    def test_parse_timestamp_with_time_as_period(self, date_string, expected):
+        self.given_local_tz_offset(0)
+        self.given_parser(settings={'TO_TIMEZONE': 'UTC', 'RETURN_TIME_AS_PERIOD': True})
+        self.when_date_is_parsed(date_string)
+        self.then_date_obj_exactly_is(expected)
+        self.then_period_is('time')
 
     @parameterized.expand([
         param('10 December', expected=datetime(2015, 12, 10), period='day'),
diff --git a/tests/test_language_detect.py b/tests/test_language_detect.py
new file mode 100644
index 000000000..a9857cf04
--- /dev/null
+++ b/tests/test_language_detect.py
@@ -0,0 +1,88 @@
+from datetime import datetime
+from unittest.mock import Mock
+import unittest
+
+from parameterized import parameterized, param
+
+from dateparser.custom_language_detection.fasttext import detect_languages as fast_text_detect_languages
+from dateparser.custom_language_detection.langdetect import detect_languages as lang_detect_detect_languages
+from dateparser import parse
+from dateparser.date import DateDataParser
+from dateparser.search import search_dates
+
+detect_languages = Mock()
+detect_languages.return_value = ["en"]
+
+
+class CustomLangDetectParserTest(unittest.TestCase):
+    def check_is_returned_list(self):
+        self.assertEqual(type(self.result), list)
+
+    @parameterized.expand([
+        param(dt_string="14 June 2020", confidence_threshold=0.0),
+        param(dt_string="26 July 2021", confidence_threshold=0.0)
+    ])
+    def test_custom_language_detect_fast_text(self, dt_string, confidence_threshold):
+        self.result = fast_text_detect_languages(dt_string, confidence_threshold)
+        self.check_is_returned_list()
+
+    @parameterized.expand([
+        param(dt_string="14 June 2020", confidence_threshold=0.0),
+    ])
+    def test_custom_language_detect_lang_detect(self, dt_string, confidence_threshold):
+        self.result = lang_detect_detect_languages(dt_string, confidence_threshold)
+        self.check_is_returned_list()
+
+    @parameterized.expand([
+        param(dt_string="10-10-2021", confidence_threshold=0.5),
+    ])
+    def test_lang_detect_doesnt_raise_error(self, dt_string, confidence_threshold):
+        result = lang_detect_detect_languages(dt_string, confidence_threshold)
+        assert result == []
+
+    # Mock test for parse, search_dates and DateDataParser
+
+    detect_languages = Mock()
+    detect_languages.return_value = ["en"]
+
+    # parse
+
+    def when_date_is_parsed_using_parse(self, dt_string):
+        self.result = parse(dt_string, detect_languages_function=detect_languages)
+
+    def then_date_obj_exactly_is(self, expected_date_obj):
+        self.assertEqual(expected_date_obj, self.result)
+
+    @parameterized.expand([
+        param("Tuesday Jul 22, 2014", datetime(2014, 7, 22, 0, 0, 0)),
+    ])
+    def test_custom_language_detect_mock_parse(self, dt_string, expected_date_obj):
+        self.when_date_is_parsed_using_parse(dt_string)
+        self.then_date_obj_exactly_is(expected_date_obj)
+
+    # DateDataParser
+
+    def when_date_is_parsed_using_with_datedataparser(self, dt_string):
+        ddp = DateDataParser(detect_languages_function=detect_languages)
+        self.result = ddp.get_date_data(dt_string)["date_obj"]
+
+    @parameterized.expand([
+        param("Tuesday Jul 22, 2014", datetime(2014, 7, 22, 0, 0, 0)),
+    ])
+    def test_custom_language_detect_mock_datedataparser(self, dt_string, expected_date_obj):
+        self.when_date_is_parsed_using_with_datedataparser(dt_string)
+        self.then_date_obj_exactly_is(expected_date_obj)
+
+    # search_date
+
+    def when_date_is_parsed_using_with_search_dates(self, dt_string):
+        self.result = search_dates(dt_string, detect_languages_function=detect_languages)
+
+    @parameterized.expand([
+        param('January 3, 2017 - February 1st',
+              [('January 3, 2017', datetime(2017, 1, 3, 0, 0)),
+               ('February 1st', datetime(2017, 2, 1, 0, 0))]),
+    ])
+    def test_custom_language_detect_mock_search_dates(self, dt_string, expected_date_obj):
+        self.when_date_is_parsed_using_with_search_dates(dt_string)
+        self.then_date_obj_exactly_is(expected_date_obj)
diff --git a/tests/test_languages.py b/tests/test_languages.py
index 536d6cafc..a9d292d8f 100644
--- a/tests/test_languages.py
+++ b/tests/test_languages.py
@@ -8,6 +8,11 @@
 from dateparser.conf import apply_settings
 from dateparser.search.detection import AutoDetectLanguage, ExactLanguages
 from dateparser.utils import normalize_unicode
+from dateparser import parse
+from dateparser.date import DateDataParser
+from dateparser.search import search_dates
+
+from datetime import datetime
 
 from tests import BaseTestCase
 
@@ -2168,3 +2173,49 @@ def test_validate_extra_keys_when_invalid(self, lang_id, lang_info, log_msg):
         result = self.validator._validate_extra_keys(lang_id, lang_info)
         self.assertEqual(log_msg, self.get_log_str())
         self.assertFalse(result)
+
+    @parameterized.expand([
+        param(date_string='3 de marzo 2019', languages=["en"], settings={
+            "DEFAULT_LANGUAGES": ["es"]
+        }, expected=datetime(2019, 3, 3, 0, 0)),
+    ])
+    def test_parse_settings_default_languages(self, date_string, languages, settings, expected):
+        result = parse(date_string, languages=languages, settings=settings)
+        assert result == expected
+
+    @parameterized.expand([
+        param(date_string='3 de marzo 2019', languages=["en"], settings={
+            "DEFAULT_LANGUAGES": ["es"]
+        }, expected=datetime(2019, 3, 3, 0, 0)),
+    ])
+    def test_date_data_parser_settings_default_languages(self, date_string, languages, settings, expected):
+        ddp = DateDataParser(languages=languages, settings=settings)
+        result = ddp.get_date_data(date_string)
+        assert result.date_obj == expected
+
+    @parameterized.expand([
+        param(date_string='3 de marzo 2019', settings={
+            "DEFAULT_LANGUAGES": ["es"]
+        }, expected=[('3 de marzo 2019', datetime(2019, 3, 3, 0, 0))]),
+    ])
+    def test_search_dates_settings_default_languages(self, date_string, settings, expected):
+        result = search_dates(date_string, settings=settings)
+        assert result == expected
+
+    @parameterized.expand([
+        param(date_string='RANDOM_WORD ', settings={
+            "DEFAULT_LANGUAGES": ["en"]
+        })
+    ])
+    def test_parse_settings_default_languages_no_language_detect(self, date_string, settings):
+        result = parse(date_string, settings=settings)
+        assert result is None
+
+    @parameterized.expand([
+        param(date_string='29 mai 2021', languages=["fr"], expected=datetime(2021, 5, 29, 0, 0), settings={
+            "DEFAULT_LANGUAGES": ["en", "es"]
+        }),
+    ])
+    def test_parse_settings_default_languages_with_detected_language(self, date_string, languages, expected, settings):
+        result = parse(date_string, languages=languages, settings=settings)
+        assert result == expected
diff --git a/tests/test_search.py b/tests/test_search.py
index 067601569..1ea7b7bff 100644
--- a/tests/test_search.py
+++ b/tests/test_search.py
@@ -276,6 +276,11 @@ def test_search_date_string(self, shortname, datetime_string):
         param('en', 'in a minute',
               [('in a minute', datetime.datetime(2000, 1, 1, 0, 1))],
               settings={'RELATIVE_BASE': datetime.datetime(2000, 1, 1)}),
+
+        param('en', 'last decade',
+              [('last decade', datetime.datetime(1990, 1, 1, 0, 0))],
+              settings={'RELATIVE_BASE': datetime.datetime(2000, 1, 1)}),
+
         param('en', 'July 13th.\r\n July 14th',
               [('July 13th', datetime.datetime(2000, 7, 13, 0, 0)),
                ('July 14th', datetime.datetime(2000, 7, 14, 0, 0))],
diff --git a/tests/test_settings.py b/tests/test_settings.py
index 44c355c9c..171dd6a63 100644
--- a/tests/test_settings.py
+++ b/tests/test_settings.py
@@ -173,6 +173,8 @@ def test_check_settings_wrong_setting_name(self):
         param('NORMALIZE', 'true', '', True),
         param('FUZZY', 'true', '', False),
         param('PREFER_LOCALE_DATE_ORDER', 'false', '', True),
+        param('DEFAULT_LANGUAGES', 'en', '', ['en']),
+        param('LANGUAGE_DETECTION_CONFIDENCE_THRESHOLD', '1', '', 0.5),
     ])
     def test_check_settings(self, setting, wrong_type, wrong_value, valid_value):
         with self.assertRaisesRegex(
@@ -212,6 +214,22 @@ def test_check_settings_extra_check_parsers(self):
         ):
             DateDataParser(settings={'PARSERS': ['absolute-time', 'timestamp', 'absolute-time']})
 
+    def test_check_settings_extra_check_confidence_threshold(self):
+        with self.assertRaisesRegex(
+            SettingValidationError,
+            r'1.1 is not a valid value for '
+            r'LANGUAGE_DETECTION_CONFIDENCE_THRESHOLD. It can take values '
+            r'between 0 and 1'
+        ):
+            DateDataParser(settings={'LANGUAGE_DETECTION_CONFIDENCE_THRESHOLD': 1.1})
+
+    def test_check_settings_extra_check_default_languages(self):
+        with self.assertRaisesRegex(
+            SettingValidationError,
+            "Found invalid languages in the 'DEFAULT_LANGUAGES' setting: 'abcd'"
+        ):
+            DateDataParser(settings={'DEFAULT_LANGUAGES': ["abcd"]})
+
 
 @pytest.mark.parametrize(
     "date_string,expected_result", [
@@ -227,3 +245,18 @@ def test_no_spaces_strict_parsing(date_string, expected_result):
 
     parser = DateDataParser(settings={'PARSERS': ['no-spaces-time'], 'STRICT_PARSING': True})
     assert parser.get_date_data(date_string)['date_obj'] is None
+
+
+def detect_languages(text, confidence_threshold):
+    if confidence_threshold > 0.5:
+        return ['en']
+    else:
+        return ['fr']
+
+
+def test_confidence_threshold_setting_is_applied():
+    ddp = DateDataParser(detect_languages_function=detect_languages, settings={'LANGUAGE_DETECTION_CONFIDENCE_THRESHOLD': 0.6})
+    assert ddp.get_date_data('21/06/2020').locale == 'en'
+
+    ddp2 = DateDataParser(detect_languages_function=detect_languages, settings={'LANGUAGE_DETECTION_CONFIDENCE_THRESHOLD': 0.4})
+    assert ddp2.get_date_data('21/06/2020').locale == 'fr'
diff --git a/tests/test_timezone_parser.py b/tests/test_timezone_parser.py
index ebad84904..c157a5606 100644
--- a/tests/test_timezone_parser.py
+++ b/tests/test_timezone_parser.py
@@ -52,6 +52,10 @@ def setUp(self):
         param('Fri Sep 23 2016 10:34:51 UTC+1245', 12.75),
         param('2019-07-17T12:30:00.000-03:30', -3.5),
         param('2019-07-17T12:30:00.000-02:30', -2.5),
+        param('16. srpna 2021 9:59:44 SELČ', 2),
+        param('16. srpna 2021 9:59:44 SEČ', 1),
+        param('16. srpna 2021 9:59:44 ZEČ', 0),
+        param('16. srpna 2021 9:59:44 VEČ', 2),
     ])
     def test_extracting_valid_offset(self, initial_string, expected_offset):
         self.given_string(initial_string)
diff --git a/tox.ini b/tox.ini
index f4a78208b..208d05c31 100644
--- a/tox.ini
+++ b/tox.ini
@@ -10,7 +10,7 @@ deps =
 deps =
     {[base]deps}
     tzlocal<3.0b1
-extras = calendars
+extras = calendars, fasttext, langdetect
 commands =
     pytest --cov=dateparser --cov-report=xml {posargs: tests}
 
@@ -21,12 +21,12 @@ deps =
 
 [testenv:flake8]
 basepython = python3
-extras = calendars
+extras = calendars, fasttext, langdetect
 deps =
     {[testenv]deps}
     pytest-flake8
 commands =
-    pytest --flake8 {posargs:docs dateparser tests}
+    pytest --flake8
 
 [testenv:docs]
 changedir = docs