publishFullContrib: true for ydb

<HIDDEN_URL>
commit_hash:c82a80ac4594723cebf2c7387dec9c60217f603e

contrib/deprecated/python/backports.functools-lru-cache/.yandex_meta/yamaker.yaml

@@ -0,0 +1,2 @@
+exclude:
+- backports/__init__.py # Для избежания коллизий с другими backports пакетами

contrib/deprecated/python/backports.shutil-get-terminal-size/.yandex_meta/yamaker.yaml

@@ -0,0 +1,3 @@
+exclude:
+- backports/__init__.py # Для избежания коллизий с другими backports пакетами
+- shutil_backports/* # В Аркадии нет потребителей для этого пакета

contrib/deprecated/python/backports.shutil-get-terminal-size/patches/01-arcadia.patch

@@ -0,0 +1,11 @@
+--- contrib/deprecated/python/backports.shutil-get-terminal-size/backports/shutil_get_terminal_size/get_terminal_size.py	(index)
++++ contrib/deprecated/python/backports.shutil-get-terminal-size/backports/shutil_get_terminal_size/get_terminal_size.py	(working tree)
+@@ -41,7 +41,7 @@ try:
+ 
+         return terminal_size(columns, lines)
+ 
+-except ImportError:
++except (ImportError, OSError):
+     import fcntl
+     import termios
+ 

contrib/deprecated/python/configparser/.yandex_meta/yamaker.yaml

@@ -0,0 +1,2 @@
+exclude:
+  - backports/__init__.py # Для избежания коллизий с другими backports пакетами

contrib/deprecated/python/enum34/.yandex_meta/yamaker.yaml

@@ -0,0 +1,3 @@
+exclude_from_macros:
+  - enum/LICENSE
+  - enum/README

contrib/deprecated/python/enum34/patches/01-unknown.patch

@@ -0,0 +1,82 @@
+--- contrib/deprecated/python/enum34/enum/__init__.py	(index)
++++ contrib/deprecated/python/enum34/enum/__init__.py	(working tree)
+@@ -8,6 +8,8 @@ version = 1, 1, 10
+ 
+ pyver = float('%s.%s' % _sys.version_info[:2])
+ 
++ALLOW_SYNONYMS = '__allow_synonyms__'
++
+ try:
+     any
+ except NameError:
+@@ -161,6 +163,7 @@ class EnumMeta(type):
+             for k, v in original_dict.items():
+                 classdict[k] = v
+ 
++        allow_synonyms = classdict.get(ALLOW_SYNONYMS, True)
+         member_type, first_enum = metacls._get_mixins_(bases)
+         __new__, save_new, use_args = metacls._find_new_(classdict, member_type,
+                                                         first_enum)
+@@ -215,8 +218,18 @@ class EnumMeta(type):
+         # auto-numbering ;)
+         if __new__ is None:
+             __new__ = enum_class.__new__
++
++        val2name = {}
+         for member_name in _order_:
+             value = members[member_name]
++            if not allow_synonyms:
++                if value in val2name:
++                    raise ValueError(
++                        'allow_synonyms=False forbids multiple names of the same value; '
++                        'Members {!r} and {!r} break this'.format(val2name[value], member_name)
++                    )
++                val2name[value] = member_name
++
+             if not isinstance(value, tuple):
+                 args = (value, )
+             else:
+@@ -237,7 +250,7 @@ class EnumMeta(type):
+             enum_member.__init__(*args)
+             # If another member with the same value was already defined, the
+             # new member becomes an alias to the existing one.
+-            for name, canonical_member in enum_class._member_map_.items():
++            for name, canonical_member in (enum_class._member_map_.items() if allow_synonyms else ()):
+                 if canonical_member.value == enum_member._value_:
+                     enum_member = canonical_member
+                     break
+@@ -328,7 +341,7 @@ class EnumMeta(type):
+         """
+         return True
+ 
+-    def __call__(cls, value, names=None, module=None, type=None, start=1):
++    def __call__(cls, value, names=None, module=None, type=None, start=1, allow_synonyms=True):
+         """Either returns an existing member, or creates a new enum class.
+ 
+         This method is used both when an enum class is given a value to match
+@@ -347,7 +360,7 @@ class EnumMeta(type):
+         if names is None:  # simple value lookup
+             return cls.__new__(cls, value)
+         # otherwise, functional API: we're creating a new Enum type
+-        return cls._create_(value, names, module=module, type=type, start=start)
++        return cls._create_(value, names, module=module, type=type, start=start, allow_synonyms=allow_synonyms)
+ 
+     def __contains__(cls, member):
+         return isinstance(member, cls) and member.name in cls._member_map_
+@@ -420,7 +433,7 @@ class EnumMeta(type):
+             raise AttributeError('Cannot reassign members.')
+         super(EnumMeta, cls).__setattr__(name, value)
+ 
+-    def _create_(cls, class_name, names=None, module=None, type=None, start=1):
++    def _create_(cls, class_name, names=None, module=None, type=None, start=1, allow_synonyms=True):
+         """Convenience method to create a new Enum class.
+ 
+         `names` can be:
+@@ -465,6 +478,7 @@ class EnumMeta(type):
+         # only set _order_ in classdict if name/value was not from a mapping
+         if not isinstance(item, basestring):
+             classdict['_order_'] = _order_
++        classdict[ALLOW_SYNONYMS] = getattr(cls, ALLOW_SYNONYMS, allow_synonyms)
+         enum_class = metacls.__new__(metacls, class_name, bases, classdict)
+ 
+         # TODO: replace the frame hack if a blessed way to know the calling

contrib/deprecated/python/enum34/patches/02-fix-tests.patch

@@ -0,0 +1,216 @@
+--- contrib/deprecated/python/enum34/enum/test.py	(index)
++++ contrib/deprecated/python/enum34/enum/test.py	(working tree)
+@@ -94,7 +94,9 @@ try:
+ except Exception:
+     pass
+ 
+-def test_pickle_dump_load(assertion, source, target=None,
++import pytest
++
++def check_pickle_dump_load(assertion, source, target=None,
+         protocol=(0, HIGHEST_PROTOCOL)):
+     start, stop = protocol
+     failures = []
+@@ -110,7 +112,7 @@ def test_pickle_dump_load(assertion, source, target=None,
+     if failures:
+         raise ValueError('Failed with protocols: %s' % ', '.join(failures))
+ 
+-def test_pickle_exception(assertion, exception, obj,
++def check_pickle_exception(assertion, exception, obj,
+         protocol=(0, HIGHEST_PROTOCOL)):
+     start, stop = protocol
+     failures = []
+@@ -610,32 +612,32 @@ class TestEnum(unittest.TestCase):
+     def test_pickle_enum(self):
+         if isinstance(Stooges, Exception):
+             raise Stooges
+-        test_pickle_dump_load(self.assertTrue, Stooges.CURLY)
+-        test_pickle_dump_load(self.assertTrue, Stooges)
++        check_pickle_dump_load(self.assertTrue, Stooges.CURLY)
++        check_pickle_dump_load(self.assertTrue, Stooges)
+ 
+     def test_pickle_int(self):
+         if isinstance(IntStooges, Exception):
+             raise IntStooges
+-        test_pickle_dump_load(self.assertTrue, IntStooges.CURLY)
+-        test_pickle_dump_load(self.assertTrue, IntStooges)
++        check_pickle_dump_load(self.assertTrue, IntStooges.CURLY)
++        check_pickle_dump_load(self.assertTrue, IntStooges)
+ 
+     def test_pickle_float(self):
+         if isinstance(FloatStooges, Exception):
+             raise FloatStooges
+-        test_pickle_dump_load(self.assertTrue, FloatStooges.CURLY)
+-        test_pickle_dump_load(self.assertTrue, FloatStooges)
++        check_pickle_dump_load(self.assertTrue, FloatStooges.CURLY)
++        check_pickle_dump_load(self.assertTrue, FloatStooges)
+ 
+     def test_pickle_enum_function(self):
+         if isinstance(Answer, Exception):
+             raise Answer
+-        test_pickle_dump_load(self.assertTrue, Answer.him)
+-        test_pickle_dump_load(self.assertTrue, Answer)
++        check_pickle_dump_load(self.assertTrue, Answer.him)
++        check_pickle_dump_load(self.assertTrue, Answer)
+ 
+     def test_pickle_enum_function_with_module(self):
+         if isinstance(Question, Exception):
+             raise Question
+-        test_pickle_dump_load(self.assertTrue, Question.who)
+-        test_pickle_dump_load(self.assertTrue, Question)
++        check_pickle_dump_load(self.assertTrue, Question.who)
++        check_pickle_dump_load(self.assertTrue, Question)
+ 
+     if pyver == 3.4:
+         def test_class_nested_enum_and_pickle_protocol_four(self):
+@@ -646,10 +648,10 @@ class TestEnum(unittest.TestCase):
+ 
+             self.__class__.NestedEnum = NestedEnum
+             self.NestedEnum.__qualname__ = '%s.NestedEnum' % self.__class__.__name__
+-            test_pickle_exception(
++            check_pickle_exception(
+                     self.assertRaises, PicklingError, self.NestedEnum.twigs,
+                     protocol=(0, 3))
+-            test_pickle_dump_load(self.assertTrue, self.NestedEnum.twigs,
++            check_pickle_dump_load(self.assertTrue, self.NestedEnum.twigs,
+                     protocol=(4, HIGHEST_PROTOCOL))
+ 
+     elif pyver == 3.5:
+@@ -661,15 +663,15 @@ class TestEnum(unittest.TestCase):
+ 
+             self.__class__.NestedEnum = NestedEnum
+             self.NestedEnum.__qualname__ = '%s.NestedEnum' % self.__class__.__name__
+-            test_pickle_dump_load(self.assertTrue, self.NestedEnum.twigs,
++            check_pickle_dump_load(self.assertTrue, self.NestedEnum.twigs,
+                     protocol=(0, HIGHEST_PROTOCOL))
+ 
+     def test_exploding_pickle(self):
+         BadPickle = Enum('BadPickle', 'dill sweet bread_n_butter')
+         enum._make_class_unpicklable(BadPickle)
+         globals()['BadPickle'] = BadPickle
+-        test_pickle_exception(self.assertRaises, TypeError, BadPickle.dill)
+-        test_pickle_exception(self.assertRaises, PicklingError, BadPickle)
++        check_pickle_exception(self.assertRaises, TypeError, BadPickle.dill)
++        check_pickle_exception(self.assertRaises, PicklingError, BadPickle)
+ 
+     def test_string_enum(self):
+         class SkillLevel(str, Enum):
+@@ -1066,7 +1068,7 @@ class TestEnum(unittest.TestCase):
+         self.assertEqual(Name.BDFL, 'Guido van Rossum')
+         self.assertTrue(Name.BDFL, Name('Guido van Rossum'))
+         self.assertTrue(Name.BDFL is getattr(Name, 'BDFL'))
+-        test_pickle_dump_load(self.assertTrue, Name.BDFL)
++        check_pickle_dump_load(self.assertTrue, Name.BDFL)
+ 
+     def test_extending(self):
+         def bad_extension():
+@@ -1291,9 +1293,9 @@ class TestEnum(unittest.TestCase):
+         globals()['NEI'] = NEI
+         NI5 = NamedInt('test', 5)
+         self.assertEqual(NI5, 5)
+-        test_pickle_dump_load(self.assertTrue, NI5, 5)
++        check_pickle_dump_load(self.assertTrue, NI5, 5)
+         self.assertEqual(NEI.y.value, 2)
+-        test_pickle_dump_load(self.assertTrue, NEI.y)
++        check_pickle_dump_load(self.assertTrue, NEI.y)
+ 
+     if pyver >= 3.4:
+         def test_subclasses_with_getnewargs_ex(self):
+@@ -1348,9 +1350,9 @@ class TestEnum(unittest.TestCase):
+             globals()['NEI'] = NEI
+             NI5 = NamedInt('test', 5)
+             self.assertEqual(NI5, 5)
+-            test_pickle_dump_load(self.assertEqual, NI5, 5, protocol=(4, HIGHEST_PROTOCOL))
++            check_pickle_dump_load(self.assertEqual, NI5, 5, protocol=(4, HIGHEST_PROTOCOL))
+             self.assertEqual(NEI.y.value, 2)
+-            test_pickle_dump_load(self.assertTrue, NEI.y, protocol=(4, HIGHEST_PROTOCOL))
++            check_pickle_dump_load(self.assertTrue, NEI.y, protocol=(4, HIGHEST_PROTOCOL))
+ 
+     def test_subclasses_with_reduce(self):
+         class NamedInt(int):
+@@ -1404,9 +1406,9 @@ class TestEnum(unittest.TestCase):
+         globals()['NEI'] = NEI
+         NI5 = NamedInt('test', 5)
+         self.assertEqual(NI5, 5)
+-        test_pickle_dump_load(self.assertEqual, NI5, 5)
++        check_pickle_dump_load(self.assertEqual, NI5, 5)
+         self.assertEqual(NEI.y.value, 2)
+-        test_pickle_dump_load(self.assertTrue, NEI.y)
++        check_pickle_dump_load(self.assertTrue, NEI.y)
+ 
+     def test_subclasses_with_reduce_ex(self):
+         class NamedInt(int):
+@@ -1460,9 +1462,9 @@ class TestEnum(unittest.TestCase):
+         globals()['NEI'] = NEI
+         NI5 = NamedInt('test', 5)
+         self.assertEqual(NI5, 5)
+-        test_pickle_dump_load(self.assertEqual, NI5, 5)
++        check_pickle_dump_load(self.assertEqual, NI5, 5)
+         self.assertEqual(NEI.y.value, 2)
+-        test_pickle_dump_load(self.assertTrue, NEI.y)
++        check_pickle_dump_load(self.assertTrue, NEI.y)
+ 
+     def test_subclasses_without_direct_pickle_support(self):
+         class NamedInt(int):
+@@ -1514,8 +1516,8 @@ class TestEnum(unittest.TestCase):
+         NI5 = NamedInt('test', 5)
+         self.assertEqual(NI5, 5)
+         self.assertEqual(NEI.y.value, 2)
+-        test_pickle_exception(self.assertRaises, TypeError, NEI.x)
+-        test_pickle_exception(self.assertRaises, PicklingError, NEI)
++        check_pickle_exception(self.assertRaises, TypeError, NEI.x)
++        check_pickle_exception(self.assertRaises, PicklingError, NEI)
+ 
+     def test_subclasses_without_direct_pickle_support_using_name(self):
+         class NamedInt(int):
+@@ -1569,8 +1571,8 @@ class TestEnum(unittest.TestCase):
+         NI5 = NamedInt('test', 5)
+         self.assertEqual(NI5, 5)
+         self.assertEqual(NEI.y.value, 2)
+-        test_pickle_dump_load(self.assertTrue, NEI.y)
+-        test_pickle_dump_load(self.assertTrue, NEI)
++        check_pickle_dump_load(self.assertTrue, NEI.y)
++        check_pickle_dump_load(self.assertTrue, NEI)
+ 
+     def test_tuple_subclass(self):
+         class SomeTuple(tuple, Enum):
+@@ -1582,7 +1584,7 @@ class TestEnum(unittest.TestCase):
+         self.assertTrue(isinstance(SomeTuple.second, tuple))
+         self.assertEqual(SomeTuple.third, (3, 'for the music'))
+         globals()['SomeTuple'] = SomeTuple
+-        test_pickle_dump_load(self.assertTrue, SomeTuple.first)
++        check_pickle_dump_load(self.assertTrue, SomeTuple.first)
+ 
+     def test_duplicate_values_give_unique_enum_items(self):
+         class AutoNumber(Enum):
+@@ -1832,6 +1834,30 @@ class TestUnique(unittest.TestCase):
+         self.assertTrue('double -> single' in message)
+         self.assertTrue('turkey -> triple' in message)
+ 
++    def test_unique_class(self):
++        values = [
++            ('switzerland', 1),
++            ('sweden', 2),
++            ('usa', 3),
++            ('iran', 4),
++            ('iraq', 4),
++        ]
++        with self.assertRaises(ValueError):
++            enum.Enum('Country', values, allow_synonyms=False)
++
++        with self.assertRaises(ValueError):
++            class Country(enum.Enum):
++                __allow_synonyms__ = False
++
++                austria = 1
++                australia = 1
++
++        with self.assertRaises(ValueError):
++            class NoDuplicatesAllowed(enum.Enum):
++                __allow_synonyms__ = False
++
++            t = NoDuplicatesAllowed('NewEnum', [('russia', 1), ('belorussia', 1)])
++
+ 
+ class TestMe(unittest.TestCase):
+ 

contrib/deprecated/python/faulthandler/.yandex_meta/yamaker.yaml

@@ -0,0 +1,3 @@
+copy:
+  - faulthandler.c
+  - traceback.c

contrib/deprecated/python/faulthandler/patches/01-dump-extra-siginfo.patch

@@ -0,0 +1,156 @@
+commit 1a1c8a87cb6e966c8d716a90d516ee9ed23f5bef
+author: prettyboy
+date: 2020-05-28T12:04:46+03:00
+revision: 6879742
+
+    Dump extra siginfo if term signal is received
+    
+    issue:DEVTOOLSSUPPORT-1110
+    
+    REVIEW: 1279268
+
+--- contrib/deprecated/python/faulthandler/faulthandler.c	(b4ffd42d61e5a2398623b2c73b681b72896da86b)
++++ contrib/deprecated/python/faulthandler/faulthandler.c	(1a1c8a87cb6e966c8d716a90d516ee9ed23f5bef)
+@@ -43,6 +43,8 @@
+ 
+ /* defined in traceback.c */
+ extern Py_ssize_t _Py_write_noraise(int fd, const char *buf, size_t count);
++extern void dump_decimal(int fd, int value);
++extern void reverse_string(char *text, const size_t len);
+ 
+ /* cast size_t to int because write() takes an int on Windows
+    (anyway, the length is smaller than 30 characters) */
+@@ -378,6 +380,81 @@ faulthandler_fatal_error(int signum)
+     raise(signum);
+ }
+ 
++static size_t
++uitoa(size_t val, char* ss) {
++    char* start = ss;
++    size_t len = 0;
++    do {
++        *ss = '0' + (val % 10);
++        val /= 10;
++        ss++; len++;
++    } while (val);
++    reverse_string(start, len);
++    return len;
++}
++
++static void
++read_proc_exe(pid_t pid, char* buff, size_t len) {
++    char pathname[32] = {0};
++    strcpy(pathname, "/proc/");
++    size_t pos = uitoa(pid, &pathname[6]) + 6;
++    strcpy(&pathname[pos], "/exe");
++
++    ssize_t l = readlink(pathname, buff, len);
++    if (l > 0) {
++        // readlink() does not append a null byte to buf
++        buff[l] = '\0';
++    } else {
++        strncpy(buff, "unknown_program", len);
++    }
++}
++
++static void
++faulthandler_fatal_error_siginfo(int signum, siginfo_t* siginfo, void* ctx)
++{
++    const int fd = fatal_error.fd;
++    int save_errno = errno;
++
++    if (!fatal_error.enabled)
++        return;
++
++    PUTS(fd, "\n*** Signal {si_signo=");
++    dump_decimal(fd, siginfo->si_signo);
++
++    PUTS(fd, ", si_code=");
++    dump_decimal(fd, siginfo->si_code);
++    switch (siginfo->si_code) {
++    case SEGV_ACCERR: PUTS(fd, " SEGV_ACCERR"); break;
++    case SEGV_MAPERR: PUTS(fd, " SEGV_MAPERR"); break;
++    case SI_KERNEL: PUTS(fd, " SI_KERNEL"); break;
++    case SI_TIMER: PUTS(fd, " SI_TIMER"); break;
++    case SI_TKILL: PUTS(fd, " SI_TKILL"); break;
++    case SI_USER: PUTS(fd, " SI_USER"); break;
++    }
++
++    if (siginfo->si_pid > 0) {
++        PUTS(fd, ", si_pid=");
++        dump_decimal(fd, siginfo->si_pid);
++        PUTS(fd, " ");
++        char buffer[PATH_MAX] = {0};
++        read_proc_exe(siginfo->si_pid, &buffer[0], PATH_MAX - 1);
++        PUTS(fd, &buffer[0]);
++    }
++
++    PUTS(fd, ", si_uid=");
++    dump_decimal(fd, siginfo->si_uid);
++
++    PUTS(fd, "} received by proc {pid=");
++    dump_decimal(fd, getpid());
++    PUTS(fd, ", uid=");
++    dump_decimal(fd, getuid());
++    PUTS(fd, "} ***\n");
++
++    faulthandler_fatal_error(signum);
++
++    errno = save_errno;
++}
++
+ #ifdef MS_WINDOWS
+ extern void _Py_dump_hexadecimal(int fd, unsigned long value, size_t bytes);
+ 
+@@ -489,11 +566,17 @@ faulthandler_enable(PyObject *self, PyObject *args, PyObject *kwargs)
+         for (i=0; i < faulthandler_nsignals; i++) {
+             handler = &faulthandler_handlers[i];
+ #ifdef HAVE_SIGACTION
++            action.sa_flags = 0;
++#ifdef USE_SIGINFO
++            action.sa_handler = faulthandler_fatal_error_siginfo;
++            action.sa_flags |= SA_SIGINFO;
++#else
+             action.sa_handler = faulthandler_fatal_error;
++#endif
+             sigemptyset(&action.sa_mask);
+             /* Do not prevent the signal from being received from within
+                its own signal handler */
+-            action.sa_flags = SA_NODEFER;
++            action.sa_flags |= SA_NODEFER;
+ #ifdef HAVE_SIGALTSTACK
+             if (stack.ss_sp != NULL) {
+                 /* Call the signal handler on an alternate signal stack
+--- contrib/deprecated/python/faulthandler/traceback.c	(b4ffd42d61e5a2398623b2c73b681b72896da86b)
++++ contrib/deprecated/python/faulthandler/traceback.c	(1a1c8a87cb6e966c8d716a90d516ee9ed23f5bef)
+@@ -45,7 +45,7 @@ _Py_write_noraise(int fd, const char *buf, size_t count)
+ 
+    This function is signal safe. */
+ 
+-static void
++void
+ reverse_string(char *text, const size_t len)
+ {
+     char tmp;
+@@ -59,17 +59,17 @@ reverse_string(char *text, const size_t len)
+     }
+ }
+ 
+-/* Format an integer in range [0; 999999] to decimal,
++/* Format an integer in range [0; 999999999] to decimal,
+    and write it into the file fd.
+ 
+    This function is signal safe. */
+ 
+-static void
++void
+ dump_decimal(int fd, int value)
+ {
+-    char buffer[7];
++    char buffer[10];
+     int len;
+-    if (value < 0 || 999999 < value)
++    if (value < 0 || 999999999 < value)
+         return;
+     len = 0;
+     do {

contrib/deprecated/python/faulthandler/patches/02-use-in-run_test.patch

@@ -0,0 +1,43 @@
+commit 8189e0be69cc063844214e4363f5acb28fa2aad0
+author: prettyboy
+date: 2020-05-28T16:23:43+03:00
+revision: 6880919
+
+    Use faulthandler in the run_test to dump extra info in case of receiving term signal
+    
+    issue:DEVTOOLSSUPPORT-1110
+    
+    REVIEW: 1279410
+
+--- contrib/deprecated/python/faulthandler/faulthandler.c	(97a2dfa5400dd696c5eff33a9faa46526011a0ac)
++++ contrib/deprecated/python/faulthandler/faulthandler.c	(8189e0be69cc063844214e4363f5acb28fa2aad0)
+@@ -117,6 +117,13 @@ static user_signal_t *user_signals;
+ static void faulthandler_user(int signum);
+ #endif /* FAULTHANDLER_USER */
+ 
++#ifndef SI_KERNEL
++#define SI_KERNEL 0x80
++#endif
++
++#ifndef SI_TKILL
++#define SI_TKILL -6
++#endif
+ 
+ static fault_handler_t faulthandler_handlers[] = {
+ #ifdef SIGBUS
+@@ -409,6 +416,7 @@ read_proc_exe(pid_t pid, char* buff, size_t len) {
+     }
+ }
+ 
++#ifdef HAVE_SIGACTION
+ static void
+ faulthandler_fatal_error_siginfo(int signum, siginfo_t* siginfo, void* ctx)
+ {
+@@ -454,6 +462,7 @@ faulthandler_fatal_error_siginfo(int signum, siginfo_t* siginfo, void* ctx)
+ 
+     errno = save_errno;
+ }
++#endif
+ 
+ #ifdef MS_WINDOWS
+ extern void _Py_dump_hexadecimal(int fd, unsigned long value, size_t bytes);