Kaynağa Gözat

[core] Removing all the python2 libraries (#3319)

Ayush Goyal 2 yıl önce
ebeveyn
işleme
f55721a8b5
100 değiştirilmiş dosya ile 0 ekleme ve 4184 silme
  1. 0 131
      desktop/core/ext-py/Babel-2.9.1/AUTHORS
  2. 0 725
      desktop/core/ext-py/Babel-2.9.1/CHANGES
  3. 0 29
      desktop/core/ext-py/Babel-2.9.1/LICENSE
  4. 0 10
      desktop/core/ext-py/Babel-2.9.1/MANIFEST.in
  5. 0 48
      desktop/core/ext-py/Babel-2.9.1/Makefile
  6. 0 27
      desktop/core/ext-py/Babel-2.9.1/PKG-INFO
  7. 0 24
      desktop/core/ext-py/Babel-2.9.1/README.rst
  8. 0 24
      desktop/core/ext-py/Babel-2.9.1/babel/__init__.py
  9. 0 79
      desktop/core/ext-py/Babel-2.9.1/babel/_compat.py
  10. 0 1133
      desktop/core/ext-py/Babel-2.9.1/babel/core.py
  11. 0 1796
      desktop/core/ext-py/Babel-2.9.1/babel/dates.py
  12. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/global.dat
  13. 0 71
      desktop/core/ext-py/Babel-2.9.1/babel/languages.py
  14. 0 87
      desktop/core/ext-py/Babel-2.9.1/babel/lists.py
  15. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/af.dat
  16. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/af_NA.dat
  17. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/af_ZA.dat
  18. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/agq.dat
  19. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/agq_CM.dat
  20. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ak.dat
  21. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ak_GH.dat
  22. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/am.dat
  23. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/am_ET.dat
  24. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ar.dat
  25. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ar_001.dat
  26. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ar_AE.dat
  27. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ar_BH.dat
  28. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ar_DJ.dat
  29. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ar_DZ.dat
  30. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ar_EG.dat
  31. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ar_EH.dat
  32. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ar_ER.dat
  33. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ar_IL.dat
  34. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ar_IQ.dat
  35. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ar_JO.dat
  36. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ar_KM.dat
  37. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ar_KW.dat
  38. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ar_LB.dat
  39. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ar_LY.dat
  40. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ar_MA.dat
  41. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ar_MR.dat
  42. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ar_OM.dat
  43. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ar_PS.dat
  44. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ar_QA.dat
  45. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ar_SA.dat
  46. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ar_SD.dat
  47. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ar_SO.dat
  48. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ar_SS.dat
  49. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ar_SY.dat
  50. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ar_TD.dat
  51. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ar_TN.dat
  52. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ar_YE.dat
  53. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/as.dat
  54. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/as_IN.dat
  55. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/asa.dat
  56. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/asa_TZ.dat
  57. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ast.dat
  58. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ast_ES.dat
  59. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/az.dat
  60. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/az_Cyrl.dat
  61. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/az_Cyrl_AZ.dat
  62. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/az_Latn.dat
  63. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/az_Latn_AZ.dat
  64. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/bas.dat
  65. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/bas_CM.dat
  66. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/be.dat
  67. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/be_BY.dat
  68. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/bem.dat
  69. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/bem_ZM.dat
  70. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/bez.dat
  71. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/bez_TZ.dat
  72. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/bg.dat
  73. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/bg_BG.dat
  74. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/bm.dat
  75. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/bm_ML.dat
  76. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/bn.dat
  77. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/bn_BD.dat
  78. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/bn_IN.dat
  79. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/bo.dat
  80. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/bo_CN.dat
  81. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/bo_IN.dat
  82. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/br.dat
  83. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/br_FR.dat
  84. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/brx.dat
  85. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/brx_IN.dat
  86. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/bs.dat
  87. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/bs_Cyrl.dat
  88. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/bs_Cyrl_BA.dat
  89. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/bs_Latn.dat
  90. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/bs_Latn_BA.dat
  91. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ca.dat
  92. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ca_AD.dat
  93. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ca_ES.dat
  94. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ca_ES_VALENCIA.dat
  95. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ca_FR.dat
  96. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ca_IT.dat
  97. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ccp.dat
  98. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ccp_BD.dat
  99. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ccp_IN.dat
  100. BIN
      desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ce.dat

+ 0 - 131
desktop/core/ext-py/Babel-2.9.1/AUTHORS

@@ -1,131 +0,0 @@
-
-Babel is written and maintained by the Babel team and various contributors:
-
-- Aarni Koskela
-- Christopher Lenz
-- Armin Ronacher
-- Alex Morega
-- Lasse Schuirmann
-- Felix Schwarz
-- Pedro Algarvio
-- Jeroen Ruigrok van der Werven
-- Philip Jenvey
-- benselme
-- Isaac Jurado
-- Tobias Bieniek
-- Erick Wilder
-- Michael Birtwell
-- Jonas Borgström
-- Kevin Deldycke
-- Jon Dufresne
-- Ville Skyttä
-- Hugo
-- Heungsub Lee
-- Jakob Schnitzer
-- Sachin Paliwal
-- Alex Willmer
-- Daniel Neuhäuser
-- Miro Hrončok
-- Cédric Krier
-- Luke Plant
-- Jennifer Wang
-- Lukas Balaga
-- sudheesh001
-- Niklas Hambüchen
-- Changaco
-- Xavier Fernandez
-- KO. Mattsson
-- Sébastien Diemer
-- alexbodn@gmail.com
-- saurabhiiit
-- srisankethu
-- Erik Romijn
-- Lukas B
-- Ryan J Ollos
-- Arturas Moskvinas
-- Leonardo Pistone
-- Jun Omae
-- Hyunjun Kim
-- Alessio Bogon
-- Nikiforov Konstantin
-- Abdullah Javed Nesar
-- Brad Martin
-- Tyler Kennedy
-- CyanNani123
-- sebleblanc
-- He Chen
-- Steve (Gadget) Barnes
-- Romuald Brunet
-- Mario Frasca
-- BT-sschmid
-- Alberto Mardegan
-- mondeja
-- NotAFile
-- Julien Palard
-- Brian Cappello
-- Serban Constantin
-- Bryn Truscott
-- Chris
-- Charly C
-- PTrottier
-- xmo-odoo
-- StevenJ
-- Jungmo Ku
-- Simeon Visser
-- Narendra Vardi
-- Stefane Fermigier
-- Narayan Acharya
-- François Magimel
-- Wolfgang Doll
-- Roy Williams
-- Marc-André Dufresne
-- Abhishek Tiwari
-- David Baumgold
-- Alex Kuzmenko
-- Georg Schölly
-- ldwoolley
-- Rodrigo Ramírez Norambuena
-- Jakub Wilk
-- Roman Rader
-- Max Shenfield
-- Nicolas Grilly
-- Kenny Root
-- Adam Chainz
-- Sébastien Fievet
-- Anthony Sottile
-- Yuriy Shatrov
-- iamshubh22
-- Sven Anderson
-- Eoin Nugent
-- Roman Imankulov
-- David Stanek
-- Roy Wellington Ⅳ
-- Florian Schulze
-- Todd M. Guerra
-- Joseph Breihan
-- Craig Loftus
-- The Gitter Badger
-- Régis Behmo
-- Julen Ruiz Aizpuru
-- astaric
-- Felix Yan
-- Philip_Tzou
-- Jesús Espino
-- Jeremy Weinstein
-- James Page
-- masklinn
-- Sjoerd Langkemper
-- Matt Iversen
-- Alexander A. Dyshev
-- Dirkjan Ochtman
-- Nick Retallack
-- Thomas Waldmann
-- xen
-
-Babel was previously developed under the Copyright of Edgewall Software.  The
-following copyright notice holds true for releases before 2013: "Copyright (c)
-2007 - 2011 by Edgewall Software"
-
-In addition to the regular contributions Babel includes a fork of Lennart
-Regebro's tzlocal that originally was licensed under the CC0 license.  The
-original copyright of that project is "Copyright 2013 by Lennart Regebro".

+ 0 - 725
desktop/core/ext-py/Babel-2.9.1/CHANGES

@@ -1,725 +0,0 @@
-Babel Changelog
-===============
-
-Version 2.9.1
--------------
-
-Bugfixes
-~~~~~~~~
-
-* The internal locale-data loading functions now validate the name of the locale file to be loaded and only
-  allow files within Babel's data directory.  Thank you to Chris Lyne of Tenable, Inc. for discovering the issue!
-
-Version 2.9.0
--------------
-
-Upcoming version support changes
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-* This version, Babel 2.9, is the last version of Babel to support Python 2.7, Python 3.4, and Python 3.5.
-
-Improvements
-~~~~~~~~~~~~
-
-* CLDR: Use CLDR 37 – Aarni Koskela (#734)
-* Dates: Handle ZoneInfo objects in get_timezone_location, get_timezone_name - Alessio Bogon (#741)
-* Numbers: Add group_separator feature in number formatting - Abdullah Javed Nesar (#726)
-
-Bugfixes
-~~~~~~~~
-
-* Dates: Correct default Format().timedelta format to 'long' to mute deprecation warnings – Aarni Koskela
-* Import: Simplify iteration code in "import_cldr.py" – Felix Schwarz
-* Import: Stop using deprecated ElementTree methods "getchildren()" and "getiterator()" – Felix Schwarz
-* Messages: Fix unicode printing error on Python 2 without TTY. – Niklas Hambüchen
-* Messages: Introduce invariant that _invalid_pofile() takes unicode line. – Niklas Hambüchen
-* Tests: fix tests when using Python 3.9 – Felix Schwarz
-* Tests: Remove deprecated 'sudo: false' from Travis configuration – Jon Dufresne
-* Tests: Support Py.test 6.x – Aarni Koskela
-* Utilities: LazyProxy: Handle AttributeError in specified func – Nikiforov Konstantin (#724)
-* Utilities: Replace usage of parser.suite with ast.parse – Miro Hrončok
-
-Documentation
-~~~~~~~~~~~~~
-
-* Update parse_number comments – Brad Martin (#708)
-* Add __iter__ to Catalog documentation – @CyanNani123
-
-Version 2.8.1
--------------
-
-This is solely a patch release to make running tests on Py.test 6+ possible.
-
-Bugfixes
-~~~~~~~~
-
-* Support Py.test 6 - Aarni Koskela (#747, #750, #752)
-
-Version 2.8.0
--------------
-
-Improvements
-~~~~~~~~~~~~
-
-* CLDR: Upgrade to CLDR 36.0 - Aarni Koskela (#679)
-* Messages: Don't even open files with the "ignore" extraction method - @sebleblanc (#678)
-
-Bugfixes
-~~~~~~~~
-
-* Numbers: Fix formatting very small decimals when quantization is disabled - Lev Lybin, @miluChen (#662)
-* Messages: Attempt to sort all messages – Mario Frasca (#651, #606)
-
-Docs
-~~~~
-
-* Add years to changelog - Romuald Brunet
-* Note that installation requires pytz - Steve (Gadget) Barnes
-
-Version 2.7.0
--------------
-
-Possibly incompatible changes
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-These may be backward incompatible in some cases, as some more-or-less internal
-APIs have changed. Please feel free to file issues if you bump into anything
-strange and we'll try to help!
-
-* General: Internal uses of ``babel.util.odict`` have been replaced with
-  ``collections.OrderedDict`` from The Python standard library.
-
-Improvements
-~~~~~~~~~~~~
-
-* CLDR: Upgrade to CLDR 35.1 - Alberto Mardegan, Aarni Koskela (#626, #643)
-* General: allow anchoring path patterns to the start of a string - Brian Cappello (#600)
-* General: Bumped version requirement on pytz - @chrisbrake (#592)
-* Messages: `pybabel compile`: exit with code 1 if errors were encountered - Aarni Koskela (#647)
-* Messages: Add omit-header to update_catalog - Cédric Krier (#633)
-* Messages: Catalog update: keep user comments from destination by default - Aarni Koskela (#648)
-* Messages: Skip empty message when writing mo file - Cédric Krier (#564)
-* Messages: Small fixes to avoid crashes on badly formatted .po files - Bryn Truscott (#597)
-* Numbers: `parse_decimal()` `strict` argument and `suggestions` - Charly C (#590)
-* Numbers: don't repeat suggestions in parse_decimal strict - Serban Constantin (#599)
-* Numbers: implement currency formatting with long display names - Luke Plant (#585)
-* Numbers: parse_decimal(): assume spaces are equivalent to non-breaking spaces when not in strict mode - Aarni Koskela (#649)
-* Performance: Cache locale_identifiers() - Aarni Koskela (#644)
-
-Bugfixes
-~~~~~~~~
-
-* CLDR: Skip alt=... for week data (minDays, firstDay, weekendStart, weekendEnd) - Aarni Koskela (#634)
-* Dates: Fix wrong weeknumber for 31.12.2018 - BT-sschmid (#621)
-* Locale: Avoid KeyError trying to get data on WindowsXP - mondeja (#604)
-* Locale: get_display_name(): Don't attempt to concatenate variant information to None - Aarni Koskela (#645)
-* Messages: pofile: Add comparison operators to _NormalizedString - Aarni Koskela (#646)
-* Messages: pofile: don't crash when message.locations can't be sorted - Aarni Koskela (#646)
-
-Tooling & docs
-~~~~~~~~~~~~~~
-
-* Docs: Remove all references to deprecated easy_install - Jon Dufresne (#610)
-* Docs: Switch print statement in docs to print function - NotAFile
-* Docs: Update all pypi.python.org URLs to pypi.org - Jon Dufresne (#587)
-* Docs: Use https URLs throughout project where available - Jon Dufresne (#588)
-* Support: Add testing and document support for Python 3.7 - Jon Dufresne (#611)
-* Support: Test on Python 3.8-dev - Aarni Koskela (#642)
-* Support: Using ABCs from collections instead of collections.abc is deprecated. - Julien Palard (#609)
-* Tests: Fix conftest.py compatibility with pytest 4.3 - Miro Hrončok (#635)
-* Tests: Update pytest and pytest-cov - Miro Hrončok (#635)
-
-Version 2.6.0
--------------
-
-Possibly incompatible changes
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-These may be backward incompatible in some cases, as some more-or-less internal APIs have changed.
-Please feel free to file issues if you bump into anything strange and we'll try to help!
-
-* Numbers: Refactor decimal handling code and allow bypass of decimal quantization. (@kdeldycke) (PR #538)
-* Messages: allow processing files that are in locales unknown to Babel (@akx) (PR #557)
-* General: Drop support for EOL Python 2.6 and 3.3 (@hugovk) (PR #546)
-
-Other changes
-~~~~~~~~~~~~~
-
-* CLDR: Use CLDR 33 (@akx) (PR #581)
-* Lists: Add support for various list styles other than the default (@akx) (#552)
-* Messages: Add new PoFileError exception (@Bedrock02) (PR #532)
-* Times: Simplify Linux distro specific explicit timezone setting search (@scop) (PR #528)
-
-Bugfixes
-~~~~~~~~
-
-* CLDR: avoid importing alt=narrow currency symbols (@akx) (PR #558)
-* CLDR: ignore non-Latin numbering systems (@akx) (PR #579)
-* Docs: Fix improper example for date formatting (@PTrottier) (PR #574)
-* Tooling: Fix some deprecation warnings (@akx) (PR #580)
-
-Tooling & docs
-~~~~~~~~~~~~~~
-
-* Add explicit signatures to some date autofunctions (@xmo-odoo) (PR #554)
-* Include license file in the generated wheel package (@jdufresne) (PR #539)
-* Python 3.6 invalid escape sequence deprecation fixes (@scop) (PR #528)
-* Test and document all supported Python versions (@jdufresne) (PR #540)
-* Update copyright header years and authors file (@akx) (PR #559)
-
-
-Version 2.5.3
--------------
-
-This is a maintenance release that reverts undesired API-breaking changes that slipped into 2.5.2
-(see https://github.com/python-babel/babel/issues/550).
-
-It is based on v2.5.1 (f29eccd) with commits 7cedb84, 29da2d2 and edfb518 cherry-picked on top.
-
-Version 2.5.2
--------------
-
-Bugfixes
-~~~~~~~~
-
-* Revert the unnecessary PyInstaller fixes from 2.5.0 and 2.5.1 (#533) (@yagebu)
-
-Version 2.5.1
--------------
-
-Minor Improvements and bugfixes
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-* Use a fixed datetime to avoid test failures (#520) (@narendravardi)
-* Parse multi-line __future__ imports better (#519) (@akx)
-* Fix validate_currency docstring (#522)
-* Allow normalize_locale and exists to handle various unexpected inputs (#523) (@suhojm)
-* Make PyInstaller support more robust (#525, #526) (@thijstriemstra, @akx)
-
-
-Version 2.5.0
--------------
-
-New Features
-~~~~~~~~~~~~
-
-* Numbers: Add currency utilities and helpers (#491) (@kdeldycke)
-* Support PyInstaller (#500, #505) (@wodo)
-
-Minor Improvements and bugfixes
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-* Dates: Add __str__ to DateTimePattern (#515) (@sfermigier)
-* Dates: Fix an invalid string to bytes comparison when parsing TZ files on Py3 (#498) (@rowillia)
-* Dates: Formatting zero-padded components of dates is faster (#517) (@akx)
-* Documentation: Fix "Good Commits" link in CONTRIBUTING.md (#511) (@naryanacharya6)
-* Documentation: Fix link to Python gettext module (#512) (@Linkid)
-* Messages: Allow both dash and underscore separated locale identifiers in pofiles (#489, #490) (@akx)
-* Messages: Extract Python messages in nested gettext calls (#488) (@sublee)
-* Messages: Fix in-place editing of dir list while iterating (#476, #492) (@MarcDufresne)
-* Messages: Stabilize sort order (#482) (@xavfernandez)
-* Time zones: Honor the no-inherit marker for metazone names (#405) (@akx)
-
-
-Version 2.4.0
--------------
-
-New Features
-~~~~~~~~~~~~
-
-Some of these changes might break your current code and/or tests.
-
-* CLDR: CLDR 29 is now used instead of CLDR 28 (#405) (@akx)
-* Messages: Add option 'add_location' for location line formatting (#438, #459) (@rrader, @alxpy)
-* Numbers: Allow full control of decimal behavior (#410) (@etanol)
-
-Minor Improvements and bugfixes
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-* Documentation: Improve Date Fields descriptions (#450) (@ldwoolley)
-* Documentation: Typo fixes and documentation improvements (#406, #412, #403, #440, #449, #463) (@zyegfryed, @adamchainz, @jwilk, @akx, @roramirez, @abhishekcs10)
-* Messages: Default to UTF-8 source encoding instead of ISO-8859-1 (#399) (@asottile)
-* Messages: Ensure messages are extracted in the order they were passed in (#424) (@ngrilly)
-* Messages: Message extraction for JSX files is improved (#392, #396, #425) (@karloskar, @georgschoelly)
-* Messages: PO file reading supports multi-line obsolete units (#429) (@mbirtwell)
-* Messages: Python message extractor respects unicode_literals in __future__ (#427) (@sublee)
-* Messages: Roundtrip Language headers (#420) (@kruton)
-* Messages: units before obsolete units are no longer erroneously marked obsolete (#452) (@mbirtwell)
-* Numbers: `parse_pattern` now preserves the full original pattern (#414) (@jtwang)
-* Numbers: Fix float conversion in `extract_operands` (#435) (@akx)
-* Plurals: Fix plural forms for Czech and Slovak locales (#373) (@ykshatroff)
-* Plurals: More plural form fixes based on Mozilla and CLDR references (#431) (@mshenfield)
-
-
-Internal improvements
-~~~~~~~~~~~~~~~~~~~~~
-
-* Local times are constructed correctly in tests (#411) (@etanol)
-* Miscellaneous small improvements (#437) (@scop)
-* Regex flags are extracted from the regex strings (#462) (@singingwolfboy)
-* The PO file reader is now a class and has seen some refactoring (#429, #452) (@mbirtwell)
-
-
-Version 2.3.4
--------------
-
-(Bugfix release, released on April 22th 2016)
-
-Bugfixes
-~~~~~~~~
-
-* CLDR: The lxml library is no longer used for CLDR importing, so it should not cause strange failures either. Thanks to @aronbierbaum for the bug report and @jtwang for the fix. (https://github.com/python-babel/babel/pull/393)
-* CLI: Every last single CLI usage regression should now be gone, and both distutils and stand-alone CLIs should work as they have in the past. Thanks to @paxswill and @ajaeger for bug reports. (https://github.com/python-babel/babel/pull/389)
-
-Version 2.3.3
--------------
-
-(Bugfix release, released on April 12th 2016)
-
-Bugfixes
-~~~~~~~~
-
-* CLI: Usage regressions that had snuck in between 2.2 and 2.3 should be no more. (https://github.com/python-babel/babel/pull/386) Thanks to @ajaeger, @sebdiem and @jcristovao for bug reports and patches.
-
-Version 2.3.2
--------------
-
-(Bugfix release, released on April 9th 2016)
-
-Bugfixes
-~~~~~~~~
-
-* Dates: Period (am/pm) formatting was broken in certain locales (namely zh_TW). Thanks to @jun66j5 for the bug report. (https://github.com/python-babel/babel/issues/378, https://github.com/python-babel/babel/issues/379)
-
-Version 2.3.1
--------------
-
-(Bugfix release because of deployment problems, released on April 8th 2016)
-
-Version 2.3
------------
-
-(Feature release, released on April 8th 2016)
-
-Internal improvements
-~~~~~~~~~~~~~~~~~~~~~
-
-* The CLI frontend and Distutils commands use a shared implementation (https://github.com/python-babel/babel/pull/311)
-* PyPy3 is supported (https://github.com/python-babel/babel/pull/343)
-
-Features
-~~~~~~~~
-
-* CLDR: Add an API for territory language data (https://github.com/python-babel/babel/pull/315)
-* Core: Character order and measurement system data is imported and exposed (https://github.com/python-babel/babel/pull/368)
-* Dates: Add an API for time interval formatting (https://github.com/python-babel/babel/pull/316)
-* Dates: More pattern formats and lengths are supported (https://github.com/python-babel/babel/pull/347)
-* Dates: Period IDs are imported and exposed (https://github.com/python-babel/babel/pull/349)
-* Dates: Support for date-time skeleton formats has been added (https://github.com/python-babel/babel/pull/265)
-* Dates: Timezone formatting has been improved (https://github.com/python-babel/babel/pull/338)
-* Messages: JavaScript extraction now supports dotted names, ES6 template strings and JSX tags (https://github.com/python-babel/babel/pull/332)
-* Messages: npgettext is recognized by default (https://github.com/python-babel/babel/pull/341)
-* Messages: The CLI learned to accept multiple domains (https://github.com/python-babel/babel/pull/335)
-* Messages: The extraction commands now accept filenames in addition to directories (https://github.com/python-babel/babel/pull/324)
-* Units: A new API for unit formatting is implemented (https://github.com/python-babel/babel/pull/369)
-
-Bugfixes
-~~~~~~~~
-
-* Core: Mixed-case locale IDs work more reliably (https://github.com/python-babel/babel/pull/361)
-* Dates: S...S formats work correctly now (https://github.com/python-babel/babel/pull/360)
-* Messages: All messages are now sorted correctly if sorting has been specified (https://github.com/python-babel/babel/pull/300)
-* Messages: Fix the unexpected behavior caused by catalog header updating (e0e7ef1) (https://github.com/python-babel/babel/pull/320)
-* Messages: Gettext operands are now generated correctly (https://github.com/python-babel/babel/pull/295)
-* Messages: Message extraction has been taught to detect encodings better (https://github.com/python-babel/babel/pull/274)
-
-Version 2.2
------------
-
-(Feature release, released on January 2nd 2016)
-
-Bugfixes
-~~~~~~~~
-
-* General: Add __hash__ to Locale. (#303) (2aa8074)
-* General: Allow files with BOM if they're UTF-8 (#189) (da87edd)
-* General: localedata directory is now locale-data (#109) (2d1882e)
-* General: odict: Fix pop method (0a9e97e)
-* General: Removed uses of datetime.date class from *.dat files (#174) (94f6830)
-* Messages: Fix plural selection for Chinese (531f666)
-* Messages: Fix typo and add semicolon in plural_forms (5784501)
-* Messages: Flatten NullTranslations.files into a list (ad11101)
-* Times: FixedOffsetTimezone: fix display of negative offsets (d816803)
-
-Features
-~~~~~~~~
-
-* CLDR: Update to CLDR 28 (#292) (9f7f4d0)
-* General: Add __copy__ and __deepcopy__ to LazyProxy. (a1cc3f1)
-* General: Add official support for Python 3.4 and 3.5
-* General: Improve odict performance by making key search O(1) (6822b7f)
-* Locale: Add an ordinal_form property to Locale (#270) (b3f3430)
-* Locale: Add support for list formatting (37ce4fa, be6e23d)
-* Locale: Check inheritance exceptions first (3ef0d6d)
-* Messages: Allow file locations without line numbers (#279) (79bc781)
-* Messages: Allow passing a callable to `extract()` (#289) (3f58516)
-* Messages: Support 'Language' header field of PO files (#76) (3ce842b)
-* Messages: Update catalog headers from templates (e0e7ef1)
-* Numbers: Properly load and expose currency format types (#201) (df676ab)
-* Numbers: Use cdecimal by default when available (b6169be)
-* Numbers: Use the CLDR's suggested number of decimals for format_currency (#139) (201ed50)
-* Times: Add format_timedelta(format='narrow') support (edc5eb5)
-
-Version 2.1
------------
-
-(Bugfix/minor feature release, released on September 25th 2015)
-
-- Parse and honour the locale inheritance exceptions
-  (https://github.com/python-babel/babel/issues/97)
-- Fix Locale.parse using ``global.dat`` incompatible types
-  (https://github.com/python-babel/babel/issues/174)
-- Fix display of negative offsets in ``FixedOffsetTimezone``
-  (https://github.com/python-babel/babel/issues/214)
-- Improved odict performance which is used during localization file
-  build, should improve compilation time for large projects
-- Add support for "narrow" format for ``format_timedelta``
-- Add universal wheel support
-- Support 'Language' header field in .PO files
-  (fixes https://github.com/python-babel/babel/issues/76)
-- Test suite enhancements (coverage, broken tests fixed, etc)
-- Documentation updated
-
-Version 2.0
------------
-
-(Released on July 27th 2015, codename Second Coming)
-
-- Added support for looking up currencies that belong to a territory
-  through the :func:`babel.numbers.get_territory_currencies`
-  function.
-- Improved Python 3 support.
-- Fixed some broken tests for timezone behavior.
-- Improved various smaller things for dealing with dates.
-
-Version 1.4
------------
-
-(bugfix release, release date to be decided)
-
-- Fixed a bug that caused deprecated territory codes not being
-  converted properly by the subtag resolving.  This for instance
-  showed up when trying to use ``und_UK`` as a language code
-  which now properly resolves to ``en_GB``.
-- Fixed a bug that made it impossible to import the CLDR data
-  from scratch on windows systems.
-
-Version 1.3
------------
-
-(bugfix release, released on July 29th 2013)
-
-- Fixed a bug in likely-subtag resolving for some common locales.
-  This primarily makes ``zh_CN`` work again which was broken
-  due to how it was defined in the likely subtags combined with
-  our broken resolving.  This fixes :gh:`37`.
-- Fixed a bug that caused pybabel to break when writing to stdout
-  on Python 3.
-- Removed a stray print that was causing issues when writing to
-  stdout for message catalogs.
-
-Version 1.2
------------
-
-(bugfix release, released on July 27th 2013)
-
-- Included all tests in the tarball.  Previously the include
-  skipped past recursive folders.
-- Changed how tests are invoked and added separate standalone
-  test command.  This simplifies testing of the package for
-  linux distributors.
-
-Version 1.1
------------
-
-(bugfix release, released on July 27th 2013)
-
-- added dummy version requirements for pytz so that it installs
-  on pip 1.4.
-- Included tests in the tarball.
-
-Version 1.0
------------
-
-(Released on July 26th 2013, codename Revival)
-
-- support python 2.6, 2.7, 3.3+ and pypy - drop all other versions
-- use tox for testing on different pythons
-- Added support for the locale plural rules defined by the CLDR.
-- Added `format_timedelta` function to support localized formatting of
-  relative times with strings such as "2 days" or "1 month" (:trac:`126`).
-- Fixed negative offset handling of Catalog._set_mime_headers (:trac:`165`).
-- Fixed the case where messages containing square brackets would break with
-  an unpack error.
-- updated to CLDR 23
-- Make the CLDR import script work with Python 2.7.
-- Fix various typos.
-- Sort output of list-locales.
-- Make the POT-Creation-Date of the catalog being updated equal to
-  POT-Creation-Date of the template used to update (:trac:`148`).
-- Use a more explicit error message if no option or argument (command) is
-  passed to pybabel (:trac:`81`).
-- Keep the PO-Revision-Date if it is not the default value (:trac:`148`).
-- Make --no-wrap work by reworking --width's default and mimic xgettext's
-  behaviour of always wrapping comments (:trac:`145`).
-- Add --project and --version options for commandline (:trac:`173`).
-- Add a __ne__() method to the Local class.
-- Explicitly sort instead of using sorted() and don't assume ordering
-  (Jython compatibility).
-- Removed ValueError raising for string formatting message checkers if the
-  string does not contain any string formattings (:trac:`150`).
-- Fix Serbian plural forms (:trac:`213`).
-- Small speed improvement in format_date() (:trac:`216`).
-- Fix so frontend.CommandLineInterface.run does not accumulate logging
-  handlers (:trac:`227`, reported with initial patch by dfraser)
-- Fix exception if environment contains an invalid locale setting
-  (:trac:`200`)
-- use cPickle instead of pickle for better performance (:trac:`225`)
-- Only use bankers round algorithm as a tie breaker if there are two nearest
-  numbers, round as usual if there is only one nearest number (:trac:`267`,
-  patch by Martin)
-- Allow disabling cache behaviour in LazyProxy (:trac:`208`, initial patch
-  from Pedro Algarvio)
-- Support for context-aware methods during message extraction (:trac:`229`,
-  patch from David Rios)
-- "init" and "update" commands support "--no-wrap" option (:trac:`289`)
-- fix formatting of fraction in format_decimal() if the input value is a float
-  with more than 7 significant digits (:trac:`183`)
-- fix format_date() with datetime parameter (:trac:`282`, patch from Xavier
-  Morel)
-- fix format_decimal() with small Decimal values (:trac:`214`, patch from
-  George Lund)
-- fix handling of messages containing '\\n' (:trac:`198`)
-- handle irregular multi-line msgstr (no "" as first line) gracefully
-  (:trac:`171`)
-- parse_decimal() now returns Decimals not floats, API change (:trac:`178`)
-- no warnings when running setup.py without installed setuptools (:trac:`262`)
-- modified Locale.__eq__ method so Locales are only equal if all of their
-  attributes (language, territory, script, variant) are equal
-- resort to hard-coded message extractors/checkers if pkg_resources is
-  installed but no egg-info was found (:trac:`230`)
-- format_time() and format_datetime() now accept also floats (:trac:`242`)
-- add babel.support.NullTranslations class similar to gettext.NullTranslations
-  but with all of Babel's new gettext methods (:trac:`277`)
-- "init" and "update" commands support "--width" option (:trac:`284`)
-- fix 'input_dirs' option for setuptools integration (:trac:`232`, initial
-  patch by Étienne Bersac)
-- ensure .mo file header contains the same information as the source .po file
-  (:trac:`199`)
-- added support for get_language_name() on the locale objects.
-- added support for get_territory_name() on the locale objects.
-- added support for get_script_name() on the locale objects.
-- added pluralization support for currency names and added a '¤¤¤'
-  pattern for currencies that includes the full name.
-- depend on pytz now and wrap it nicer.  This gives us improved support
-  for things like timezone transitions and an overall nicer API.
-- Added support for explicit charset to PO file reading.
-- Added experimental Python 3 support.
-- Added better support for returning timezone names.
-- Don't throw away a Catalog's obsolete messages when updating it.
-- Added basic likelySubtag resolving when doing locale parsing and no
-  match can be found.
-
-
-Version 0.9.6
--------------
-
-(released on March 17th 2011)
-
-- Backport r493-494: documentation typo fixes.
-- Make the CLDR import script work with Python 2.7.
-- Fix various typos.
-- Fixed Python 2.3 compatibility (:trac:`146`, :trac:`233`).
-- Sort output of list-locales.
-- Make the POT-Creation-Date of the catalog being updated equal to
-  POT-Creation-Date of the template used to update (:trac:`148`).
-- Use a more explicit error message if no option or argument (command) is
-  passed to pybabel (:trac:`81`).
-- Keep the PO-Revision-Date if it is not the default value (:trac:`148`).
-- Make --no-wrap work by reworking --width's default and mimic xgettext's
-  behaviour of always wrapping comments (:trac:`145`).
-- Fixed negative offset handling of Catalog._set_mime_headers (:trac:`165`).
-- Add --project and --version options for commandline (:trac:`173`).
-- Add a __ne__() method to the Local class.
-- Explicitly sort instead of using sorted() and don't assume ordering
-  (Python 2.3 and Jython compatibility).
-- Removed ValueError raising for string formatting message checkers if the
-  string does not contain any string formattings (:trac:`150`).
-- Fix Serbian plural forms (:trac:`213`).
-- Small speed improvement in format_date() (:trac:`216`).
-- Fix number formatting for locales where CLDR specifies alt or draft
-  items (:trac:`217`)
-- Fix bad check in format_time (:trac:`257`, reported with patch and tests by
-  jomae)
-- Fix so frontend.CommandLineInterface.run does not accumulate logging
-  handlers (:trac:`227`, reported with initial patch by dfraser)
-- Fix exception if environment contains an invalid locale setting
-  (:trac:`200`)
-
-
-Version 0.9.5
--------------
-
-(released on April 6th 2010)
-
-- Fixed the case where messages containing square brackets would break with
-  an unpack error.
-- Backport of r467: Fuzzy matching regarding plurals should *NOT* be checked
-  against len(message.id)  because this is always 2, instead, it's should be
-  checked against catalog.num_plurals (:trac:`212`).
-
-
-Version 0.9.4
--------------
-
-(released on August 25th 2008)
-
-- Currency symbol definitions that is defined with choice patterns in the
-  CLDR data are no longer imported, so the symbol code will be used instead.
-- Fixed quarter support in date formatting.
-- Fixed a serious memory leak that was introduces by the support for CLDR
-  aliases in 0.9.3 (:trac:`128`).
-- Locale modifiers such as "@euro" are now stripped from locale identifiers
-  when parsing (:trac:`136`).
-- The system locales "C" and "POSIX" are now treated as aliases for
-  "en_US_POSIX", for which the CLDR provides the appropriate data. Thanks to
-  Manlio Perillo for the suggestion.
-- Fixed JavaScript extraction for regular expression literals (:trac:`138`)
-  and concatenated strings.
-- The `Translation` class in `babel.support` can now manage catalogs with
-  different message domains, and exposes the family of `d*gettext` functions
-  (:trac:`137`).
-
-
-Version 0.9.3
--------------
-
-(released on July 9th 2008)
-
-- Fixed invalid message extraction methods causing an UnboundLocalError.
-- Extraction method specification can now use a dot instead of the colon to
-  separate module and function name (:trac:`105`).
-- Fixed message catalog compilation for locales with more than two plural
-  forms (:trac:`95`).
-- Fixed compilation of message catalogs for locales with more than two plural
-  forms where the translations were empty (:trac:`97`).
-- The stripping of the comment tags in comments is optional now and
-  is done for each line in a comment.
-- Added a JavaScript message extractor.
-- Updated to CLDR 1.6.
-- Fixed timezone calculations when formatting datetime and time values.
-- Added a `get_plural` function into the plurals module that returns the
-  correct plural forms for a locale as tuple.
-- Added support for alias definitions in the CLDR data files, meaning that
-  the chance for items missing in certain locales should be greatly reduced
-  (:trac:`68`).
-
-
-Version 0.9.2
--------------
-
-(released on February 4th 2008)
-
-- Fixed catalogs' charset values not being recognized (:trac:`66`).
-- Numerous improvements to the default plural forms.
-- Fixed fuzzy matching when updating message catalogs (:trac:`82`).
-- Fixed bug in catalog updating, that in some cases pulled in translations
-  from different catalogs based on the same template.
-- Location lines in PO files do no longer get wrapped at hyphens in file
-  names (:trac:`79`).
-- Fixed division by zero error in catalog compilation on empty catalogs
-  (:trac:`60`).
-
-
-Version 0.9.1
--------------
-
-(released on September 7th 2007)
-
-- Fixed catalog updating when a message is merged that was previously simple
-  but now has a plural form, for example by moving from `gettext` to
-  `ngettext`, or vice versa.
-- Fixed time formatting for 12 am and 12 pm.
-- Fixed output encoding of the `pybabel --list-locales` command.
-- MO files are now written in binary mode on windows (:trac:`61`).
-
-
-Version 0.9
------------
-
-(released on August 20th 2007)
-
-- The `new_catalog` distutils command has been renamed to `init_catalog` for
-  consistency with the command-line frontend.
-- Added compilation of message catalogs to MO files (:trac:`21`).
-- Added updating of message catalogs from POT files (:trac:`22`).
-- Support for significant digits in number formatting.
-- Apply proper "banker's rounding" in number formatting in a cross-platform
-  manner.
-- The number formatting functions now also work with numbers represented by
-  Python `Decimal` objects (:trac:`53`).
-- Added extensible infrastructure for validating translation catalogs.
-- Fixed the extractor not filtering out messages that didn't validate against
-  the keyword's specification (:trac:`39`).
-- Fixed the extractor raising an exception when encountering an empty string
-  msgid. It now emits a warning to stderr.
-- Numerous Python message extractor fixes: it now handles nested function
-  calls within a gettext function call correctly, uses the correct line number
-  for multi-line function calls, and other small fixes (tickets :trac:`38` and
-  :trac:`39`).
-- Improved support for detecting Python string formatting fields in message
-  strings (:trac:`57`).
-- CLDR upgraded to the 1.5 release.
-- Improved timezone formatting.
-- Implemented scientific number formatting.
-- Added mechanism to lookup locales by alias, for cases where browsers insist
-  on including only the language code in the `Accept-Language` header, and
-  sometimes even the incorrect language code.
-
-
-Version 0.8.1
--------------
-
-(released on July 2nd 2007)
-
-- `default_locale()` would fail when the value of the `LANGUAGE` environment
-  variable contained multiple language codes separated by colon, as is
-  explicitly allowed by the GNU gettext tools. As the `default_locale()`
-  function is called at the module level in some modules, this bug would
-  completely break importing these modules on systems where `LANGUAGE` is set
-  that way.
-- The character set specified in PO template files is now respected when
-  creating new catalog files based on that template. This allows the use of
-  characters outside the ASCII range in POT files (:trac:`17`).
-- The default ordering of messages in generated POT files, which is based on
-  the order those messages are found when walking the source tree, is no
-  longer subject to differences between platforms; directory and file names
-  are now always sorted alphabetically.
-- The Python message extractor now respects the special encoding comment to be
-  able to handle files containing non-ASCII characters (:trac:`23`).
-- Added ``N_`` (gettext noop) to the extractor's default keywords.
-- Made locale string parsing more robust, and also take the script part into
-  account (:trac:`27`).
-- Added a function to list all locales for which locale data is available.
-- Added a command-line option to the `pybabel` command which prints out all
-  available locales (:trac:`24`).
-- The name of the command-line script has been changed from just `babel` to
-  `pybabel` to avoid a conflict with the OpenBabel project (:trac:`34`).
-
-
-Version 0.8
------------
-
-(released on June 20th 2007)
-
-- First public release

+ 0 - 29
desktop/core/ext-py/Babel-2.9.1/LICENSE

@@ -1,29 +0,0 @@
-Copyright (c) 2013-2021 by the Babel Team, see AUTHORS for more information.
-
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions
-are met:
-
- 1. Redistributions of source code must retain the above copyright
-    notice, this list of conditions and the following disclaimer.
- 2. Redistributions in binary form must reproduce the above copyright
-    notice, this list of conditions and the following disclaimer in
-    the documentation and/or other materials provided with the
-    distribution.
- 3. The name of the author may not be used to endorse or promote
-    products derived from this software without specific prior
-    written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS
-OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
-GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
-IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
-OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
-IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

+ 0 - 10
desktop/core/ext-py/Babel-2.9.1/MANIFEST.in

@@ -1,10 +0,0 @@
-include Makefile CHANGES LICENSE AUTHORS
-include conftest.py tox.ini
-include babel/global.dat
-include babel/locale-data/*.dat
-recursive-include docs *
-recursive-exclude docs/_build *
-include scripts/*
-recursive-include tests *
-recursive-exclude tests *.pyc
-recursive-exclude tests *.pyo

+ 0 - 48
desktop/core/ext-py/Babel-2.9.1/Makefile

@@ -1,48 +0,0 @@
-test: import-cldr
-	@PYTHONWARNINGS=default python ${PYTHON_TEST_FLAGS} -m pytest
-
-test-cov: import-cldr
-	@PYTHONWARNINGS=default python ${PYTHON_TEST_FLAGS} -m pytest --cov=babel
-
-test-env:
-	@virtualenv test-env
-	@test-env/bin/pip install pytest
-	@test-env/bin/pip install --editable .
-
-clean-test-env:
-	@rm -rf test-env
-
-standalone-test: import-cldr test-env
-	@test-env/bin/py.test tests
-
-clean: clean-cldr clean-pyc clean-test-env
-
-import-cldr:
-	@python scripts/download_import_cldr.py
-
-clean-cldr:
-	@rm -f babel/locale-data/*.dat
-	@rm -f babel/global.dat
-
-clean-pyc:
-	@find . -name '*.pyc' -exec rm {} \;
-	@find . -name '__pycache__' -type d | xargs rm -rf
-
-develop:
-	@pip install --editable .
-
-tox-test: import-cldr
-	@tox
-
-upload-docs:
-	$(MAKE) -C docs html dirhtml latex
-	$(MAKE) -C docs/_build/latex all-pdf
-	cd docs/_build/; mv html babel-docs; zip -r babel-docs.zip babel-docs; mv babel-docs html
-	rsync -a docs/_build/dirhtml/ pocoo.org:/var/www/babel.pocoo.org/docs/
-	rsync -a docs/_build/latex/Babel.pdf pocoo.org:/var/www/babel.pocoo.org/docs/babel-docs.pdf
-	rsync -a docs/_build/babel-docs.zip pocoo.org:/var/www/babel.pocoo.org/docs/babel-docs.zip
-
-release: import-cldr
-	python scripts/make-release.py
-
-.PHONY: test develop tox-test clean-pyc clean-cldr import-cldr clean release upload-docs clean-test-env standalone-test

+ 0 - 27
desktop/core/ext-py/Babel-2.9.1/PKG-INFO

@@ -1,27 +0,0 @@
-Metadata-Version: 1.2
-Name: Babel
-Version: 2.9.1
-Summary: Internationalization utilities
-Home-page: http://babel.pocoo.org/
-Author: Armin Ronacher
-Author-email: armin.ronacher@active-4.com
-License: BSD
-Description: A collection of tools for internationalizing Python applications.
-Platform: UNKNOWN
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Environment :: Web Environment
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: BSD License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 2
-Classifier: Programming Language :: Python :: 2.7
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.4
-Classifier: Programming Language :: Python :: 3.5
-Classifier: Programming Language :: Python :: 3.6
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: Implementation :: CPython
-Classifier: Programming Language :: Python :: Implementation :: PyPy
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*

+ 0 - 24
desktop/core/ext-py/Babel-2.9.1/README.rst

@@ -1,24 +0,0 @@
-About Babel
-===========
-
-Babel is a Python library that provides an integrated collection of
-utilities that assist with internationalizing and localizing Python
-applications (in particular web-based applications.)
-
-Details can be found in the HTML files in the ``docs`` folder.
-
-For more information please visit the Babel web site:
-
-http://babel.pocoo.org/
-
-Join the chat at https://gitter.im/python-babel/babel
-
-Contributing to Babel
-=====================
-
-If you want to contribute code to Babel, please take a look at our
-`CONTRIBUTING.md <https://github.com/python-babel/babel/blob/master/CONTRIBUTING.md>`__.
-
-If you know your way around Babels codebase a bit and like to help
-further, we would appreciate any help in reviewing pull requests. Please
-contact us at https://gitter.im/python-babel/babel if you're interested!

+ 0 - 24
desktop/core/ext-py/Babel-2.9.1/babel/__init__.py

@@ -1,24 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    babel
-    ~~~~~
-
-    Integrated collection of utilities that assist in internationalizing and
-    localizing applications.
-
-    This package is basically composed of two major parts:
-
-     * tools to build and work with ``gettext`` message catalogs
-     * a Python interface to the CLDR (Common Locale Data Repository), providing
-       access to various locale display names, localized number and date
-       formatting, etc.
-
-    :copyright: (c) 2013-2021 by the Babel Team.
-    :license: BSD, see LICENSE for more details.
-"""
-
-from babel.core import UnknownLocaleError, Locale, default_locale, \
-    negotiate_locale, parse_locale, get_locale_identifier
-
-
-__version__ = '2.9.1'

+ 0 - 79
desktop/core/ext-py/Babel-2.9.1/babel/_compat.py

@@ -1,79 +0,0 @@
-import sys
-import array
-
-PY2 = sys.version_info[0] == 2
-
-_identity = lambda x: x
-
-
-if not PY2:
-    text_type = str
-    string_types = (str,)
-    integer_types = (int, )
-
-    text_to_native = lambda s, enc: s
-    unichr = chr
-
-    iterkeys = lambda d: iter(d.keys())
-    itervalues = lambda d: iter(d.values())
-    iteritems = lambda d: iter(d.items())
-
-    from io import StringIO, BytesIO
-    import pickle
-
-    izip = zip
-    imap = map
-    range_type = range
-
-    cmp = lambda a, b: (a > b) - (a < b)
-
-    array_tobytes = array.array.tobytes
-    from collections import abc
-
-else:
-    text_type = unicode
-    string_types = (str, unicode)
-    integer_types = (int, long)
-
-    text_to_native = lambda s, enc: s.encode(enc)
-    unichr = unichr
-
-    iterkeys = lambda d: d.iterkeys()
-    itervalues = lambda d: d.itervalues()
-    iteritems = lambda d: d.iteritems()
-
-    from cStringIO import StringIO as BytesIO
-    from StringIO import StringIO
-    import cPickle as pickle
-
-    from itertools import imap
-    from itertools import izip
-    range_type = xrange
-
-    cmp = cmp
-
-    array_tobytes = array.array.tostring
-    import collections as abc
-
-number_types = integer_types + (float,)
-
-
-def force_text(s, encoding='utf-8', errors='strict'):
-    if isinstance(s, text_type):
-        return s
-    if isinstance(s, bytes):
-        return s.decode(encoding, errors)
-    return text_type(s)
-
-
-#
-# Since Python 3.3, a fast decimal implementation is already included in the
-# standard library.  Otherwise use cdecimal when available
-#
-if sys.version_info[:2] >= (3, 3):
-    import decimal
-else:
-    try:
-        import cdecimal as decimal
-    except ImportError:
-        import decimal

+ 0 - 1133
desktop/core/ext-py/Babel-2.9.1/babel/core.py

@@ -1,1133 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    babel.core
-    ~~~~~~~~~~
-
-    Core locale representation and locale data access.
-
-    :copyright: (c) 2013-2021 by the Babel Team.
-    :license: BSD, see LICENSE for more details.
-"""
-
-import os
-
-from babel import localedata
-from babel._compat import pickle, string_types
-from babel.plural import PluralRule
-
-__all__ = ['UnknownLocaleError', 'Locale', 'default_locale', 'negotiate_locale',
-           'parse_locale']
-
-
-_global_data = None
-_default_plural_rule = PluralRule({})
-
-
-def _raise_no_data_error():
-    raise RuntimeError('The babel data files are not available. '
-                       'This usually happens because you are using '
-                       'a source checkout from Babel and you did '
-                       'not build the data files.  Just make sure '
-                       'to run "python setup.py import_cldr" before '
-                       'installing the library.')
-
-
-def get_global(key):
-    """Return the dictionary for the given key in the global data.
-
-    The global data is stored in the ``babel/global.dat`` file and contains
-    information independent of individual locales.
-
-    >>> get_global('zone_aliases')['UTC']
-    u'Etc/UTC'
-    >>> get_global('zone_territories')['Europe/Berlin']
-    u'DE'
-
-    The keys available are:
-
-    - ``all_currencies``
-    - ``currency_fractions``
-    - ``language_aliases``
-    - ``likely_subtags``
-    - ``parent_exceptions``
-    - ``script_aliases``
-    - ``territory_aliases``
-    - ``territory_currencies``
-    - ``territory_languages``
-    - ``territory_zones``
-    - ``variant_aliases``
-    - ``windows_zone_mapping``
-    - ``zone_aliases``
-    - ``zone_territories``
-
-    .. note:: The internal structure of the data may change between versions.
-
-    .. versionadded:: 0.9
-
-    :param key: the data key
-    """
-    global _global_data
-    if _global_data is None:
-        dirname = os.path.join(os.path.dirname(__file__))
-        filename = os.path.join(dirname, 'global.dat')
-        if not os.path.isfile(filename):
-            _raise_no_data_error()
-        with open(filename, 'rb') as fileobj:
-            _global_data = pickle.load(fileobj)
-    return _global_data.get(key, {})
-
-
-LOCALE_ALIASES = {
-    'ar': 'ar_SY', 'bg': 'bg_BG', 'bs': 'bs_BA', 'ca': 'ca_ES', 'cs': 'cs_CZ',
-    'da': 'da_DK', 'de': 'de_DE', 'el': 'el_GR', 'en': 'en_US', 'es': 'es_ES',
-    'et': 'et_EE', 'fa': 'fa_IR', 'fi': 'fi_FI', 'fr': 'fr_FR', 'gl': 'gl_ES',
-    'he': 'he_IL', 'hu': 'hu_HU', 'id': 'id_ID', 'is': 'is_IS', 'it': 'it_IT',
-    'ja': 'ja_JP', 'km': 'km_KH', 'ko': 'ko_KR', 'lt': 'lt_LT', 'lv': 'lv_LV',
-    'mk': 'mk_MK', 'nl': 'nl_NL', 'nn': 'nn_NO', 'no': 'nb_NO', 'pl': 'pl_PL',
-    'pt': 'pt_PT', 'ro': 'ro_RO', 'ru': 'ru_RU', 'sk': 'sk_SK', 'sl': 'sl_SI',
-    'sv': 'sv_SE', 'th': 'th_TH', 'tr': 'tr_TR', 'uk': 'uk_UA'
-}
-
-
-class UnknownLocaleError(Exception):
-    """Exception thrown when a locale is requested for which no locale data
-    is available.
-    """
-
-    def __init__(self, identifier):
-        """Create the exception.
-
-        :param identifier: the identifier string of the unsupported locale
-        """
-        Exception.__init__(self, 'unknown locale %r' % identifier)
-
-        #: The identifier of the locale that could not be found.
-        self.identifier = identifier
-
-
-class Locale(object):
-    """Representation of a specific locale.
-
-    >>> locale = Locale('en', 'US')
-    >>> repr(locale)
-    "Locale('en', territory='US')"
-    >>> locale.display_name
-    u'English (United States)'
-
-    A `Locale` object can also be instantiated from a raw locale string:
-
-    >>> locale = Locale.parse('en-US', sep='-')
-    >>> repr(locale)
-    "Locale('en', territory='US')"
-
-    `Locale` objects provide access to a collection of locale data, such as
-    territory and language names, number and date format patterns, and more:
-
-    >>> locale.number_symbols['decimal']
-    u'.'
-
-    If a locale is requested for which no locale data is available, an
-    `UnknownLocaleError` is raised:
-
-    >>> Locale.parse('en_XX')
-    Traceback (most recent call last):
-        ...
-    UnknownLocaleError: unknown locale 'en_XX'
-
-    For more information see :rfc:`3066`.
-    """
-
-    def __init__(self, language, territory=None, script=None, variant=None):
-        """Initialize the locale object from the given identifier components.
-
-        >>> locale = Locale('en', 'US')
-        >>> locale.language
-        'en'
-        >>> locale.territory
-        'US'
-
-        :param language: the language code
-        :param territory: the territory (country or region) code
-        :param script: the script code
-        :param variant: the variant code
-        :raise `UnknownLocaleError`: if no locale data is available for the
-                                     requested locale
-        """
-        #: the language code
-        self.language = language
-        #: the territory (country or region) code
-        self.territory = territory
-        #: the script code
-        self.script = script
-        #: the variant code
-        self.variant = variant
-        self.__data = None
-
-        identifier = str(self)
-        if not localedata.exists(identifier):
-            raise UnknownLocaleError(identifier)
-
-    @classmethod
-    def default(cls, category=None, aliases=LOCALE_ALIASES):
-        """Return the system default locale for the specified category.
-
-        >>> for name in ['LANGUAGE', 'LC_ALL', 'LC_CTYPE', 'LC_MESSAGES']:
-        ...     os.environ[name] = ''
-        >>> os.environ['LANG'] = 'fr_FR.UTF-8'
-        >>> Locale.default('LC_MESSAGES')
-        Locale('fr', territory='FR')
-
-        The following fallbacks to the variable are always considered:
-
-        - ``LANGUAGE``
-        - ``LC_ALL``
-        - ``LC_CTYPE``
-        - ``LANG``
-
-        :param category: one of the ``LC_XXX`` environment variable names
-        :param aliases: a dictionary of aliases for locale identifiers
-        """
-        # XXX: use likely subtag expansion here instead of the
-        # aliases dictionary.
-        locale_string = default_locale(category, aliases=aliases)
-        return cls.parse(locale_string)
-
-    @classmethod
-    def negotiate(cls, preferred, available, sep='_', aliases=LOCALE_ALIASES):
-        """Find the best match between available and requested locale strings.
-
-        >>> Locale.negotiate(['de_DE', 'en_US'], ['de_DE', 'de_AT'])
-        Locale('de', territory='DE')
-        >>> Locale.negotiate(['de_DE', 'en_US'], ['en', 'de'])
-        Locale('de')
-        >>> Locale.negotiate(['de_DE', 'de'], ['en_US'])
-
-        You can specify the character used in the locale identifiers to separate
-        the differnet components. This separator is applied to both lists. Also,
-        case is ignored in the comparison:
-
-        >>> Locale.negotiate(['de-DE', 'de'], ['en-us', 'de-de'], sep='-')
-        Locale('de', territory='DE')
-
-        :param preferred: the list of locale identifers preferred by the user
-        :param available: the list of locale identifiers available
-        :param aliases: a dictionary of aliases for locale identifiers
-        """
-        identifier = negotiate_locale(preferred, available, sep=sep,
-                                      aliases=aliases)
-        if identifier:
-            return Locale.parse(identifier, sep=sep)
-
-    @classmethod
-    def parse(cls, identifier, sep='_', resolve_likely_subtags=True):
-        """Create a `Locale` instance for the given locale identifier.
-
-        >>> l = Locale.parse('de-DE', sep='-')
-        >>> l.display_name
-        u'Deutsch (Deutschland)'
-
-        If the `identifier` parameter is not a string, but actually a `Locale`
-        object, that object is returned:
-
-        >>> Locale.parse(l)
-        Locale('de', territory='DE')
-
-        This also can perform resolving of likely subtags which it does
-        by default.  This is for instance useful to figure out the most
-        likely locale for a territory you can use ``'und'`` as the
-        language tag:
-
-        >>> Locale.parse('und_AT')
-        Locale('de', territory='AT')
-
-        :param identifier: the locale identifier string
-        :param sep: optional component separator
-        :param resolve_likely_subtags: if this is specified then a locale will
-                                       have its likely subtag resolved if the
-                                       locale otherwise does not exist.  For
-                                       instance ``zh_TW`` by itself is not a
-                                       locale that exists but Babel can
-                                       automatically expand it to the full
-                                       form of ``zh_hant_TW``.  Note that this
-                                       expansion is only taking place if no
-                                       locale exists otherwise.  For instance
-                                       there is a locale ``en`` that can exist
-                                       by itself.
-        :raise `ValueError`: if the string does not appear to be a valid locale
-                             identifier
-        :raise `UnknownLocaleError`: if no locale data is available for the
-                                     requested locale
-        """
-        if identifier is None:
-            return None
-        elif isinstance(identifier, Locale):
-            return identifier
-        elif not isinstance(identifier, string_types):
-            raise TypeError('Unexpected value for identifier: %r' % (identifier,))
-
-        parts = parse_locale(identifier, sep=sep)
-        input_id = get_locale_identifier(parts)
-
-        def _try_load(parts):
-            try:
-                return cls(*parts)
-            except UnknownLocaleError:
-                return None
-
-        def _try_load_reducing(parts):
-            # Success on first hit, return it.
-            locale = _try_load(parts)
-            if locale is not None:
-                return locale
-
-            # Now try without script and variant
-            locale = _try_load(parts[:2])
-            if locale is not None:
-                return locale
-
-        locale = _try_load(parts)
-        if locale is not None:
-            return locale
-        if not resolve_likely_subtags:
-            raise UnknownLocaleError(input_id)
-
-        # From here onwards is some very bad likely subtag resolving.  This
-        # whole logic is not entirely correct but good enough (tm) for the
-        # time being.  This has been added so that zh_TW does not cause
-        # errors for people when they upgrade.  Later we should properly
-        # implement ICU like fuzzy locale objects and provide a way to
-        # maximize and minimize locale tags.
-
-        language, territory, script, variant = parts
-        language = get_global('language_aliases').get(language, language)
-        territory = get_global('territory_aliases').get(territory, (territory,))[0]
-        script = get_global('script_aliases').get(script, script)
-        variant = get_global('variant_aliases').get(variant, variant)
-
-        if territory == 'ZZ':
-            territory = None
-        if script == 'Zzzz':
-            script = None
-
-        parts = language, territory, script, variant
-
-        # First match: try the whole identifier
-        new_id = get_locale_identifier(parts)
-        likely_subtag = get_global('likely_subtags').get(new_id)
-        if likely_subtag is not None:
-            locale = _try_load_reducing(parse_locale(likely_subtag))
-            if locale is not None:
-                return locale
-
-        # If we did not find anything so far, try again with a
-        # simplified identifier that is just the language
-        likely_subtag = get_global('likely_subtags').get(language)
-        if likely_subtag is not None:
-            language2, _, script2, variant2 = parse_locale(likely_subtag)
-            locale = _try_load_reducing((language2, territory, script2, variant2))
-            if locale is not None:
-                return locale
-
-        raise UnknownLocaleError(input_id)
-
-    def __eq__(self, other):
-        for key in ('language', 'territory', 'script', 'variant'):
-            if not hasattr(other, key):
-                return False
-        return (self.language == other.language) and \
-            (self.territory == other.territory) and \
-            (self.script == other.script) and \
-            (self.variant == other.variant)
-
-    def __ne__(self, other):
-        return not self.__eq__(other)
-
-    def __hash__(self):
-        return hash((self.language, self.territory, self.script, self.variant))
-
-    def __repr__(self):
-        parameters = ['']
-        for key in ('territory', 'script', 'variant'):
-            value = getattr(self, key)
-            if value is not None:
-                parameters.append('%s=%r' % (key, value))
-        parameter_string = '%r' % self.language + ', '.join(parameters)
-        return 'Locale(%s)' % parameter_string
-
-    def __str__(self):
-        return get_locale_identifier((self.language, self.territory,
-                                      self.script, self.variant))
-
-    @property
-    def _data(self):
-        if self.__data is None:
-            self.__data = localedata.LocaleDataDict(localedata.load(str(self)))
-        return self.__data
-
-    def get_display_name(self, locale=None):
-        """Return the display name of the locale using the given locale.
-
-        The display name will include the language, territory, script, and
-        variant, if those are specified.
-
-        >>> Locale('zh', 'CN', script='Hans').get_display_name('en')
-        u'Chinese (Simplified, China)'
-
-        :param locale: the locale to use
-        """
-        if locale is None:
-            locale = self
-        locale = Locale.parse(locale)
-        retval = locale.languages.get(self.language)
-        if retval and (self.territory or self.script or self.variant):
-            details = []
-            if self.script:
-                details.append(locale.scripts.get(self.script))
-            if self.territory:
-                details.append(locale.territories.get(self.territory))
-            if self.variant:
-                details.append(locale.variants.get(self.variant))
-            details = filter(None, details)
-            if details:
-                retval += ' (%s)' % u', '.join(details)
-        return retval
-
-    display_name = property(get_display_name, doc="""\
-        The localized display name of the locale.
-
-        >>> Locale('en').display_name
-        u'English'
-        >>> Locale('en', 'US').display_name
-        u'English (United States)'
-        >>> Locale('sv').display_name
-        u'svenska'
-
-        :type: `unicode`
-        """)
-
-    def get_language_name(self, locale=None):
-        """Return the language of this locale in the given locale.
-
-        >>> Locale('zh', 'CN', script='Hans').get_language_name('de')
-        u'Chinesisch'
-
-        .. versionadded:: 1.0
-
-        :param locale: the locale to use
-        """
-        if locale is None:
-            locale = self
-        locale = Locale.parse(locale)
-        return locale.languages.get(self.language)
-
-    language_name = property(get_language_name, doc="""\
-        The localized language name of the locale.
-
-        >>> Locale('en', 'US').language_name
-        u'English'
-    """)
-
-    def get_territory_name(self, locale=None):
-        """Return the territory name in the given locale."""
-        if locale is None:
-            locale = self
-        locale = Locale.parse(locale)
-        return locale.territories.get(self.territory)
-
-    territory_name = property(get_territory_name, doc="""\
-        The localized territory name of the locale if available.
-
-        >>> Locale('de', 'DE').territory_name
-        u'Deutschland'
-    """)
-
-    def get_script_name(self, locale=None):
-        """Return the script name in the given locale."""
-        if locale is None:
-            locale = self
-        locale = Locale.parse(locale)
-        return locale.scripts.get(self.script)
-
-    script_name = property(get_script_name, doc="""\
-        The localized script name of the locale if available.
-
-        >>> Locale('sr', 'ME', script='Latn').script_name
-        u'latinica'
-    """)
-
-    @property
-    def english_name(self):
-        """The english display name of the locale.
-
-        >>> Locale('de').english_name
-        u'German'
-        >>> Locale('de', 'DE').english_name
-        u'German (Germany)'
-
-        :type: `unicode`"""
-        return self.get_display_name(Locale('en'))
-
-    # { General Locale Display Names
-
-    @property
-    def languages(self):
-        """Mapping of language codes to translated language names.
-
-        >>> Locale('de', 'DE').languages['ja']
-        u'Japanisch'
-
-        See `ISO 639 <http://www.loc.gov/standards/iso639-2/>`_ for
-        more information.
-        """
-        return self._data['languages']
-
-    @property
-    def scripts(self):
-        """Mapping of script codes to translated script names.
-
-        >>> Locale('en', 'US').scripts['Hira']
-        u'Hiragana'
-
-        See `ISO 15924 <http://www.evertype.com/standards/iso15924/>`_
-        for more information.
-        """
-        return self._data['scripts']
-
-    @property
-    def territories(self):
-        """Mapping of script codes to translated script names.
-
-        >>> Locale('es', 'CO').territories['DE']
-        u'Alemania'
-
-        See `ISO 3166 <http://www.iso.org/iso/en/prods-services/iso3166ma/>`_
-        for more information.
-        """
-        return self._data['territories']
-
-    @property
-    def variants(self):
-        """Mapping of script codes to translated script names.
-
-        >>> Locale('de', 'DE').variants['1901']
-        u'Alte deutsche Rechtschreibung'
-        """
-        return self._data['variants']
-
-    # { Number Formatting
-
-    @property
-    def currencies(self):
-        """Mapping of currency codes to translated currency names.  This
-        only returns the generic form of the currency name, not the count
-        specific one.  If an actual number is requested use the
-        :func:`babel.numbers.get_currency_name` function.
-
-        >>> Locale('en').currencies['COP']
-        u'Colombian Peso'
-        >>> Locale('de', 'DE').currencies['COP']
-        u'Kolumbianischer Peso'
-        """
-        return self._data['currency_names']
-
-    @property
-    def currency_symbols(self):
-        """Mapping of currency codes to symbols.
-
-        >>> Locale('en', 'US').currency_symbols['USD']
-        u'$'
-        >>> Locale('es', 'CO').currency_symbols['USD']
-        u'US$'
-        """
-        return self._data['currency_symbols']
-
-    @property
-    def number_symbols(self):
-        """Symbols used in number formatting.
-
-        .. note:: The format of the value returned may change between
-                  Babel versions.
-
-        >>> Locale('fr', 'FR').number_symbols['decimal']
-        u','
-        """
-        return self._data['number_symbols']
-
-    @property
-    def decimal_formats(self):
-        """Locale patterns for decimal number formatting.
-
-        .. note:: The format of the value returned may change between
-                  Babel versions.
-
-        >>> Locale('en', 'US').decimal_formats[None]
-        <NumberPattern u'#,##0.###'>
-        """
-        return self._data['decimal_formats']
-
-    @property
-    def currency_formats(self):
-        """Locale patterns for currency number formatting.
-
-        .. note:: The format of the value returned may change between
-                  Babel versions.
-
-        >>> Locale('en', 'US').currency_formats['standard']
-        <NumberPattern u'\\xa4#,##0.00'>
-        >>> Locale('en', 'US').currency_formats['accounting']
-        <NumberPattern u'\\xa4#,##0.00;(\\xa4#,##0.00)'>
-        """
-        return self._data['currency_formats']
-
-    @property
-    def percent_formats(self):
-        """Locale patterns for percent number formatting.
-
-        .. note:: The format of the value returned may change between
-                  Babel versions.
-
-        >>> Locale('en', 'US').percent_formats[None]
-        <NumberPattern u'#,##0%'>
-        """
-        return self._data['percent_formats']
-
-    @property
-    def scientific_formats(self):
-        """Locale patterns for scientific number formatting.
-
-        .. note:: The format of the value returned may change between
-                  Babel versions.
-
-        >>> Locale('en', 'US').scientific_formats[None]
-        <NumberPattern u'#E0'>
-        """
-        return self._data['scientific_formats']
-
-    # { Calendar Information and Date Formatting
-
-    @property
-    def periods(self):
-        """Locale display names for day periods (AM/PM).
-
-        >>> Locale('en', 'US').periods['am']
-        u'AM'
-        """
-        try:
-            return self._data['day_periods']['stand-alone']['wide']
-        except KeyError:
-            return {}
-
-    @property
-    def day_periods(self):
-        """Locale display names for various day periods (not necessarily only AM/PM).
-
-        These are not meant to be used without the relevant `day_period_rules`.
-        """
-        return self._data['day_periods']
-
-    @property
-    def day_period_rules(self):
-        """Day period rules for the locale.  Used by `get_period_id`.
-        """
-        return self._data.get('day_period_rules', {})
-
-    @property
-    def days(self):
-        """Locale display names for weekdays.
-
-        >>> Locale('de', 'DE').days['format']['wide'][3]
-        u'Donnerstag'
-        """
-        return self._data['days']
-
-    @property
-    def months(self):
-        """Locale display names for months.
-
-        >>> Locale('de', 'DE').months['format']['wide'][10]
-        u'Oktober'
-        """
-        return self._data['months']
-
-    @property
-    def quarters(self):
-        """Locale display names for quarters.
-
-        >>> Locale('de', 'DE').quarters['format']['wide'][1]
-        u'1. Quartal'
-        """
-        return self._data['quarters']
-
-    @property
-    def eras(self):
-        """Locale display names for eras.
-
-        .. note:: The format of the value returned may change between
-                  Babel versions.
-
-        >>> Locale('en', 'US').eras['wide'][1]
-        u'Anno Domini'
-        >>> Locale('en', 'US').eras['abbreviated'][0]
-        u'BC'
-        """
-        return self._data['eras']
-
-    @property
-    def time_zones(self):
-        """Locale display names for time zones.
-
-        .. note:: The format of the value returned may change between
-                  Babel versions.
-
-        >>> Locale('en', 'US').time_zones['Europe/London']['long']['daylight']
-        u'British Summer Time'
-        >>> Locale('en', 'US').time_zones['America/St_Johns']['city']
-        u'St. John\u2019s'
-        """
-        return self._data['time_zones']
-
-    @property
-    def meta_zones(self):
-        """Locale display names for meta time zones.
-
-        Meta time zones are basically groups of different Olson time zones that
-        have the same GMT offset and daylight savings time.
-
-        .. note:: The format of the value returned may change between
-                  Babel versions.
-
-        >>> Locale('en', 'US').meta_zones['Europe_Central']['long']['daylight']
-        u'Central European Summer Time'
-
-        .. versionadded:: 0.9
-        """
-        return self._data['meta_zones']
-
-    @property
-    def zone_formats(self):
-        """Patterns related to the formatting of time zones.
-
-        .. note:: The format of the value returned may change between
-                  Babel versions.
-
-        >>> Locale('en', 'US').zone_formats['fallback']
-        u'%(1)s (%(0)s)'
-        >>> Locale('pt', 'BR').zone_formats['region']
-        u'Hor\\xe1rio %s'
-
-        .. versionadded:: 0.9
-        """
-        return self._data['zone_formats']
-
-    @property
-    def first_week_day(self):
-        """The first day of a week, with 0 being Monday.
-
-        >>> Locale('de', 'DE').first_week_day
-        0
-        >>> Locale('en', 'US').first_week_day
-        6
-        """
-        return self._data['week_data']['first_day']
-
-    @property
-    def weekend_start(self):
-        """The day the weekend starts, with 0 being Monday.
-
-        >>> Locale('de', 'DE').weekend_start
-        5
-        """
-        return self._data['week_data']['weekend_start']
-
-    @property
-    def weekend_end(self):
-        """The day the weekend ends, with 0 being Monday.
-
-        >>> Locale('de', 'DE').weekend_end
-        6
-        """
-        return self._data['week_data']['weekend_end']
-
-    @property
-    def min_week_days(self):
-        """The minimum number of days in a week so that the week is counted as
-        the first week of a year or month.
-
-        >>> Locale('de', 'DE').min_week_days
-        4
-        """
-        return self._data['week_data']['min_days']
-
-    @property
-    def date_formats(self):
-        """Locale patterns for date formatting.
-
-        .. note:: The format of the value returned may change between
-                  Babel versions.
-
-        >>> Locale('en', 'US').date_formats['short']
-        <DateTimePattern u'M/d/yy'>
-        >>> Locale('fr', 'FR').date_formats['long']
-        <DateTimePattern u'd MMMM y'>
-        """
-        return self._data['date_formats']
-
-    @property
-    def time_formats(self):
-        """Locale patterns for time formatting.
-
-        .. note:: The format of the value returned may change between
-                  Babel versions.
-
-        >>> Locale('en', 'US').time_formats['short']
-        <DateTimePattern u'h:mm a'>
-        >>> Locale('fr', 'FR').time_formats['long']
-        <DateTimePattern u'HH:mm:ss z'>
-        """
-        return self._data['time_formats']
-
-    @property
-    def datetime_formats(self):
-        """Locale patterns for datetime formatting.
-
-        .. note:: The format of the value returned may change between
-                  Babel versions.
-
-        >>> Locale('en').datetime_formats['full']
-        u"{1} 'at' {0}"
-        >>> Locale('th').datetime_formats['medium']
-        u'{1} {0}'
-        """
-        return self._data['datetime_formats']
-
-    @property
-    def datetime_skeletons(self):
-        """Locale patterns for formatting parts of a datetime.
-
-        >>> Locale('en').datetime_skeletons['MEd']
-        <DateTimePattern u'E, M/d'>
-        >>> Locale('fr').datetime_skeletons['MEd']
-        <DateTimePattern u'E dd/MM'>
-        >>> Locale('fr').datetime_skeletons['H']
-        <DateTimePattern u"HH 'h'">
-        """
-        return self._data['datetime_skeletons']
-
-    @property
-    def interval_formats(self):
-        """Locale patterns for interval formatting.
-
-        .. note:: The format of the value returned may change between
-                  Babel versions.
-
-        How to format date intervals in Finnish when the day is the
-        smallest changing component:
-
-        >>> Locale('fi_FI').interval_formats['MEd']['d']
-        [u'E d. \u2013 ', u'E d.M.']
-
-        .. seealso::
-
-           The primary API to use this data is :py:func:`babel.dates.format_interval`.
-
-
-        :rtype: dict[str, dict[str, list[str]]]
-        """
-        return self._data['interval_formats']
-
-    @property
-    def plural_form(self):
-        """Plural rules for the locale.
-
-        >>> Locale('en').plural_form(1)
-        'one'
-        >>> Locale('en').plural_form(0)
-        'other'
-        >>> Locale('fr').plural_form(0)
-        'one'
-        >>> Locale('ru').plural_form(100)
-        'many'
-        """
-        return self._data.get('plural_form', _default_plural_rule)
-
-    @property
-    def list_patterns(self):
-        """Patterns for generating lists
-
-        .. note:: The format of the value returned may change between
-                  Babel versions.
-
-        >>> Locale('en').list_patterns['standard']['start']
-        u'{0}, {1}'
-        >>> Locale('en').list_patterns['standard']['end']
-        u'{0}, and {1}'
-        >>> Locale('en_GB').list_patterns['standard']['end']
-        u'{0} and {1}'
-        """
-        return self._data['list_patterns']
-
-    @property
-    def ordinal_form(self):
-        """Plural rules for the locale.
-
-        >>> Locale('en').ordinal_form(1)
-        'one'
-        >>> Locale('en').ordinal_form(2)
-        'two'
-        >>> Locale('en').ordinal_form(3)
-        'few'
-        >>> Locale('fr').ordinal_form(2)
-        'other'
-        >>> Locale('ru').ordinal_form(100)
-        'other'
-        """
-        return self._data.get('ordinal_form', _default_plural_rule)
-
-    @property
-    def measurement_systems(self):
-        """Localized names for various measurement systems.
-
-        >>> Locale('fr', 'FR').measurement_systems['US']
-        u'am\\xe9ricain'
-        >>> Locale('en', 'US').measurement_systems['US']
-        u'US'
-
-        """
-        return self._data['measurement_systems']
-
-    @property
-    def character_order(self):
-        """The text direction for the language.
-
-        >>> Locale('de', 'DE').character_order
-        'left-to-right'
-        >>> Locale('ar', 'SA').character_order
-        'right-to-left'
-        """
-        return self._data['character_order']
-
-    @property
-    def text_direction(self):
-        """The text direction for the language in CSS short-hand form.
-
-        >>> Locale('de', 'DE').text_direction
-        'ltr'
-        >>> Locale('ar', 'SA').text_direction
-        'rtl'
-        """
-        return ''.join(word[0] for word in self.character_order.split('-'))
-
-    @property
-    def unit_display_names(self):
-        """Display names for units of measurement.
-
-        .. seealso::
-
-           You may want to use :py:func:`babel.units.get_unit_name` instead.
-
-        .. note:: The format of the value returned may change between
-                  Babel versions.
-
-        """
-        return self._data['unit_display_names']
-
-
-def default_locale(category=None, aliases=LOCALE_ALIASES):
-    """Returns the system default locale for a given category, based on
-    environment variables.
-
-    >>> for name in ['LANGUAGE', 'LC_ALL', 'LC_CTYPE']:
-    ...     os.environ[name] = ''
-    >>> os.environ['LANG'] = 'fr_FR.UTF-8'
-    >>> default_locale('LC_MESSAGES')
-    'fr_FR'
-
-    The "C" or "POSIX" pseudo-locales are treated as aliases for the
-    "en_US_POSIX" locale:
-
-    >>> os.environ['LC_MESSAGES'] = 'POSIX'
-    >>> default_locale('LC_MESSAGES')
-    'en_US_POSIX'
-
-    The following fallbacks to the variable are always considered:
-
-    - ``LANGUAGE``
-    - ``LC_ALL``
-    - ``LC_CTYPE``
-    - ``LANG``
-
-    :param category: one of the ``LC_XXX`` environment variable names
-    :param aliases: a dictionary of aliases for locale identifiers
-    """
-    varnames = (category, 'LANGUAGE', 'LC_ALL', 'LC_CTYPE', 'LANG')
-    for name in filter(None, varnames):
-        locale = os.getenv(name)
-        if locale:
-            if name == 'LANGUAGE' and ':' in locale:
-                # the LANGUAGE variable may contain a colon-separated list of
-                # language codes; we just pick the language on the list
-                locale = locale.split(':')[0]
-            if locale.split('.')[0] in ('C', 'POSIX'):
-                locale = 'en_US_POSIX'
-            elif aliases and locale in aliases:
-                locale = aliases[locale]
-            try:
-                return get_locale_identifier(parse_locale(locale))
-            except ValueError:
-                pass
-
-
-def negotiate_locale(preferred, available, sep='_', aliases=LOCALE_ALIASES):
-    """Find the best match between available and requested locale strings.
-
-    >>> negotiate_locale(['de_DE', 'en_US'], ['de_DE', 'de_AT'])
-    'de_DE'
-    >>> negotiate_locale(['de_DE', 'en_US'], ['en', 'de'])
-    'de'
-
-    Case is ignored by the algorithm, the result uses the case of the preferred
-    locale identifier:
-
-    >>> negotiate_locale(['de_DE', 'en_US'], ['de_de', 'de_at'])
-    'de_DE'
-
-    >>> negotiate_locale(['de_DE', 'en_US'], ['de_de', 'de_at'])
-    'de_DE'
-
-    By default, some web browsers unfortunately do not include the territory
-    in the locale identifier for many locales, and some don't even allow the
-    user to easily add the territory. So while you may prefer using qualified
-    locale identifiers in your web-application, they would not normally match
-    the language-only locale sent by such browsers. To workaround that, this
-    function uses a default mapping of commonly used langauge-only locale
-    identifiers to identifiers including the territory:
-
-    >>> negotiate_locale(['ja', 'en_US'], ['ja_JP', 'en_US'])
-    'ja_JP'
-
-    Some browsers even use an incorrect or outdated language code, such as "no"
-    for Norwegian, where the correct locale identifier would actually be "nb_NO"
-    (Bokmål) or "nn_NO" (Nynorsk). The aliases are intended to take care of
-    such cases, too:
-
-    >>> negotiate_locale(['no', 'sv'], ['nb_NO', 'sv_SE'])
-    'nb_NO'
-
-    You can override this default mapping by passing a different `aliases`
-    dictionary to this function, or you can bypass the behavior althogher by
-    setting the `aliases` parameter to `None`.
-
-    :param preferred: the list of locale strings preferred by the user
-    :param available: the list of locale strings available
-    :param sep: character that separates the different parts of the locale
-                strings
-    :param aliases: a dictionary of aliases for locale identifiers
-    """
-    available = [a.lower() for a in available if a]
-    for locale in preferred:
-        ll = locale.lower()
-        if ll in available:
-            return locale
-        if aliases:
-            alias = aliases.get(ll)
-            if alias:
-                alias = alias.replace('_', sep)
-                if alias.lower() in available:
-                    return alias
-        parts = locale.split(sep)
-        if len(parts) > 1 and parts[0].lower() in available:
-            return parts[0]
-    return None
-
-
-def parse_locale(identifier, sep='_'):
-    """Parse a locale identifier into a tuple of the form ``(language,
-    territory, script, variant)``.
-
-    >>> parse_locale('zh_CN')
-    ('zh', 'CN', None, None)
-    >>> parse_locale('zh_Hans_CN')
-    ('zh', 'CN', 'Hans', None)
-
-    The default component separator is "_", but a different separator can be
-    specified using the `sep` parameter:
-
-    >>> parse_locale('zh-CN', sep='-')
-    ('zh', 'CN', None, None)
-
-    If the identifier cannot be parsed into a locale, a `ValueError` exception
-    is raised:
-
-    >>> parse_locale('not_a_LOCALE_String')
-    Traceback (most recent call last):
-      ...
-    ValueError: 'not_a_LOCALE_String' is not a valid locale identifier
-
-    Encoding information and locale modifiers are removed from the identifier:
-
-    >>> parse_locale('it_IT@euro')
-    ('it', 'IT', None, None)
-    >>> parse_locale('en_US.UTF-8')
-    ('en', 'US', None, None)
-    >>> parse_locale('de_DE.iso885915@euro')
-    ('de', 'DE', None, None)
-
-    See :rfc:`4646` for more information.
-
-    :param identifier: the locale identifier string
-    :param sep: character that separates the different components of the locale
-                identifier
-    :raise `ValueError`: if the string does not appear to be a valid locale
-                         identifier
-    """
-    if '.' in identifier:
-        # this is probably the charset/encoding, which we don't care about
-        identifier = identifier.split('.', 1)[0]
-    if '@' in identifier:
-        # this is a locale modifier such as @euro, which we don't care about
-        # either
-        identifier = identifier.split('@', 1)[0]
-
-    parts = identifier.split(sep)
-    lang = parts.pop(0).lower()
-    if not lang.isalpha():
-        raise ValueError('expected only letters, got %r' % lang)
-
-    script = territory = variant = None
-    if parts:
-        if len(parts[0]) == 4 and parts[0].isalpha():
-            script = parts.pop(0).title()
-
-    if parts:
-        if len(parts[0]) == 2 and parts[0].isalpha():
-            territory = parts.pop(0).upper()
-        elif len(parts[0]) == 3 and parts[0].isdigit():
-            territory = parts.pop(0)
-
-    if parts:
-        if len(parts[0]) == 4 and parts[0][0].isdigit() or \
-                len(parts[0]) >= 5 and parts[0][0].isalpha():
-            variant = parts.pop()
-
-    if parts:
-        raise ValueError('%r is not a valid locale identifier' % identifier)
-
-    return lang, territory, script, variant
-
-
-def get_locale_identifier(tup, sep='_'):
-    """The reverse of :func:`parse_locale`.  It creates a locale identifier out
-    of a ``(language, territory, script, variant)`` tuple.  Items can be set to
-    ``None`` and trailing ``None``\\s can also be left out of the tuple.
-
-    >>> get_locale_identifier(('de', 'DE', None, '1999'))
-    'de_DE_1999'
-
-    .. versionadded:: 1.0
-
-    :param tup: the tuple as returned by :func:`parse_locale`.
-    :param sep: the separator for the identifier.
-    """
-    tup = tuple(tup[:4])
-    lang, territory, script, variant = tup + (None,) * (4 - len(tup))
-    return sep.join(filter(None, (lang, script, territory, variant)))

+ 0 - 1796
desktop/core/ext-py/Babel-2.9.1/babel/dates.py

@@ -1,1796 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    babel.dates
-    ~~~~~~~~~~~
-
-    Locale dependent formatting and parsing of dates and times.
-
-    The default locale for the functions in this module is determined by the
-    following environment variables, in that order:
-
-     * ``LC_TIME``,
-     * ``LC_ALL``, and
-     * ``LANG``
-
-    :copyright: (c) 2013-2021 by the Babel Team.
-    :license: BSD, see LICENSE for more details.
-"""
-
-from __future__ import division
-
-import re
-import warnings
-import pytz as _pytz
-
-from datetime import date, datetime, time, timedelta
-from bisect import bisect_right
-
-from babel.core import default_locale, get_global, Locale
-from babel.util import UTC, LOCALTZ
-from babel._compat import string_types, integer_types, number_types, PY2
-
-# "If a given short metazone form is known NOT to be understood in a given
-#  locale and the parent locale has this value such that it would normally
-#  be inherited, the inheritance of this value can be explicitly disabled by
-#  use of the 'no inheritance marker' as the value, which is 3 simultaneous [sic]
-#  empty set characters ( U+2205 )."
-#  - https://www.unicode.org/reports/tr35/tr35-dates.html#Metazone_Names
-
-NO_INHERITANCE_MARKER = u'\u2205\u2205\u2205'
-
-
-LC_TIME = default_locale('LC_TIME')
-
-# Aliases for use in scopes where the modules are shadowed by local variables
-date_ = date
-datetime_ = datetime
-time_ = time
-
-
-def _get_dt_and_tzinfo(dt_or_tzinfo):
-    """
-    Parse a `dt_or_tzinfo` value into a datetime and a tzinfo.
-
-    See the docs for this function's callers for semantics.
-
-    :rtype: tuple[datetime, tzinfo]
-    """
-    if dt_or_tzinfo is None:
-        dt = datetime.now()
-        tzinfo = LOCALTZ
-    elif isinstance(dt_or_tzinfo, string_types):
-        dt = None
-        tzinfo = get_timezone(dt_or_tzinfo)
-    elif isinstance(dt_or_tzinfo, integer_types):
-        dt = None
-        tzinfo = UTC
-    elif isinstance(dt_or_tzinfo, (datetime, time)):
-        dt = _get_datetime(dt_or_tzinfo)
-        if dt.tzinfo is not None:
-            tzinfo = dt.tzinfo
-        else:
-            tzinfo = UTC
-    else:
-        dt = None
-        tzinfo = dt_or_tzinfo
-    return dt, tzinfo
-
-
-def _get_tz_name(dt_or_tzinfo):
-    """
-    Get the timezone name out of a time, datetime, or tzinfo object.
-
-    :rtype: str
-    """
-    dt, tzinfo = _get_dt_and_tzinfo(dt_or_tzinfo)
-    if hasattr(tzinfo, 'zone'):  # pytz object
-        return tzinfo.zone
-    elif hasattr(tzinfo, 'key') and tzinfo.key is not None:  # ZoneInfo object
-        return tzinfo.key
-    else:
-        return tzinfo.tzname(dt or datetime.utcnow())
-
-
-def _get_datetime(instant):
-    """
-    Get a datetime out of an "instant" (date, time, datetime, number).
-
-    .. warning:: The return values of this function may depend on the system clock.
-
-    If the instant is None, the current moment is used.
-    If the instant is a time, it's augmented with today's date.
-
-    Dates are converted to naive datetimes with midnight as the time component.
-
-    >>> _get_datetime(date(2015, 1, 1))
-    datetime.datetime(2015, 1, 1, 0, 0)
-
-    UNIX timestamps are converted to datetimes.
-
-    >>> _get_datetime(1400000000)
-    datetime.datetime(2014, 5, 13, 16, 53, 20)
-
-    Other values are passed through as-is.
-
-    >>> x = datetime(2015, 1, 1)
-    >>> _get_datetime(x) is x
-    True
-
-    :param instant: date, time, datetime, integer, float or None
-    :type instant: date|time|datetime|int|float|None
-    :return: a datetime
-    :rtype: datetime
-    """
-    if instant is None:
-        return datetime_.utcnow()
-    elif isinstance(instant, integer_types) or isinstance(instant, float):
-        return datetime_.utcfromtimestamp(instant)
-    elif isinstance(instant, time):
-        return datetime_.combine(date.today(), instant)
-    elif isinstance(instant, date) and not isinstance(instant, datetime):
-        return datetime_.combine(instant, time())
-    # TODO (3.x): Add an assertion/type check for this fallthrough branch:
-    return instant
-
-
-def _ensure_datetime_tzinfo(datetime, tzinfo=None):
-    """
-    Ensure the datetime passed has an attached tzinfo.
-
-    If the datetime is tz-naive to begin with, UTC is attached.
-
-    If a tzinfo is passed in, the datetime is normalized to that timezone.
-
-    >>> _ensure_datetime_tzinfo(datetime(2015, 1, 1)).tzinfo.zone
-    'UTC'
-
-    >>> tz = get_timezone("Europe/Stockholm")
-    >>> _ensure_datetime_tzinfo(datetime(2015, 1, 1, 13, 15, tzinfo=UTC), tzinfo=tz).hour
-    14
-
-    :param datetime: Datetime to augment.
-    :param tzinfo: Optional tznfo.
-    :return: datetime with tzinfo
-    :rtype: datetime
-    """
-    if datetime.tzinfo is None:
-        datetime = datetime.replace(tzinfo=UTC)
-    if tzinfo is not None:
-        datetime = datetime.astimezone(get_timezone(tzinfo))
-        if hasattr(tzinfo, 'normalize'):  # pytz
-            datetime = tzinfo.normalize(datetime)
-    return datetime
-
-
-def _get_time(time, tzinfo=None):
-    """
-    Get a timezoned time from a given instant.
-
-    .. warning:: The return values of this function may depend on the system clock.
-
-    :param time: time, datetime or None
-    :rtype: time
-    """
-    if time is None:
-        time = datetime.utcnow()
-    elif isinstance(time, number_types):
-        time = datetime.utcfromtimestamp(time)
-    if time.tzinfo is None:
-        time = time.replace(tzinfo=UTC)
-    if isinstance(time, datetime):
-        if tzinfo is not None:
-            time = time.astimezone(tzinfo)
-            if hasattr(tzinfo, 'normalize'):  # pytz
-                time = tzinfo.normalize(time)
-        time = time.timetz()
-    elif tzinfo is not None:
-        time = time.replace(tzinfo=tzinfo)
-    return time
-
-
-def get_timezone(zone=None):
-    """Looks up a timezone by name and returns it.  The timezone object
-    returned comes from ``pytz`` and corresponds to the `tzinfo` interface and
-    can be used with all of the functions of Babel that operate with dates.
-
-    If a timezone is not known a :exc:`LookupError` is raised.  If `zone`
-    is ``None`` a local zone object is returned.
-
-    :param zone: the name of the timezone to look up.  If a timezone object
-                 itself is passed in, mit's returned unchanged.
-    """
-    if zone is None:
-        return LOCALTZ
-    if not isinstance(zone, string_types):
-        return zone
-    try:
-        return _pytz.timezone(zone)
-    except _pytz.UnknownTimeZoneError:
-        raise LookupError('Unknown timezone %s' % zone)
-
-
-def get_next_timezone_transition(zone=None, dt=None):
-    """Given a timezone it will return a :class:`TimezoneTransition` object
-    that holds the information about the next timezone transition that's going
-    to happen.  For instance this can be used to detect when the next DST
-    change is going to happen and how it looks like.
-
-    The transition is calculated relative to the given datetime object.  The
-    next transition that follows the date is used.  If a transition cannot
-    be found the return value will be `None`.
-
-    Transition information can only be provided for timezones returned by
-    the :func:`get_timezone` function.
-
-    :param zone: the timezone for which the transition should be looked up.
-                 If not provided the local timezone is used.
-    :param dt: the date after which the next transition should be found.
-               If not given the current time is assumed.
-    """
-    zone = get_timezone(zone)
-    dt = _get_datetime(dt).replace(tzinfo=None)
-
-    if not hasattr(zone, '_utc_transition_times'):
-        raise TypeError('Given timezone does not have UTC transition '
-                        'times.  This can happen because the operating '
-                        'system fallback local timezone is used or a '
-                        'custom timezone object')
-
-    try:
-        idx = max(0, bisect_right(zone._utc_transition_times, dt))
-        old_trans = zone._transition_info[idx - 1]
-        new_trans = zone._transition_info[idx]
-        old_tz = zone._tzinfos[old_trans]
-        new_tz = zone._tzinfos[new_trans]
-    except (LookupError, ValueError):
-        return None
-
-    return TimezoneTransition(
-        activates=zone._utc_transition_times[idx],
-        from_tzinfo=old_tz,
-        to_tzinfo=new_tz,
-        reference_date=dt
-    )
-
-
-class TimezoneTransition(object):
-    """A helper object that represents the return value from
-    :func:`get_next_timezone_transition`.
-    """
-
-    def __init__(self, activates, from_tzinfo, to_tzinfo, reference_date=None):
-        #: the time of the activation of the timezone transition in UTC.
-        self.activates = activates
-        #: the timezone from where the transition starts.
-        self.from_tzinfo = from_tzinfo
-        #: the timezone for after the transition.
-        self.to_tzinfo = to_tzinfo
-        #: the reference date that was provided.  This is the `dt` parameter
-        #: to the :func:`get_next_timezone_transition`.
-        self.reference_date = reference_date
-
-    @property
-    def from_tz(self):
-        """The name of the timezone before the transition."""
-        return self.from_tzinfo._tzname
-
-    @property
-    def to_tz(self):
-        """The name of the timezone after the transition."""
-        return self.to_tzinfo._tzname
-
-    @property
-    def from_offset(self):
-        """The UTC offset in seconds before the transition."""
-        return int(self.from_tzinfo._utcoffset.total_seconds())
-
-    @property
-    def to_offset(self):
-        """The UTC offset in seconds after the transition."""
-        return int(self.to_tzinfo._utcoffset.total_seconds())
-
-    def __repr__(self):
-        return '<TimezoneTransition %s -> %s (%s)>' % (
-            self.from_tz,
-            self.to_tz,
-            self.activates,
-        )
-
-
-def get_period_names(width='wide', context='stand-alone', locale=LC_TIME):
-    """Return the names for day periods (AM/PM) used by the locale.
-
-    >>> get_period_names(locale='en_US')['am']
-    u'AM'
-
-    :param width: the width to use, one of "abbreviated", "narrow", or "wide"
-    :param context: the context, either "format" or "stand-alone"
-    :param locale: the `Locale` object, or a locale string
-    """
-    return Locale.parse(locale).day_periods[context][width]
-
-
-def get_day_names(width='wide', context='format', locale=LC_TIME):
-    """Return the day names used by the locale for the specified format.
-
-    >>> get_day_names('wide', locale='en_US')[1]
-    u'Tuesday'
-    >>> get_day_names('short', locale='en_US')[1]
-    u'Tu'
-    >>> get_day_names('abbreviated', locale='es')[1]
-    u'mar.'
-    >>> get_day_names('narrow', context='stand-alone', locale='de_DE')[1]
-    u'D'
-
-    :param width: the width to use, one of "wide", "abbreviated", "short" or "narrow"
-    :param context: the context, either "format" or "stand-alone"
-    :param locale: the `Locale` object, or a locale string
-    """
-    return Locale.parse(locale).days[context][width]
-
-
-def get_month_names(width='wide', context='format', locale=LC_TIME):
-    """Return the month names used by the locale for the specified format.
-
-    >>> get_month_names('wide', locale='en_US')[1]
-    u'January'
-    >>> get_month_names('abbreviated', locale='es')[1]
-    u'ene.'
-    >>> get_month_names('narrow', context='stand-alone', locale='de_DE')[1]
-    u'J'
-
-    :param width: the width to use, one of "wide", "abbreviated", or "narrow"
-    :param context: the context, either "format" or "stand-alone"
-    :param locale: the `Locale` object, or a locale string
-    """
-    return Locale.parse(locale).months[context][width]
-
-
-def get_quarter_names(width='wide', context='format', locale=LC_TIME):
-    """Return the quarter names used by the locale for the specified format.
-
-    >>> get_quarter_names('wide', locale='en_US')[1]
-    u'1st quarter'
-    >>> get_quarter_names('abbreviated', locale='de_DE')[1]
-    u'Q1'
-    >>> get_quarter_names('narrow', locale='de_DE')[1]
-    u'1'
-
-    :param width: the width to use, one of "wide", "abbreviated", or "narrow"
-    :param context: the context, either "format" or "stand-alone"
-    :param locale: the `Locale` object, or a locale string
-    """
-    return Locale.parse(locale).quarters[context][width]
-
-
-def get_era_names(width='wide', locale=LC_TIME):
-    """Return the era names used by the locale for the specified format.
-
-    >>> get_era_names('wide', locale='en_US')[1]
-    u'Anno Domini'
-    >>> get_era_names('abbreviated', locale='de_DE')[1]
-    u'n. Chr.'
-
-    :param width: the width to use, either "wide", "abbreviated", or "narrow"
-    :param locale: the `Locale` object, or a locale string
-    """
-    return Locale.parse(locale).eras[width]
-
-
-def get_date_format(format='medium', locale=LC_TIME):
-    """Return the date formatting patterns used by the locale for the specified
-    format.
-
-    >>> get_date_format(locale='en_US')
-    <DateTimePattern u'MMM d, y'>
-    >>> get_date_format('full', locale='de_DE')
-    <DateTimePattern u'EEEE, d. MMMM y'>
-
-    :param format: the format to use, one of "full", "long", "medium", or
-                   "short"
-    :param locale: the `Locale` object, or a locale string
-    """
-    return Locale.parse(locale).date_formats[format]
-
-
-def get_datetime_format(format='medium', locale=LC_TIME):
-    """Return the datetime formatting patterns used by the locale for the
-    specified format.
-
-    >>> get_datetime_format(locale='en_US')
-    u'{1}, {0}'
-
-    :param format: the format to use, one of "full", "long", "medium", or
-                   "short"
-    :param locale: the `Locale` object, or a locale string
-    """
-    patterns = Locale.parse(locale).datetime_formats
-    if format not in patterns:
-        format = None
-    return patterns[format]
-
-
-def get_time_format(format='medium', locale=LC_TIME):
-    """Return the time formatting patterns used by the locale for the specified
-    format.
-
-    >>> get_time_format(locale='en_US')
-    <DateTimePattern u'h:mm:ss a'>
-    >>> get_time_format('full', locale='de_DE')
-    <DateTimePattern u'HH:mm:ss zzzz'>
-
-    :param format: the format to use, one of "full", "long", "medium", or
-                   "short"
-    :param locale: the `Locale` object, or a locale string
-    """
-    return Locale.parse(locale).time_formats[format]
-
-
-def get_timezone_gmt(datetime=None, width='long', locale=LC_TIME, return_z=False):
-    """Return the timezone associated with the given `datetime` object formatted
-    as string indicating the offset from GMT.
-
-    >>> dt = datetime(2007, 4, 1, 15, 30)
-    >>> get_timezone_gmt(dt, locale='en')
-    u'GMT+00:00'
-    >>> get_timezone_gmt(dt, locale='en', return_z=True)
-    'Z'
-    >>> get_timezone_gmt(dt, locale='en', width='iso8601_short')
-    u'+00'
-    >>> tz = get_timezone('America/Los_Angeles')
-    >>> dt = tz.localize(datetime(2007, 4, 1, 15, 30))
-    >>> get_timezone_gmt(dt, locale='en')
-    u'GMT-07:00'
-    >>> get_timezone_gmt(dt, 'short', locale='en')
-    u'-0700'
-    >>> get_timezone_gmt(dt, locale='en', width='iso8601_short')
-    u'-07'
-
-    The long format depends on the locale, for example in France the acronym
-    UTC string is used instead of GMT:
-
-    >>> get_timezone_gmt(dt, 'long', locale='fr_FR')
-    u'UTC-07:00'
-
-    .. versionadded:: 0.9
-
-    :param datetime: the ``datetime`` object; if `None`, the current date and
-                     time in UTC is used
-    :param width: either "long" or "short" or "iso8601" or "iso8601_short"
-    :param locale: the `Locale` object, or a locale string
-    :param return_z: True or False; Function returns indicator "Z"
-                     when local time offset is 0
-    """
-    datetime = _ensure_datetime_tzinfo(_get_datetime(datetime))
-    locale = Locale.parse(locale)
-
-    offset = datetime.tzinfo.utcoffset(datetime)
-    seconds = offset.days * 24 * 60 * 60 + offset.seconds
-    hours, seconds = divmod(seconds, 3600)
-    if return_z and hours == 0 and seconds == 0:
-        return 'Z'
-    elif seconds == 0 and width == 'iso8601_short':
-        return u'%+03d' % hours
-    elif width == 'short' or width == 'iso8601_short':
-        pattern = u'%+03d%02d'
-    elif width == 'iso8601':
-        pattern = u'%+03d:%02d'
-    else:
-        pattern = locale.zone_formats['gmt'] % '%+03d:%02d'
-    return pattern % (hours, seconds // 60)
-
-
-def get_timezone_location(dt_or_tzinfo=None, locale=LC_TIME, return_city=False):
-    u"""Return a representation of the given timezone using "location format".
-
-    The result depends on both the local display name of the country and the
-    city associated with the time zone:
-
-    >>> tz = get_timezone('America/St_Johns')
-    >>> print(get_timezone_location(tz, locale='de_DE'))
-    Kanada (St. John’s) Zeit
-    >>> print(get_timezone_location(tz, locale='en'))
-    Canada (St. John’s) Time
-    >>> print(get_timezone_location(tz, locale='en', return_city=True))
-    St. John’s
-    >>> tz = get_timezone('America/Mexico_City')
-    >>> get_timezone_location(tz, locale='de_DE')
-    u'Mexiko (Mexiko-Stadt) Zeit'
-
-    If the timezone is associated with a country that uses only a single
-    timezone, just the localized country name is returned:
-
-    >>> tz = get_timezone('Europe/Berlin')
-    >>> get_timezone_name(tz, locale='de_DE')
-    u'Mitteleurop\\xe4ische Zeit'
-
-    .. versionadded:: 0.9
-
-    :param dt_or_tzinfo: the ``datetime`` or ``tzinfo`` object that determines
-                         the timezone; if `None`, the current date and time in
-                         UTC is assumed
-    :param locale: the `Locale` object, or a locale string
-    :param return_city: True or False, if True then return exemplar city (location)
-                        for the time zone
-    :return: the localized timezone name using location format
-
-    """
-    locale = Locale.parse(locale)
-
-    zone = _get_tz_name(dt_or_tzinfo)
-
-    # Get the canonical time-zone code
-    zone = get_global('zone_aliases').get(zone, zone)
-
-    info = locale.time_zones.get(zone, {})
-
-    # Otherwise, if there is only one timezone for the country, return the
-    # localized country name
-    region_format = locale.zone_formats['region']
-    territory = get_global('zone_territories').get(zone)
-    if territory not in locale.territories:
-        territory = 'ZZ'  # invalid/unknown
-    territory_name = locale.territories[territory]
-    if not return_city and territory and len(get_global('territory_zones').get(territory, [])) == 1:
-        return region_format % territory_name
-
-    # Otherwise, include the city in the output
-    fallback_format = locale.zone_formats['fallback']
-    if 'city' in info:
-        city_name = info['city']
-    else:
-        metazone = get_global('meta_zones').get(zone)
-        metazone_info = locale.meta_zones.get(metazone, {})
-        if 'city' in metazone_info:
-            city_name = metazone_info['city']
-        elif '/' in zone:
-            city_name = zone.split('/', 1)[1].replace('_', ' ')
-        else:
-            city_name = zone.replace('_', ' ')
-
-    if return_city:
-        return city_name
-    return region_format % (fallback_format % {
-        '0': city_name,
-        '1': territory_name
-    })
-
-
-def get_timezone_name(dt_or_tzinfo=None, width='long', uncommon=False,
-                      locale=LC_TIME, zone_variant=None, return_zone=False):
-    r"""Return the localized display name for the given timezone. The timezone
-    may be specified using a ``datetime`` or `tzinfo` object.
-
-    >>> dt = time(15, 30, tzinfo=get_timezone('America/Los_Angeles'))
-    >>> get_timezone_name(dt, locale='en_US')
-    u'Pacific Standard Time'
-    >>> get_timezone_name(dt, locale='en_US', return_zone=True)
-    'America/Los_Angeles'
-    >>> get_timezone_name(dt, width='short', locale='en_US')
-    u'PST'
-
-    If this function gets passed only a `tzinfo` object and no concrete
-    `datetime`,  the returned display name is indenpendent of daylight savings
-    time. This can be used for example for selecting timezones, or to set the
-    time of events that recur across DST changes:
-
-    >>> tz = get_timezone('America/Los_Angeles')
-    >>> get_timezone_name(tz, locale='en_US')
-    u'Pacific Time'
-    >>> get_timezone_name(tz, 'short', locale='en_US')
-    u'PT'
-
-    If no localized display name for the timezone is available, and the timezone
-    is associated with a country that uses only a single timezone, the name of
-    that country is returned, formatted according to the locale:
-
-    >>> tz = get_timezone('Europe/Berlin')
-    >>> get_timezone_name(tz, locale='de_DE')
-    u'Mitteleurop\xe4ische Zeit'
-    >>> get_timezone_name(tz, locale='pt_BR')
-    u'Hor\xe1rio da Europa Central'
-
-    On the other hand, if the country uses multiple timezones, the city is also
-    included in the representation:
-
-    >>> tz = get_timezone('America/St_Johns')
-    >>> get_timezone_name(tz, locale='de_DE')
-    u'Neufundland-Zeit'
-
-    Note that short format is currently not supported for all timezones and
-    all locales.  This is partially because not every timezone has a short
-    code in every locale.  In that case it currently falls back to the long
-    format.
-
-    For more information see `LDML Appendix J: Time Zone Display Names
-    <https://www.unicode.org/reports/tr35/#Time_Zone_Fallback>`_
-
-    .. versionadded:: 0.9
-
-    .. versionchanged:: 1.0
-       Added `zone_variant` support.
-
-    :param dt_or_tzinfo: the ``datetime`` or ``tzinfo`` object that determines
-                         the timezone; if a ``tzinfo`` object is used, the
-                         resulting display name will be generic, i.e.
-                         independent of daylight savings time; if `None`, the
-                         current date in UTC is assumed
-    :param width: either "long" or "short"
-    :param uncommon: deprecated and ignored
-    :param zone_variant: defines the zone variation to return.  By default the
-                           variation is defined from the datetime object
-                           passed in.  If no datetime object is passed in, the
-                           ``'generic'`` variation is assumed.  The following
-                           values are valid: ``'generic'``, ``'daylight'`` and
-                           ``'standard'``.
-    :param locale: the `Locale` object, or a locale string
-    :param return_zone: True or False. If true then function
-                        returns long time zone ID
-    """
-    dt, tzinfo = _get_dt_and_tzinfo(dt_or_tzinfo)
-    locale = Locale.parse(locale)
-
-    zone = _get_tz_name(dt_or_tzinfo)
-
-    if zone_variant is None:
-        if dt is None:
-            zone_variant = 'generic'
-        else:
-            dst = tzinfo.dst(dt)
-            if dst:
-                zone_variant = 'daylight'
-            else:
-                zone_variant = 'standard'
-    else:
-        if zone_variant not in ('generic', 'standard', 'daylight'):
-            raise ValueError('Invalid zone variation')
-
-    # Get the canonical time-zone code
-    zone = get_global('zone_aliases').get(zone, zone)
-    if return_zone:
-        return zone
-    info = locale.time_zones.get(zone, {})
-    # Try explicitly translated zone names first
-    if width in info:
-        if zone_variant in info[width]:
-            return info[width][zone_variant]
-
-    metazone = get_global('meta_zones').get(zone)
-    if metazone:
-        metazone_info = locale.meta_zones.get(metazone, {})
-        if width in metazone_info:
-            name = metazone_info[width].get(zone_variant)
-            if width == 'short' and name == NO_INHERITANCE_MARKER:
-                # If the short form is marked no-inheritance,
-                # try to fall back to the long name instead.
-                name = metazone_info.get('long', {}).get(zone_variant)
-            if name:
-                return name
-
-    # If we have a concrete datetime, we assume that the result can't be
-    # independent of daylight savings time, so we return the GMT offset
-    if dt is not None:
-        return get_timezone_gmt(dt, width=width, locale=locale)
-
-    return get_timezone_location(dt_or_tzinfo, locale=locale)
-
-
-def format_date(date=None, format='medium', locale=LC_TIME):
-    """Return a date formatted according to the given pattern.
-
-    >>> d = date(2007, 4, 1)
-    >>> format_date(d, locale='en_US')
-    u'Apr 1, 2007'
-    >>> format_date(d, format='full', locale='de_DE')
-    u'Sonntag, 1. April 2007'
-
-    If you don't want to use the locale default formats, you can specify a
-    custom date pattern:
-
-    >>> format_date(d, "EEE, MMM d, ''yy", locale='en')
-    u"Sun, Apr 1, '07"
-
-    :param date: the ``date`` or ``datetime`` object; if `None`, the current
-                 date is used
-    :param format: one of "full", "long", "medium", or "short", or a custom
-                   date/time pattern
-    :param locale: a `Locale` object or a locale identifier
-    """
-    if date is None:
-        date = date_.today()
-    elif isinstance(date, datetime):
-        date = date.date()
-
-    locale = Locale.parse(locale)
-    if format in ('full', 'long', 'medium', 'short'):
-        format = get_date_format(format, locale=locale)
-    pattern = parse_pattern(format)
-    return pattern.apply(date, locale)
-
-
-def format_datetime(datetime=None, format='medium', tzinfo=None,
-                    locale=LC_TIME):
-    r"""Return a date formatted according to the given pattern.
-
-    >>> dt = datetime(2007, 4, 1, 15, 30)
-    >>> format_datetime(dt, locale='en_US')
-    u'Apr 1, 2007, 3:30:00 PM'
-
-    For any pattern requiring the display of the time-zone, the third-party
-    ``pytz`` package is needed to explicitly specify the time-zone:
-
-    >>> format_datetime(dt, 'full', tzinfo=get_timezone('Europe/Paris'),
-    ...                 locale='fr_FR')
-    u'dimanche 1 avril 2007 \xe0 17:30:00 heure d\u2019\xe9t\xe9 d\u2019Europe centrale'
-    >>> format_datetime(dt, "yyyy.MM.dd G 'at' HH:mm:ss zzz",
-    ...                 tzinfo=get_timezone('US/Eastern'), locale='en')
-    u'2007.04.01 AD at 11:30:00 EDT'
-
-    :param datetime: the `datetime` object; if `None`, the current date and
-                     time is used
-    :param format: one of "full", "long", "medium", or "short", or a custom
-                   date/time pattern
-    :param tzinfo: the timezone to apply to the time for display
-    :param locale: a `Locale` object or a locale identifier
-    """
-    datetime = _ensure_datetime_tzinfo(_get_datetime(datetime), tzinfo)
-
-    locale = Locale.parse(locale)
-    if format in ('full', 'long', 'medium', 'short'):
-        return get_datetime_format(format, locale=locale) \
-            .replace("'", "") \
-            .replace('{0}', format_time(datetime, format, tzinfo=None,
-                                        locale=locale)) \
-            .replace('{1}', format_date(datetime, format, locale=locale))
-    else:
-        return parse_pattern(format).apply(datetime, locale)
-
-
-def format_time(time=None, format='medium', tzinfo=None, locale=LC_TIME):
-    r"""Return a time formatted according to the given pattern.
-
-    >>> t = time(15, 30)
-    >>> format_time(t, locale='en_US')
-    u'3:30:00 PM'
-    >>> format_time(t, format='short', locale='de_DE')
-    u'15:30'
-
-    If you don't want to use the locale default formats, you can specify a
-    custom time pattern:
-
-    >>> format_time(t, "hh 'o''clock' a", locale='en')
-    u"03 o'clock PM"
-
-    For any pattern requiring the display of the time-zone a
-    timezone has to be specified explicitly:
-
-    >>> t = datetime(2007, 4, 1, 15, 30)
-    >>> tzinfo = get_timezone('Europe/Paris')
-    >>> t = tzinfo.localize(t)
-    >>> format_time(t, format='full', tzinfo=tzinfo, locale='fr_FR')
-    u'15:30:00 heure d\u2019\xe9t\xe9 d\u2019Europe centrale'
-    >>> format_time(t, "hh 'o''clock' a, zzzz", tzinfo=get_timezone('US/Eastern'),
-    ...             locale='en')
-    u"09 o'clock AM, Eastern Daylight Time"
-
-    As that example shows, when this function gets passed a
-    ``datetime.datetime`` value, the actual time in the formatted string is
-    adjusted to the timezone specified by the `tzinfo` parameter. If the
-    ``datetime`` is "naive" (i.e. it has no associated timezone information),
-    it is assumed to be in UTC.
-
-    These timezone calculations are **not** performed if the value is of type
-    ``datetime.time``, as without date information there's no way to determine
-    what a given time would translate to in a different timezone without
-    information about whether daylight savings time is in effect or not. This
-    means that time values are left as-is, and the value of the `tzinfo`
-    parameter is only used to display the timezone name if needed:
-
-    >>> t = time(15, 30)
-    >>> format_time(t, format='full', tzinfo=get_timezone('Europe/Paris'),
-    ...             locale='fr_FR')
-    u'15:30:00 heure normale d\u2019Europe centrale'
-    >>> format_time(t, format='full', tzinfo=get_timezone('US/Eastern'),
-    ...             locale='en_US')
-    u'3:30:00 PM Eastern Standard Time'
-
-    :param time: the ``time`` or ``datetime`` object; if `None`, the current
-                 time in UTC is used
-    :param format: one of "full", "long", "medium", or "short", or a custom
-                   date/time pattern
-    :param tzinfo: the time-zone to apply to the time for display
-    :param locale: a `Locale` object or a locale identifier
-    """
-    time = _get_time(time, tzinfo)
-
-    locale = Locale.parse(locale)
-    if format in ('full', 'long', 'medium', 'short'):
-        format = get_time_format(format, locale=locale)
-    return parse_pattern(format).apply(time, locale)
-
-
-def format_skeleton(skeleton, datetime=None, tzinfo=None, fuzzy=True, locale=LC_TIME):
-    r"""Return a time and/or date formatted according to the given pattern.
-
-    The skeletons are defined in the CLDR data and provide more flexibility
-    than the simple short/long/medium formats, but are a bit harder to use.
-    The are defined using the date/time symbols without order or punctuation
-    and map to a suitable format for the given locale.
-
-    >>> t = datetime(2007, 4, 1, 15, 30)
-    >>> format_skeleton('MMMEd', t, locale='fr')
-    u'dim. 1 avr.'
-    >>> format_skeleton('MMMEd', t, locale='en')
-    u'Sun, Apr 1'
-    >>> format_skeleton('yMMd', t, locale='fi')  # yMMd is not in the Finnish locale; yMd gets used
-    u'1.4.2007'
-    >>> format_skeleton('yMMd', t, fuzzy=False, locale='fi')  # yMMd is not in the Finnish locale, an error is thrown
-    Traceback (most recent call last):
-        ...
-    KeyError: yMMd
-
-    After the skeleton is resolved to a pattern `format_datetime` is called so
-    all timezone processing etc is the same as for that.
-
-    :param skeleton: A date time skeleton as defined in the cldr data.
-    :param datetime: the ``time`` or ``datetime`` object; if `None`, the current
-                 time in UTC is used
-    :param tzinfo: the time-zone to apply to the time for display
-    :param fuzzy: If the skeleton is not found, allow choosing a skeleton that's
-                  close enough to it.
-    :param locale: a `Locale` object or a locale identifier
-    """
-    locale = Locale.parse(locale)
-    if fuzzy and skeleton not in locale.datetime_skeletons:
-        skeleton = match_skeleton(skeleton, locale.datetime_skeletons)
-    format = locale.datetime_skeletons[skeleton]
-    return format_datetime(datetime, format, tzinfo, locale)
-
-
-TIMEDELTA_UNITS = (
-    ('year', 3600 * 24 * 365),
-    ('month', 3600 * 24 * 30),
-    ('week', 3600 * 24 * 7),
-    ('day', 3600 * 24),
-    ('hour', 3600),
-    ('minute', 60),
-    ('second', 1)
-)
-
-
-def format_timedelta(delta, granularity='second', threshold=.85,
-                     add_direction=False, format='long',
-                     locale=LC_TIME):
-    """Return a time delta according to the rules of the given locale.
-
-    >>> format_timedelta(timedelta(weeks=12), locale='en_US')
-    u'3 months'
-    >>> format_timedelta(timedelta(seconds=1), locale='es')
-    u'1 segundo'
-
-    The granularity parameter can be provided to alter the lowest unit
-    presented, which defaults to a second.
-
-    >>> format_timedelta(timedelta(hours=3), granularity='day',
-    ...                  locale='en_US')
-    u'1 day'
-
-    The threshold parameter can be used to determine at which value the
-    presentation switches to the next higher unit. A higher threshold factor
-    means the presentation will switch later. For example:
-
-    >>> format_timedelta(timedelta(hours=23), threshold=0.9, locale='en_US')
-    u'1 day'
-    >>> format_timedelta(timedelta(hours=23), threshold=1.1, locale='en_US')
-    u'23 hours'
-
-    In addition directional information can be provided that informs
-    the user if the date is in the past or in the future:
-
-    >>> format_timedelta(timedelta(hours=1), add_direction=True, locale='en')
-    u'in 1 hour'
-    >>> format_timedelta(timedelta(hours=-1), add_direction=True, locale='en')
-    u'1 hour ago'
-
-    The format parameter controls how compact or wide the presentation is:
-
-    >>> format_timedelta(timedelta(hours=3), format='short', locale='en')
-    u'3 hr'
-    >>> format_timedelta(timedelta(hours=3), format='narrow', locale='en')
-    u'3h'
-
-    :param delta: a ``timedelta`` object representing the time difference to
-                  format, or the delta in seconds as an `int` value
-    :param granularity: determines the smallest unit that should be displayed,
-                        the value can be one of "year", "month", "week", "day",
-                        "hour", "minute" or "second"
-    :param threshold: factor that determines at which point the presentation
-                      switches to the next higher unit
-    :param add_direction: if this flag is set to `True` the return value will
-                          include directional information.  For instance a
-                          positive timedelta will include the information about
-                          it being in the future, a negative will be information
-                          about the value being in the past.
-    :param format: the format, can be "narrow", "short" or "long". (
-                   "medium" is deprecated, currently converted to "long" to
-                   maintain compatibility)
-    :param locale: a `Locale` object or a locale identifier
-    """
-    if format not in ('narrow', 'short', 'medium', 'long'):
-        raise TypeError('Format must be one of "narrow", "short" or "long"')
-    if format == 'medium':
-        warnings.warn('"medium" value for format param of format_timedelta'
-                      ' is deprecated. Use "long" instead',
-                      category=DeprecationWarning)
-        format = 'long'
-    if isinstance(delta, timedelta):
-        seconds = int((delta.days * 86400) + delta.seconds)
-    else:
-        seconds = delta
-    locale = Locale.parse(locale)
-
-    def _iter_patterns(a_unit):
-        if add_direction:
-            unit_rel_patterns = locale._data['date_fields'][a_unit]
-            if seconds >= 0:
-                yield unit_rel_patterns['future']
-            else:
-                yield unit_rel_patterns['past']
-        a_unit = 'duration-' + a_unit
-        yield locale._data['unit_patterns'].get(a_unit, {}).get(format)
-
-    for unit, secs_per_unit in TIMEDELTA_UNITS:
-        value = abs(seconds) / secs_per_unit
-        if value >= threshold or unit == granularity:
-            if unit == granularity and value > 0:
-                value = max(1, value)
-            value = int(round(value))
-            plural_form = locale.plural_form(value)
-            pattern = None
-            for patterns in _iter_patterns(unit):
-                if patterns is not None:
-                    pattern = patterns[plural_form]
-                    break
-            # This really should not happen
-            if pattern is None:
-                return u''
-            return pattern.replace('{0}', str(value))
-
-    return u''
-
-
-def _format_fallback_interval(start, end, skeleton, tzinfo, locale):
-    if skeleton in locale.datetime_skeletons:  # Use the given skeleton
-        format = lambda dt: format_skeleton(skeleton, dt, tzinfo, locale=locale)
-    elif all((isinstance(d, date) and not isinstance(d, datetime)) for d in (start, end)):  # Both are just dates
-        format = lambda dt: format_date(dt, locale=locale)
-    elif all((isinstance(d, time) and not isinstance(d, date)) for d in (start, end)):  # Both are times
-        format = lambda dt: format_time(dt, tzinfo=tzinfo, locale=locale)
-    else:
-        format = lambda dt: format_datetime(dt, tzinfo=tzinfo, locale=locale)
-
-    formatted_start = format(start)
-    formatted_end = format(end)
-
-    if formatted_start == formatted_end:
-        return format(start)
-
-    return (
-        locale.interval_formats.get(None, "{0}-{1}").
-        replace("{0}", formatted_start).
-        replace("{1}", formatted_end)
-    )
-
-
-def format_interval(start, end, skeleton=None, tzinfo=None, fuzzy=True, locale=LC_TIME):
-    """
-    Format an interval between two instants according to the locale's rules.
-
-    >>> format_interval(date(2016, 1, 15), date(2016, 1, 17), "yMd", locale="fi")
-    u'15.\u201317.1.2016'
-
-    >>> format_interval(time(12, 12), time(16, 16), "Hm", locale="en_GB")
-    '12:12\u201316:16'
-
-    >>> format_interval(time(5, 12), time(16, 16), "hm", locale="en_US")
-    '5:12 AM \u2013 4:16 PM'
-
-    >>> format_interval(time(16, 18), time(16, 24), "Hm", locale="it")
-    '16:18\u201316:24'
-
-    If the start instant equals the end instant, the interval is formatted like the instant.
-
-    >>> format_interval(time(16, 18), time(16, 18), "Hm", locale="it")
-    '16:18'
-
-    Unknown skeletons fall back to "default" formatting.
-
-    >>> format_interval(date(2015, 1, 1), date(2017, 1, 1), "wzq", locale="ja")
-    '2015/01/01\uff5e2017/01/01'
-
-    >>> format_interval(time(16, 18), time(16, 24), "xxx", locale="ja")
-    '16:18:00\uff5e16:24:00'
-
-    >>> format_interval(date(2016, 1, 15), date(2016, 1, 17), "xxx", locale="de")
-    '15.01.2016 \u2013 17.01.2016'
-
-    :param start: First instant (datetime/date/time)
-    :param end: Second instant (datetime/date/time)
-    :param skeleton: The "skeleton format" to use for formatting.
-    :param tzinfo: tzinfo to use (if none is already attached)
-    :param fuzzy: If the skeleton is not found, allow choosing a skeleton that's
-                  close enough to it.
-    :param locale: A locale object or identifier.
-    :return: Formatted interval
-    """
-    locale = Locale.parse(locale)
-
-    # NB: The quote comments below are from the algorithm description in
-    #     https://www.unicode.org/reports/tr35/tr35-dates.html#intervalFormats
-
-    # > Look for the intervalFormatItem element that matches the "skeleton",
-    # > starting in the current locale and then following the locale fallback
-    # > chain up to, but not including root.
-
-    interval_formats = locale.interval_formats
-
-    if skeleton not in interval_formats or not skeleton:
-        # > If no match was found from the previous step, check what the closest
-        # > match is in the fallback locale chain, as in availableFormats. That
-        # > is, this allows for adjusting the string value field's width,
-        # > including adjusting between "MMM" and "MMMM", and using different
-        # > variants of the same field, such as 'v' and 'z'.
-        if skeleton and fuzzy:
-            skeleton = match_skeleton(skeleton, interval_formats)
-        else:
-            skeleton = None
-        if not skeleton:  # Still no match whatsoever?
-            # > Otherwise, format the start and end datetime using the fallback pattern.
-            return _format_fallback_interval(start, end, skeleton, tzinfo, locale)
-
-    skel_formats = interval_formats[skeleton]
-
-    if start == end:
-        return format_skeleton(skeleton, start, tzinfo, fuzzy=fuzzy, locale=locale)
-
-    start = _ensure_datetime_tzinfo(_get_datetime(start), tzinfo=tzinfo)
-    end = _ensure_datetime_tzinfo(_get_datetime(end), tzinfo=tzinfo)
-
-    start_fmt = DateTimeFormat(start, locale=locale)
-    end_fmt = DateTimeFormat(end, locale=locale)
-
-    # > If a match is found from previous steps, compute the calendar field
-    # > with the greatest difference between start and end datetime. If there
-    # > is no difference among any of the fields in the pattern, format as a
-    # > single date using availableFormats, and return.
-
-    for field in PATTERN_CHAR_ORDER:  # These are in largest-to-smallest order
-        if field in skel_formats:
-            if start_fmt.extract(field) != end_fmt.extract(field):
-                # > If there is a match, use the pieces of the corresponding pattern to
-                # > format the start and end datetime, as above.
-                return "".join(
-                    parse_pattern(pattern).apply(instant, locale)
-                    for pattern, instant
-                    in zip(skel_formats[field], (start, end))
-                )
-
-    # > Otherwise, format the start and end datetime using the fallback pattern.
-
-    return _format_fallback_interval(start, end, skeleton, tzinfo, locale)
-
-
-def get_period_id(time, tzinfo=None, type=None, locale=LC_TIME):
-    """
-    Get the day period ID for a given time.
-
-    This ID can be used as a key for the period name dictionary.
-
-    >>> get_period_names(locale="de")[get_period_id(time(7, 42), locale="de")]
-    u'Morgen'
-
-    :param time: The time to inspect.
-    :param tzinfo: The timezone for the time. See ``format_time``.
-    :param type: The period type to use. Either "selection" or None.
-                 The selection type is used for selecting among phrases such as
-                 “Your email arrived yesterday evening” or “Your email arrived last night”.
-    :param locale: the `Locale` object, or a locale string
-    :return: period ID. Something is always returned -- even if it's just "am" or "pm".
-    """
-    time = _get_time(time, tzinfo)
-    seconds_past_midnight = int(time.hour * 60 * 60 + time.minute * 60 + time.second)
-    locale = Locale.parse(locale)
-
-    # The LDML rules state that the rules may not overlap, so iterating in arbitrary
-    # order should be alright, though `at` periods should be preferred.
-    rulesets = locale.day_period_rules.get(type, {}).items()
-
-    for rule_id, rules in rulesets:
-        for rule in rules:
-            if "at" in rule and rule["at"] == seconds_past_midnight:
-                return rule_id
-
-    for rule_id, rules in rulesets:
-        for rule in rules:
-            start_ok = end_ok = False
-
-            if "from" in rule and seconds_past_midnight >= rule["from"]:
-                start_ok = True
-            if "to" in rule and seconds_past_midnight <= rule["to"]:
-                # This rule type does not exist in the present CLDR data;
-                # excuse the lack of test coverage.
-                end_ok = True
-            if "before" in rule and seconds_past_midnight < rule["before"]:
-                end_ok = True
-            if "after" in rule:
-                raise NotImplementedError("'after' is deprecated as of CLDR 29.")
-
-            if start_ok and end_ok:
-                return rule_id
-
-    if seconds_past_midnight < 43200:
-        return "am"
-    else:
-        return "pm"
-
-
-def parse_date(string, locale=LC_TIME):
-    """Parse a date from a string.
-
-    This function uses the date format for the locale as a hint to determine
-    the order in which the date fields appear in the string.
-
-    >>> parse_date('4/1/04', locale='en_US')
-    datetime.date(2004, 4, 1)
-    >>> parse_date('01.04.2004', locale='de_DE')
-    datetime.date(2004, 4, 1)
-
-    :param string: the string containing the date
-    :param locale: a `Locale` object or a locale identifier
-    """
-    # TODO: try ISO format first?
-    format = get_date_format(locale=locale).pattern.lower()
-    year_idx = format.index('y')
-    month_idx = format.index('m')
-    if month_idx < 0:
-        month_idx = format.index('l')
-    day_idx = format.index('d')
-
-    indexes = [(year_idx, 'Y'), (month_idx, 'M'), (day_idx, 'D')]
-    indexes.sort()
-    indexes = dict([(item[1], idx) for idx, item in enumerate(indexes)])
-
-    # FIXME: this currently only supports numbers, but should also support month
-    #        names, both in the requested locale, and english
-
-    numbers = re.findall(r'(\d+)', string)
-    year = numbers[indexes['Y']]
-    if len(year) == 2:
-        year = 2000 + int(year)
-    else:
-        year = int(year)
-    month = int(numbers[indexes['M']])
-    day = int(numbers[indexes['D']])
-    if month > 12:
-        month, day = day, month
-    return date(year, month, day)
-
-
-def parse_time(string, locale=LC_TIME):
-    """Parse a time from a string.
-
-    This function uses the time format for the locale as a hint to determine
-    the order in which the time fields appear in the string.
-
-    >>> parse_time('15:30:00', locale='en_US')
-    datetime.time(15, 30)
-
-    :param string: the string containing the time
-    :param locale: a `Locale` object or a locale identifier
-    :return: the parsed time
-    :rtype: `time`
-    """
-    # TODO: try ISO format first?
-    format = get_time_format(locale=locale).pattern.lower()
-    hour_idx = format.index('h')
-    if hour_idx < 0:
-        hour_idx = format.index('k')
-    min_idx = format.index('m')
-    sec_idx = format.index('s')
-
-    indexes = [(hour_idx, 'H'), (min_idx, 'M'), (sec_idx, 'S')]
-    indexes.sort()
-    indexes = dict([(item[1], idx) for idx, item in enumerate(indexes)])
-
-    # FIXME: support 12 hour clock, and 0-based hour specification
-    #        and seconds should be optional, maybe minutes too
-    #        oh, and time-zones, of course
-
-    numbers = re.findall(r'(\d+)', string)
-    hour = int(numbers[indexes['H']])
-    minute = int(numbers[indexes['M']])
-    second = int(numbers[indexes['S']])
-    return time(hour, minute, second)
-
-
-class DateTimePattern(object):
-
-    def __init__(self, pattern, format):
-        self.pattern = pattern
-        self.format = format
-
-    def __repr__(self):
-        return '<%s %r>' % (type(self).__name__, self.pattern)
-
-    def __unicode__(self):
-        return self.pattern
-
-    def __str__(self):
-        pat = self.pattern
-        if PY2:
-            pat = pat.encode('utf-8')
-        return pat
-
-    def __mod__(self, other):
-        if type(other) is not DateTimeFormat:
-            return NotImplemented
-        return self.format % other
-
-    def apply(self, datetime, locale):
-        return self % DateTimeFormat(datetime, locale)
-
-
-class DateTimeFormat(object):
-
-    def __init__(self, value, locale):
-        assert isinstance(value, (date, datetime, time))
-        if isinstance(value, (datetime, time)) and value.tzinfo is None:
-            value = value.replace(tzinfo=UTC)
-        self.value = value
-        self.locale = Locale.parse(locale)
-
-    def __getitem__(self, name):
-        char = name[0]
-        num = len(name)
-        if char == 'G':
-            return self.format_era(char, num)
-        elif char in ('y', 'Y', 'u'):
-            return self.format_year(char, num)
-        elif char in ('Q', 'q'):
-            return self.format_quarter(char, num)
-        elif char in ('M', 'L'):
-            return self.format_month(char, num)
-        elif char in ('w', 'W'):
-            return self.format_week(char, num)
-        elif char == 'd':
-            return self.format(self.value.day, num)
-        elif char == 'D':
-            return self.format_day_of_year(num)
-        elif char == 'F':
-            return self.format_day_of_week_in_month()
-        elif char in ('E', 'e', 'c'):
-            return self.format_weekday(char, num)
-        elif char == 'a':
-            # TODO: Add support for the rest of the period formats (a*, b*, B*)
-            return self.format_period(char)
-        elif char == 'h':
-            if self.value.hour % 12 == 0:
-                return self.format(12, num)
-            else:
-                return self.format(self.value.hour % 12, num)
-        elif char == 'H':
-            return self.format(self.value.hour, num)
-        elif char == 'K':
-            return self.format(self.value.hour % 12, num)
-        elif char == 'k':
-            if self.value.hour == 0:
-                return self.format(24, num)
-            else:
-                return self.format(self.value.hour, num)
-        elif char == 'm':
-            return self.format(self.value.minute, num)
-        elif char == 's':
-            return self.format(self.value.second, num)
-        elif char == 'S':
-            return self.format_frac_seconds(num)
-        elif char == 'A':
-            return self.format_milliseconds_in_day(num)
-        elif char in ('z', 'Z', 'v', 'V', 'x', 'X', 'O'):
-            return self.format_timezone(char, num)
-        else:
-            raise KeyError('Unsupported date/time field %r' % char)
-
-    def extract(self, char):
-        char = str(char)[0]
-        if char == 'y':
-            return self.value.year
-        elif char == 'M':
-            return self.value.month
-        elif char == 'd':
-            return self.value.day
-        elif char == 'H':
-            return self.value.hour
-        elif char == 'h':
-            return self.value.hour % 12 or 12
-        elif char == 'm':
-            return self.value.minute
-        elif char == 'a':
-            return int(self.value.hour >= 12)  # 0 for am, 1 for pm
-        else:
-            raise NotImplementedError("Not implemented: extracting %r from %r" % (char, self.value))
-
-    def format_era(self, char, num):
-        width = {3: 'abbreviated', 4: 'wide', 5: 'narrow'}[max(3, num)]
-        era = int(self.value.year >= 0)
-        return get_era_names(width, self.locale)[era]
-
-    def format_year(self, char, num):
-        value = self.value.year
-        if char.isupper():
-            value = self.value.isocalendar()[0]
-        year = self.format(value, num)
-        if num == 2:
-            year = year[-2:]
-        return year
-
-    def format_quarter(self, char, num):
-        quarter = (self.value.month - 1) // 3 + 1
-        if num <= 2:
-            return '%0*d' % (num, quarter)
-        width = {3: 'abbreviated', 4: 'wide', 5: 'narrow'}[num]
-        context = {'Q': 'format', 'q': 'stand-alone'}[char]
-        return get_quarter_names(width, context, self.locale)[quarter]
-
-    def format_month(self, char, num):
-        if num <= 2:
-            return '%0*d' % (num, self.value.month)
-        width = {3: 'abbreviated', 4: 'wide', 5: 'narrow'}[num]
-        context = {'M': 'format', 'L': 'stand-alone'}[char]
-        return get_month_names(width, context, self.locale)[self.value.month]
-
-    def format_week(self, char, num):
-        if char.islower():  # week of year
-            day_of_year = self.get_day_of_year()
-            week = self.get_week_number(day_of_year)
-            if week == 0:
-                date = self.value - timedelta(days=day_of_year)
-                week = self.get_week_number(self.get_day_of_year(date),
-                                            date.weekday())
-            return self.format(week, num)
-        else:  # week of month
-            week = self.get_week_number(self.value.day)
-            if week == 0:
-                date = self.value - timedelta(days=self.value.day)
-                week = self.get_week_number(date.day, date.weekday())
-            return '%d' % week
-
-    def format_weekday(self, char='E', num=4):
-        """
-        Return weekday from parsed datetime according to format pattern.
-
-        >>> format = DateTimeFormat(date(2016, 2, 28), Locale.parse('en_US'))
-        >>> format.format_weekday()
-        u'Sunday'
-
-        'E': Day of week - Use one through three letters for the abbreviated day name, four for the full (wide) name,
-             five for the narrow name, or six for the short name.
-        >>> format.format_weekday('E',2)
-        u'Sun'
-
-        'e': Local day of week. Same as E except adds a numeric value that will depend on the local starting day of the
-             week, using one or two letters. For this example, Monday is the first day of the week.
-        >>> format.format_weekday('e',2)
-        '01'
-
-        'c': Stand-Alone local day of week - Use one letter for the local numeric value (same as 'e'), three for the
-             abbreviated day name, four for the full (wide) name, five for the narrow name, or six for the short name.
-        >>> format.format_weekday('c',1)
-        '1'
-
-        :param char: pattern format character ('e','E','c')
-        :param num: count of format character
-
-        """
-        if num < 3:
-            if char.islower():
-                value = 7 - self.locale.first_week_day + self.value.weekday()
-                return self.format(value % 7 + 1, num)
-            num = 3
-        weekday = self.value.weekday()
-        width = {3: 'abbreviated', 4: 'wide', 5: 'narrow', 6: 'short'}[num]
-        if char == 'c':
-            context = 'stand-alone'
-        else:
-            context = 'format'
-        return get_day_names(width, context, self.locale)[weekday]
-
-    def format_day_of_year(self, num):
-        return self.format(self.get_day_of_year(), num)
-
-    def format_day_of_week_in_month(self):
-        return '%d' % ((self.value.day - 1) // 7 + 1)
-
-    def format_period(self, char):
-        period = {0: 'am', 1: 'pm'}[int(self.value.hour >= 12)]
-        for width in ('wide', 'narrow', 'abbreviated'):
-            period_names = get_period_names(context='format', width=width, locale=self.locale)
-            if period in period_names:
-                return period_names[period]
-        raise ValueError('Could not format period %s in %s' % (period, self.locale))
-
-    def format_frac_seconds(self, num):
-        """ Return fractional seconds.
-
-        Rounds the time's microseconds to the precision given by the number \
-        of digits passed in.
-        """
-        value = self.value.microsecond / 1000000
-        return self.format(round(value, num) * 10**num, num)
-
-    def format_milliseconds_in_day(self, num):
-        msecs = self.value.microsecond // 1000 + self.value.second * 1000 + \
-            self.value.minute * 60000 + self.value.hour * 3600000
-        return self.format(msecs, num)
-
-    def format_timezone(self, char, num):
-        width = {3: 'short', 4: 'long', 5: 'iso8601'}[max(3, num)]
-        if char == 'z':
-            return get_timezone_name(self.value, width, locale=self.locale)
-        elif char == 'Z':
-            if num == 5:
-                return get_timezone_gmt(self.value, width, locale=self.locale, return_z=True)
-            return get_timezone_gmt(self.value, width, locale=self.locale)
-        elif char == 'O':
-            if num == 4:
-                return get_timezone_gmt(self.value, width, locale=self.locale)
-        # TODO: To add support for O:1
-        elif char == 'v':
-            return get_timezone_name(self.value.tzinfo, width,
-                                     locale=self.locale)
-        elif char == 'V':
-            if num == 1:
-                return get_timezone_name(self.value.tzinfo, width,
-                                         uncommon=True, locale=self.locale)
-            elif num == 2:
-                return get_timezone_name(self.value.tzinfo, locale=self.locale, return_zone=True)
-            elif num == 3:
-                return get_timezone_location(self.value.tzinfo, locale=self.locale, return_city=True)
-            return get_timezone_location(self.value.tzinfo, locale=self.locale)
-        # Included additional elif condition to add support for 'Xx' in timezone format
-        elif char == 'X':
-            if num == 1:
-                return get_timezone_gmt(self.value, width='iso8601_short', locale=self.locale,
-                                        return_z=True)
-            elif num in (2, 4):
-                return get_timezone_gmt(self.value, width='short', locale=self.locale,
-                                        return_z=True)
-            elif num in (3, 5):
-                return get_timezone_gmt(self.value, width='iso8601', locale=self.locale,
-                                        return_z=True)
-        elif char == 'x':
-            if num == 1:
-                return get_timezone_gmt(self.value, width='iso8601_short', locale=self.locale)
-            elif num in (2, 4):
-                return get_timezone_gmt(self.value, width='short', locale=self.locale)
-            elif num in (3, 5):
-                return get_timezone_gmt(self.value, width='iso8601', locale=self.locale)
-
-    def format(self, value, length):
-        return '%0*d' % (length, value)
-
-    def get_day_of_year(self, date=None):
-        if date is None:
-            date = self.value
-        return (date - date.replace(month=1, day=1)).days + 1
-
-    def get_week_number(self, day_of_period, day_of_week=None):
-        """Return the number of the week of a day within a period. This may be
-        the week number in a year or the week number in a month.
-
-        Usually this will return a value equal to or greater than 1, but if the
-        first week of the period is so short that it actually counts as the last
-        week of the previous period, this function will return 0.
-
-        >>> format = DateTimeFormat(date(2006, 1, 8), Locale.parse('de_DE'))
-        >>> format.get_week_number(6)
-        1
-
-        >>> format = DateTimeFormat(date(2006, 1, 8), Locale.parse('en_US'))
-        >>> format.get_week_number(6)
-        2
-
-        :param day_of_period: the number of the day in the period (usually
-                              either the day of month or the day of year)
-        :param day_of_week: the week day; if ommitted, the week day of the
-                            current date is assumed
-        """
-        if day_of_week is None:
-            day_of_week = self.value.weekday()
-        first_day = (day_of_week - self.locale.first_week_day -
-                     day_of_period + 1) % 7
-        if first_day < 0:
-            first_day += 7
-        week_number = (day_of_period + first_day - 1) // 7
-
-        if 7 - first_day >= self.locale.min_week_days:
-            week_number += 1
-
-        if self.locale.first_week_day == 0:
-            # Correct the weeknumber in case of iso-calendar usage (first_week_day=0).
-            # If the weeknumber exceeds the maximum number of weeks for the given year
-            # we must count from zero.For example the above calculation gives week 53
-            # for 2018-12-31. By iso-calender definition 2018 has a max of 52
-            # weeks, thus the weeknumber must be 53-52=1.
-            max_weeks = date(year=self.value.year, day=28, month=12).isocalendar()[1]
-            if week_number > max_weeks:
-                week_number -= max_weeks
-
-        return week_number
-
-
-PATTERN_CHARS = {
-    'G': [1, 2, 3, 4, 5],                                               # era
-    'y': None, 'Y': None, 'u': None,                                    # year
-    'Q': [1, 2, 3, 4, 5], 'q': [1, 2, 3, 4, 5],                         # quarter
-    'M': [1, 2, 3, 4, 5], 'L': [1, 2, 3, 4, 5],                         # month
-    'w': [1, 2], 'W': [1],                                              # week
-    'd': [1, 2], 'D': [1, 2, 3], 'F': [1], 'g': None,                   # day
-    'E': [1, 2, 3, 4, 5, 6], 'e': [1, 2, 3, 4, 5, 6], 'c': [1, 3, 4, 5, 6],  # week day
-    'a': [1],                                                           # period
-    'h': [1, 2], 'H': [1, 2], 'K': [1, 2], 'k': [1, 2],                 # hour
-    'm': [1, 2],                                                        # minute
-    's': [1, 2], 'S': None, 'A': None,                                  # second
-    'z': [1, 2, 3, 4], 'Z': [1, 2, 3, 4, 5], 'O': [1, 4], 'v': [1, 4],  # zone
-    'V': [1, 2, 3, 4], 'x': [1, 2, 3, 4, 5], 'X': [1, 2, 3, 4, 5]       # zone
-}
-
-#: The pattern characters declared in the Date Field Symbol Table
-#: (https://www.unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table)
-#: in order of decreasing magnitude.
-PATTERN_CHAR_ORDER = "GyYuUQqMLlwWdDFgEecabBChHKkjJmsSAzZOvVXx"
-
-_pattern_cache = {}
-
-
-def parse_pattern(pattern):
-    """Parse date, time, and datetime format patterns.
-
-    >>> parse_pattern("MMMMd").format
-    u'%(MMMM)s%(d)s'
-    >>> parse_pattern("MMM d, yyyy").format
-    u'%(MMM)s %(d)s, %(yyyy)s'
-
-    Pattern can contain literal strings in single quotes:
-
-    >>> parse_pattern("H:mm' Uhr 'z").format
-    u'%(H)s:%(mm)s Uhr %(z)s'
-
-    An actual single quote can be used by using two adjacent single quote
-    characters:
-
-    >>> parse_pattern("hh' o''clock'").format
-    u"%(hh)s o'clock"
-
-    :param pattern: the formatting pattern to parse
-    """
-    if type(pattern) is DateTimePattern:
-        return pattern
-
-    if pattern in _pattern_cache:
-        return _pattern_cache[pattern]
-
-    result = []
-
-    for tok_type, tok_value in tokenize_pattern(pattern):
-        if tok_type == "chars":
-            result.append(tok_value.replace('%', '%%'))
-        elif tok_type == "field":
-            fieldchar, fieldnum = tok_value
-            limit = PATTERN_CHARS[fieldchar]
-            if limit and fieldnum not in limit:
-                raise ValueError('Invalid length for field: %r'
-                                 % (fieldchar * fieldnum))
-            result.append('%%(%s)s' % (fieldchar * fieldnum))
-        else:
-            raise NotImplementedError("Unknown token type: %s" % tok_type)
-
-    _pattern_cache[pattern] = pat = DateTimePattern(pattern, u''.join(result))
-    return pat
-
-
-def tokenize_pattern(pattern):
-    """
-    Tokenize date format patterns.
-
-    Returns a list of (token_type, token_value) tuples.
-
-    ``token_type`` may be either "chars" or "field".
-
-    For "chars" tokens, the value is the literal value.
-
-    For "field" tokens, the value is a tuple of (field character, repetition count).
-
-    :param pattern: Pattern string
-    :type pattern: str
-    :rtype: list[tuple]
-    """
-    result = []
-    quotebuf = None
-    charbuf = []
-    fieldchar = ['']
-    fieldnum = [0]
-
-    def append_chars():
-        result.append(('chars', ''.join(charbuf).replace('\0', "'")))
-        del charbuf[:]
-
-    def append_field():
-        result.append(('field', (fieldchar[0], fieldnum[0])))
-        fieldchar[0] = ''
-        fieldnum[0] = 0
-
-    for idx, char in enumerate(pattern.replace("''", '\0')):
-        if quotebuf is None:
-            if char == "'":  # quote started
-                if fieldchar[0]:
-                    append_field()
-                elif charbuf:
-                    append_chars()
-                quotebuf = []
-            elif char in PATTERN_CHARS:
-                if charbuf:
-                    append_chars()
-                if char == fieldchar[0]:
-                    fieldnum[0] += 1
-                else:
-                    if fieldchar[0]:
-                        append_field()
-                    fieldchar[0] = char
-                    fieldnum[0] = 1
-            else:
-                if fieldchar[0]:
-                    append_field()
-                charbuf.append(char)
-
-        elif quotebuf is not None:
-            if char == "'":  # end of quote
-                charbuf.extend(quotebuf)
-                quotebuf = None
-            else:  # inside quote
-                quotebuf.append(char)
-
-    if fieldchar[0]:
-        append_field()
-    elif charbuf:
-        append_chars()
-
-    return result
-
-
-def untokenize_pattern(tokens):
-    """
-    Turn a date format pattern token stream back into a string.
-
-    This is the reverse operation of ``tokenize_pattern``.
-
-    :type tokens: Iterable[tuple]
-    :rtype: str
-    """
-    output = []
-    for tok_type, tok_value in tokens:
-        if tok_type == "field":
-            output.append(tok_value[0] * tok_value[1])
-        elif tok_type == "chars":
-            if not any(ch in PATTERN_CHARS for ch in tok_value):  # No need to quote
-                output.append(tok_value)
-            else:
-                output.append("'%s'" % tok_value.replace("'", "''"))
-    return "".join(output)
-
-
-def split_interval_pattern(pattern):
-    """
-    Split an interval-describing datetime pattern into multiple pieces.
-
-    > The pattern is then designed to be broken up into two pieces by determining the first repeating field.
-    - https://www.unicode.org/reports/tr35/tr35-dates.html#intervalFormats
-
-    >>> split_interval_pattern(u'E d.M. \u2013 E d.M.')
-    [u'E d.M. \u2013 ', 'E d.M.']
-    >>> split_interval_pattern("Y 'text' Y 'more text'")
-    ["Y 'text '", "Y 'more text'"]
-    >>> split_interval_pattern(u"E, MMM d \u2013 E")
-    [u'E, MMM d \u2013 ', u'E']
-    >>> split_interval_pattern("MMM d")
-    ['MMM d']
-    >>> split_interval_pattern("y G")
-    ['y G']
-    >>> split_interval_pattern(u"MMM d \u2013 d")
-    [u'MMM d \u2013 ', u'd']
-
-    :param pattern: Interval pattern string
-    :return: list of "subpatterns"
-    """
-
-    seen_fields = set()
-    parts = [[]]
-
-    for tok_type, tok_value in tokenize_pattern(pattern):
-        if tok_type == "field":
-            if tok_value[0] in seen_fields:  # Repeated field
-                parts.append([])
-                seen_fields.clear()
-            seen_fields.add(tok_value[0])
-        parts[-1].append((tok_type, tok_value))
-
-    return [untokenize_pattern(tokens) for tokens in parts]
-
-
-def match_skeleton(skeleton, options, allow_different_fields=False):
-    """
-    Find the closest match for the given datetime skeleton among the options given.
-
-    This uses the rules outlined in the TR35 document.
-
-    >>> match_skeleton('yMMd', ('yMd', 'yMMMd'))
-    'yMd'
-
-    >>> match_skeleton('yMMd', ('jyMMd',), allow_different_fields=True)
-    'jyMMd'
-
-    >>> match_skeleton('yMMd', ('qyMMd',), allow_different_fields=False)
-
-    >>> match_skeleton('hmz', ('hmv',))
-    'hmv'
-
-    :param skeleton: The skeleton to match
-    :type skeleton: str
-    :param options: An iterable of other skeletons to match against
-    :type options: Iterable[str]
-    :return: The closest skeleton match, or if no match was found, None.
-    :rtype: str|None
-    """
-
-    # TODO: maybe implement pattern expansion?
-
-    # Based on the implementation in
-    # http://source.icu-project.org/repos/icu/icu4j/trunk/main/classes/core/src/com/ibm/icu/text/DateIntervalInfo.java
-
-    # Filter out falsy values and sort for stability; when `interval_formats` is passed in, there may be a None key.
-    options = sorted(option for option in options if option)
-
-    if 'z' in skeleton and not any('z' in option for option in options):
-        skeleton = skeleton.replace('z', 'v')
-
-    get_input_field_width = dict(t[1] for t in tokenize_pattern(skeleton) if t[0] == "field").get
-    best_skeleton = None
-    best_distance = None
-    for option in options:
-        get_opt_field_width = dict(t[1] for t in tokenize_pattern(option) if t[0] == "field").get
-        distance = 0
-        for field in PATTERN_CHARS:
-            input_width = get_input_field_width(field, 0)
-            opt_width = get_opt_field_width(field, 0)
-            if input_width == opt_width:
-                continue
-            if opt_width == 0 or input_width == 0:
-                if not allow_different_fields:  # This one is not okay
-                    option = None
-                    break
-                distance += 0x1000  # Magic weight constant for "entirely different fields"
-            elif field == 'M' and ((input_width > 2 and opt_width <= 2) or (input_width <= 2 and opt_width > 2)):
-                distance += 0x100  # Magic weight for "text turns into a number"
-            else:
-                distance += abs(input_width - opt_width)
-
-        if not option:  # We lost the option along the way (probably due to "allow_different_fields")
-            continue
-
-        if not best_skeleton or distance < best_distance:
-            best_skeleton = option
-            best_distance = distance
-
-        if distance == 0:  # Found a perfect match!
-            break
-
-    return best_skeleton

BIN
desktop/core/ext-py/Babel-2.9.1/babel/global.dat


+ 0 - 71
desktop/core/ext-py/Babel-2.9.1/babel/languages.py

@@ -1,71 +0,0 @@
-# -- encoding: UTF-8 --
-from babel.core import get_global
-
-
-def get_official_languages(territory, regional=False, de_facto=False):
-    """
-    Get the official language(s) for the given territory.
-
-    The language codes, if any are known, are returned in order of descending popularity.
-
-    If the `regional` flag is set, then languages which are regionally official are also returned.
-
-    If the `de_facto` flag is set, then languages which are "de facto" official are also returned.
-
-    .. warning:: Note that the data is as up to date as the current version of the CLDR used
-                 by Babel.  If you need scientifically accurate information, use another source!
-
-    :param territory: Territory code
-    :type territory: str
-    :param regional: Whether to return regionally official languages too
-    :type regional: bool
-    :param de_facto: Whether to return de-facto official languages too
-    :type de_facto: bool
-    :return: Tuple of language codes
-    :rtype: tuple[str]
-    """
-
-    territory = str(territory).upper()
-    allowed_stati = {"official"}
-    if regional:
-        allowed_stati.add("official_regional")
-    if de_facto:
-        allowed_stati.add("de_facto_official")
-
-    languages = get_global("territory_languages").get(territory, {})
-    pairs = [
-        (info['population_percent'], language)
-        for language, info in languages.items()
-        if info.get('official_status') in allowed_stati
-    ]
-    pairs.sort(reverse=True)
-    return tuple(lang for _, lang in pairs)
-
-
-def get_territory_language_info(territory):
-    """
-    Get a dictionary of language information for a territory.
-
-    The dictionary is keyed by language code; the values are dicts with more information.
-
-    The following keys are currently known for the values:
-
-    * `population_percent`: The percentage of the territory's population speaking the
-                            language.
-    * `official_status`: An optional string describing the officiality status of the language.
-                         Known values are "official", "official_regional" and "de_facto_official".
-
-    .. warning:: Note that the data is as up to date as the current version of the CLDR used
-                 by Babel.  If you need scientifically accurate information, use another source!
-
-    .. note:: Note that the format of the dict returned may change between Babel versions.
-
-    See https://www.unicode.org/cldr/charts/latest/supplemental/territory_language_information.html
-
-    :param territory: Territory code
-    :type territory: str
-    :return: Language information dictionary
-    :rtype: dict[str, dict]
-    """
-    territory = str(territory).upper()
-    return get_global("territory_languages").get(territory, {}).copy()

+ 0 - 87
desktop/core/ext-py/Babel-2.9.1/babel/lists.py

@@ -1,87 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    babel.lists
-    ~~~~~~~~~~~
-
-    Locale dependent formatting of lists.
-
-    The default locale for the functions in this module is determined by the
-    following environment variables, in that order:
-
-     * ``LC_ALL``, and
-     * ``LANG``
-
-    :copyright: (c) 2015-2021 by the Babel Team.
-    :license: BSD, see LICENSE for more details.
-"""
-
-from babel.core import Locale, default_locale
-
-DEFAULT_LOCALE = default_locale()
-
-
-def format_list(lst, style='standard', locale=DEFAULT_LOCALE):
-    """
-    Format the items in `lst` as a list.
-
-    >>> format_list(['apples', 'oranges', 'pears'], locale='en')
-    u'apples, oranges, and pears'
-    >>> format_list(['apples', 'oranges', 'pears'], locale='zh')
-    u'apples\u3001oranges\u548cpears'
-    >>> format_list(['omena', 'peruna', 'aplari'], style='or', locale='fi')
-    u'omena, peruna tai aplari'
-
-    These styles are defined, but not all are necessarily available in all locales.
-    The following text is verbatim from the Unicode TR35-49 spec [1].
-
-    * standard:
-      A typical 'and' list for arbitrary placeholders.
-      eg. "January, February, and March"
-    * standard-short:
-      A short version of a 'and' list, suitable for use with short or abbreviated placeholder values.
-      eg. "Jan., Feb., and Mar."
-    * or:
-      A typical 'or' list for arbitrary placeholders.
-      eg. "January, February, or March"
-    * or-short:
-      A short version of an 'or' list.
-      eg. "Jan., Feb., or Mar."
-    * unit:
-      A list suitable for wide units.
-      eg. "3 feet, 7 inches"
-    * unit-short:
-      A list suitable for short units
-      eg. "3 ft, 7 in"
-    * unit-narrow:
-      A list suitable for narrow units, where space on the screen is very limited.
-      eg. "3′ 7″"
-
-    [1]: https://www.unicode.org/reports/tr35/tr35-49/tr35-general.html#ListPatterns
-
-    :param lst: a sequence of items to format in to a list
-    :param style: the style to format the list with. See above for description.
-    :param locale: the locale
-    """
-    locale = Locale.parse(locale)
-    if not lst:
-        return ''
-    if len(lst) == 1:
-        return lst[0]
-
-    if style not in locale.list_patterns:
-        raise ValueError('Locale %s does not support list formatting style %r (supported are %s)' % (
-            locale,
-            style,
-            list(sorted(locale.list_patterns)),
-        ))
-    patterns = locale.list_patterns[style]
-
-    if len(lst) == 2:
-        return patterns['2'].format(*lst)
-
-    result = patterns['start'].format(lst[0], lst[1])
-    for elem in lst[2:-1]:
-        result = patterns['middle'].format(result, elem)
-    result = patterns['end'].format(result, lst[-1])
-
-    return result

BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/af.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/af_NA.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/af_ZA.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/agq.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/agq_CM.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ak.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ak_GH.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/am.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/am_ET.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ar.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ar_001.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ar_AE.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ar_BH.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ar_DJ.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ar_DZ.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ar_EG.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ar_EH.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ar_ER.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ar_IL.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ar_IQ.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ar_JO.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ar_KM.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ar_KW.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ar_LB.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ar_LY.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ar_MA.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ar_MR.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ar_OM.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ar_PS.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ar_QA.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ar_SA.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ar_SD.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ar_SO.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ar_SS.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ar_SY.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ar_TD.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ar_TN.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ar_YE.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/as.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/as_IN.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/asa.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/asa_TZ.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ast.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ast_ES.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/az.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/az_Cyrl.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/az_Cyrl_AZ.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/az_Latn.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/az_Latn_AZ.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/bas.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/bas_CM.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/be.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/be_BY.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/bem.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/bem_ZM.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/bez.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/bez_TZ.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/bg.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/bg_BG.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/bm.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/bm_ML.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/bn.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/bn_BD.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/bn_IN.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/bo.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/bo_CN.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/bo_IN.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/br.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/br_FR.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/brx.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/brx_IN.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/bs.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/bs_Cyrl.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/bs_Cyrl_BA.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/bs_Latn.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/bs_Latn_BA.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ca.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ca_AD.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ca_ES.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ca_ES_VALENCIA.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ca_FR.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ca_IT.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ccp.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ccp_BD.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ccp_IN.dat


BIN
desktop/core/ext-py/Babel-2.9.1/babel/locale-data/ce.dat


Bu fark içinde çok fazla dosya değişikliği olduğu için bazı dosyalar gösterilmiyor