Как объединить массивы YAML?

Я хотел бы объединить массивы в YAML и загрузить их через рубин -

some_stuff: &some_stuff
 - a
 - b
 - c

combined_stuff:
  <<: *some_stuff
  - d
  - e
  - f

Я хотел бы иметь объединенный массив как [a,b,c,d,e,f]

Я получаю сообщение об ошибке: не нашел ожидаемого ключа при разборе сопоставления блоков

Как объединить массивы в YAML?

Если целью является запуск последовательности команд оболочки, вы можете добиться этого следующим образом:

# note: no dash before commands
some_stuff: &some_stuff |-
    a
    b
    c

combined_stuff:
  - *some_stuff
  - d
  - e
  - f

Это эквивалентно:

some_stuff: "a\nb\nc"

combined_stuff:
  - "a\nb\nc"
  - d
  - e
  - f

Я использовал это на своем gitlab-ci.yml(чтобы ответить на комментарий @ rink.attendant.6 по вопросу).

Рабочий пример, который мы используем для поддержки requirements.txtчастных репозиториев из gitlab:

.pip_git: &pip_git
- git config --global url."https://gitlab-ci-token:${CI_JOB_TOKEN}@gitlab.com".insteadOf "ssh://git@gitlab.com"
- mkdir -p ~/.ssh
- chmod 700 ~/.ssh
- echo "$SSH_KNOWN_HOSTS" > ~/.ssh/known_hosts
- chmod 644 ~/.ssh/known_hosts

test:
    image: python:3.7.3
    stage: test
    script:
        - *pip_git
        - pip install -q -r requirements_test.txt
        - python -m unittest discover tests

use the same `*pip_git` on e.g. build image...

где requirements_test.txtсодержит, например,

-e git+ssh://git@gitlab.com/example/example.git@v0.2.2#egg=example

Обновление: 2019-07-01 14:06:12

• Примечание : другой ответ на этот вопрос был существенно отредактирован с обновлением альтернативных подходов .
  • В этом обновленном ответе упоминается альтернатива обходному пути в этом ответе. Он был добавлен в раздел См. Также ниже.

Контекст

Этот пост предполагает следующий контекст:

• питон 2.7
• парсер YAML на Python

Проблема

lfender6445 хочет объединить два или более списков в файле YAML, и чтобы эти объединенные списки отображались как один единственный список при синтаксическом анализе.

Решение (обходной путь)

Это может быть получено просто путем присвоения привязок YAML сопоставлениям, где желаемые списки появляются как дочерние элементы сопоставлений. Однако здесь есть предостережения (см. «Ловушки» ниже).

В приведенном ниже примере у нас есть три сопоставления ( list_one, list_two, list_three) и три якоря и псевдонима, которые ссылаются на эти сопоставления, где это необходимо.

Когда файл YAML загружается в программу, мы получаем список, который нам нужен, но может потребоваться небольшая модификация после загрузки (см. Подводные камни ниже).

пример

Исходный файл YAML

  list_one: & id001
   - а
   - б
   - с

  list_two: & id002
   - е
   - ж
   - грамм

  list_three: & id003
   - ч
   - я
   - j

  list_combined:
      - * id001
      - * id002
      - * id003

Результат после YAML.safe_load

## list_combined
  [
    [
      "а",
      "б",
      "c"
    ],
    [
      "е",
      "е",
      "грамм"
    ],
    [
      "час",
      "я",
      "j"
    ]
  ]

Ловушки

• этот подход создает вложенный список списков, который может не соответствовать желаемому результату, но его можно обработать с помощью метода сглаживания.
• в обычные предостережения YAML якорей и псевдонимы применяются для уникальности и порядка декларирования

Вывод

Этот подход позволяет создавать объединенные списки с помощью функции псевдонима и привязки YAML.

Хотя выходной результат представляет собой вложенный список списков, его можно легко преобразовать с помощью flattenметода.

Смотрите также

Обновленный альтернативный подход @Anthon

• Посмотреть альтернативный подход

Примеры flattenметода

• Javascript flatten;; Слияние / сглаживание массива массивов
• Рубин flatten;; http://ruby-doc.org/core-2.2.2/Array.html#method-i-flatten
• Python flatten;; https://softwareengineering.stackexchange.com/a/254676/23884

Это не сработает:

1. слияние поддерживается только спецификациями YAML для сопоставлений, но не для последовательностей

2. вы полностью смешиваете вещи, имея ключ слияния, << за которым следует разделитель ключ / значение :и значение, которое является ссылкой, а затем продолжаете со списком на том же уровне отступа

Это не правильный YAML:

combine_stuff:
  x: 1
  - a
  - b

Таким образом, ваш пример синтаксиса даже не имеет смысла в качестве предложения по расширению YAML.

Если вы хотите сделать что-то вроде объединения нескольких массивов, вы можете рассмотреть такой синтаксис, как:

