Пользовательский тег PyYAML для кортежа кортежей

Начнем с вопроса 2: 2002 год был годом, когда этот вид тега был введен в версию черновик YAML 1.0

Вопрос 1 сложнее. Если вы это сделаете:

from __future__ import print_function

import yaml

lol = [[1,2], [3,4]]  # list of lists
print(yaml.dump(lol))

вы получите (A):

[[1, 2], [3, 4]]

Но на самом деле это сокращение от (B):

!!seq [
  !!seq [
    !!int "1",
    !!int "2",
  ],
  !!seq [
    !!int "3",
    !!int "4",
  ],
]

что является сокращением от (C):

!<tag:yaml.org,2002:seq> [
  !<tag:yaml.org,2002:seq> [
    !<tag:yaml.org,2002:int> "1",
    !<tag:yaml.org,2002:int> "2",
  ],
  !<tag:yaml.org,2002:seq> [
    !<tag:yaml.org,2002:int> "3",
    !<tag:yaml.org,2002:int> "4",
  ],
]

Все A, B и C загружаются в исходный список list, потому что seq (uence) является встроенным типом.

Я не думаю, что расширение синтаксиса yaml (например, (), указывающее кортеж, было бы хорошей идеей. Чтобы минимизировать теги, вы уменьшите свой пример до:

yaml_in = "!tuple [ !tuple [1, 2], !tuple [3, 4]]"

и добавляем конструктор:

yaml.add_constructor("!tuple", construct_tuple)

но это подталкивает к созданию функции construct_tuple. Один для последовательности (в constructor.py):

def construct_yaml_seq(self, node):
    data = []
    yield data
    data.extend(self.construct_sequence(node))

Но вы не можете просто заменить там [] на (), поскольку изменение кортежа путем его расширения не сработает (причина этого двухэтапного создания с yield, например, в том, чтобы разрешить циклические ссылки в сложных типах, таких как последовательность и сопоставление).

Вы должны определить класс Tuple(), который ведет себя как список до тех пор, пока он не будет «заблокирован» (что вы сделали бы в конце конструкции), и с этого момента он должен вести себя как кортеж (т.е. без каких-либо модификаций). Следующее делает это без подкласса yaml.YAMLObject, поэтому вы должны явно предоставить и зарегистрировать конструктор и представитель класса.

class Tuple(list):

    def _lock(self):
        if hasattr(self, '_is_locked'):
            return
        self._is_locked = True
        self.append = self._append
        self.extend = self._extend

    def _append(self, item):
        raise AttributeError("'Tuple' object has no attribute 'append'")

    def _extend(self, items):
        raise AttributeError("'Tuple' object has no attribute 'extend'")

    def __str__(self):
        return '(' + ', '.join((str(e) for e in self)) + ')'

    # new style class cannot assign something to special method
    def __setitem__(self, key, value):
        if getattr(self, '_is_locked', False):
            raise TypeError("'Tuple' object does not support item assignment")
        list.__setitem__(self, key, value)

    def __delitem__(self, key, value):
        if getattr(self, '_is_locked', False):
            raise TypeError("'Tuple' object does not support item deletion")
        list.__delitem__(self, key, value)

    @staticmethod
    def _construct_tuple(loader, data):
        result = Tuple()
        yield result
        result.extend(loader.construct_sequence(data))
        result._lock()

    @staticmethod
    def _represent_tuple(dumper, node):
        return dumper.represent_sequence("!tuple", node)

# let yaml know how to handle this
yaml.add_constructor("!tuple", Tuple._construct_tuple)
yaml.add_representer(Tuple, Tuple._represent_tuple)

Имея это на месте, вы можете:

yaml_in = "!tuple [ !tuple [1, 2], !tuple [3, 4]]"
#yaml_in = "!tuple [1, 2]"

data = yaml.load(yaml_in)
print(data)
print(data[1][0])
print(type(data))

получить:

((1, 2), (3, 4))
3
<class '__main__.Tuple'>

Это не настоящий tuple, но он не допускает действий, подобных list. Все следующие действия вызывают соответствующую ошибку:

# test appending to the tuple,
try:
    data.append(Tuple([5, 6]))
except AttributeError:
    pass
else:
    raise NotImplementedError
# test extending the tuple,
try:
    data.extend([5, 6])
except AttributeError:
    pass
else:
    raise NotImplementedError
# test replacement of an item
try:
    data[0] = Tuple([5, 6])
except TypeError:
    pass
else:
    raise NotImplementedError
# test deletion of an item
try:
    del data[0]
except TypeError:
    pass
else:
    raise NotImplementedError

И, наконец, вы можете:

print(yaml.dump(data, default_flow_style=True))

для следующего вывода:

!tuple [!tuple [1, 2], !tuple [3, 4]]

Если вы действительно хотите !tuple [[1, 2], [3, 4]] создать кортеж кортежей, вы можете сделать это, сохранив состояние контекста в классе Baseloader yaml и переопределив метод, создающий объект python из последовательностей в кортежи или списки в зависимости от контекста. Вероятно, это должен быть стек состояний контекста, чтобы разрешить вложенное использование! Tuple, а также не-вложенное использование и некоторое явное переопределение для получения списков внутри кортежей при использовании !!seq в качестве тега.

Возможно, я не проверял Tuple() на полноту, а реализовал только те ограничения, которые tuple по сравнению с list, которые сразу пришли в голову.
Я тестировал это с моей расширенной версией PyYAML: ruamel.yaml, но это должно работать точно так же в самом PyYAML.