combined_stuff:
  - <<: *s1, *s2
  - <<: *s3
  - d
  - e
  - f

где s1, s2, s3являются якорями на последовательностях (не показаны) , которые вы хотите объединить в новую последовательность и затем иметь d, eи f приложенные к этому. Но YAML сначала определяет глубину такого рода структур, поэтому во время обработки ключа слияния нет реального контекста. У вас нет доступного массива / списка, к которому вы могли бы прикрепить обработанное значение (закрепленную последовательность).

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

Лучшим решением IMO было бы использовать теги для загрузки структур данных, которые выполняют сглаживание за вас. Это позволяет четко обозначать, что нужно развернуть, а что нет, и дает вам полный контроль над тем, выполняется ли это выравнивание во время загрузки или во время доступа. Какой из них выбрать, зависит от простоты реализации и эффективности использования времени и места для хранения. Это тот же компромисс, который необходимо сделать для реализации ключевой функции слияния, и не существует единого решения, которое всегда было бы лучшим.

Например, моя ruamel.yamlбиблиотека использует слияния грубой силы во время загрузки при использовании своего безопасного загрузчика, что приводит к объединению словарей, которые являются обычными dicts Python. Это слияние должно выполняться заранее и дублирует данные (неэффективное использование пространства), но при этом выполняется быстрый поиск значений. При использовании загрузчика туда и обратно вы хотите иметь возможность выгружать слияния без объединения, поэтому их нужно хранить отдельно. Такая структура данных, как dict, загруженная в результате загрузки туда и обратно, занимает мало места, но имеет более медленный доступ, поскольку ему нужно попытаться найти ключ, не найденный в самом dict при слияниях (и он не кэшируется, поэтому он нужно делать каждый раз). Конечно, такие соображения не очень важны для относительно небольших файлов конфигурации.

Следующее реализует схему слияния для списков в Python с использованием объектов с тегом, flatten которые на лету рекурсируют в элементы, которые являются списками и помечены toflatten. Используя эти два тега, вы можете получить файл YAML:

l1: &x1 !toflatten
  - 1 
  - 2
l2: &x2
  - 3 
  - 4
m1: !flatten
  - *x1
  - *x2
  - [5, 6]
  - !toflatten [7, 8]

(использование последовательностей стилей потока и блока совершенно произвольно и не влияет на загруженный результат).

При итерации по элементам, которые являются значением для ключа, m1это "рекурсивно" превращается в последовательности, помеченныеtoflatten , но отображает другие списки (с псевдонимами или без них) как один элемент.

Один из возможных способов достижения этого с помощью кода Python:

import sys
from pathlib import Path
import ruamel.yaml

yaml = ruamel.yaml.YAML()


@yaml.register_class
class Flatten(list):
   yaml_tag = u'!flatten'
   def __init__(self, *args):
      self.items = args

   @classmethod
   def from_yaml(cls, constructor, node):
       x = cls(*constructor.construct_sequence(node, deep=True))
       return x

   def __iter__(self):
       for item in self.items:
           if isinstance(item, ToFlatten):
               for nested_item in item:
                   yield nested_item
           else:
               yield item


@yaml.register_class
class ToFlatten(list):
   yaml_tag = u'!toflatten'

   @classmethod
   def from_yaml(cls, constructor, node):
       x = cls(constructor.construct_sequence(node, deep=True))
       return x



data = yaml.load(Path('input.yaml'))
for item in data['m1']:
    print(item)

который выводит:

1
2
[3, 4]
[5, 6]
7
8

Как видите, вы можете видеть, что в последовательности, которая требует выравнивания, вы можете использовать псевдоним для помеченной последовательности или вы можете использовать помеченную последовательность. YAML не позволяет делать:

- !flatten *x2

, т. е. пометить закрепленную последовательность, так как это существенно превратит ее в другую структуру данных.

Использование явных тегов - это IMO лучше, чем какая-то магия, как с ключами слияния YAML <<. Если ничего другого, вам теперь придется пройти через обручи, если у вас есть файл YAML с сопоставлением, у которого есть ключ, <<который вы не хотите действовать как ключ слияния, например, когда вы делаете сопоставление операторов C с их описаниями на английском (или другом естественном языке).

Если вам нужно объединить только один элемент в список, вы можете сделать

fruit:
  - &banana
    name: banana
    colour: yellow

food:
  - *banana
  - name: carrot
    colour: orange

что дает

fruit:
  - name: banana
    colour: yellow

food:
  - name: banana
    colour: yellow
  - name: carrot
    colour: orange

Вы можете объединить сопоставления, а затем преобразовать их ключи в список при следующих условиях:

• если вы используете шаблоны jinja2 и
• если порядок товара не важен

some_stuff: &some_stuff
 a:
 b:
 c:

combined_stuff:
  <<: *some_stuff
  d:
  e:
  f:

{{ combined_stuff | list }}