Я хотел бы объединить массивы в 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
Этот пост предполагает следующий контекст:
lfender6445 хочет объединить два или более списков в файле YAML, и чтобы эти объединенные списки отображались как один единственный список при синтаксическом анализе.
Это может быть получено просто путем присвоения привязок YAML сопоставлениям, где желаемые списки появляются как дочерние элементы сопоставлений. Однако здесь есть предостережения (см. «Ловушки» ниже).
В приведенном ниже примере у нас есть три сопоставления ( list_one, list_two, list_three) и три якоря и псевдонима, которые ссылаются на эти сопоставления, где это необходимо.
Когда файл YAML загружается в программу, мы получаем список, который нам нужен, но может потребоваться небольшая модификация после загрузки (см. Подводные камни ниже).
list_one: & id001
- а
- б
- с
list_two: & id002
- е
- ж
- грамм
list_three: & id003
- ч
- я
- j
list_combined:
- * id001
- * id002
- * id003
## list_combined
[
[
"а",
"б",
"c"
],
[
"е",
"е",
"грамм"
],
[
"час",
"я",
"j"
]
]
Этот подход позволяет создавать объединенные списки с помощью функции псевдонима и привязки YAML.
Хотя выходной результат представляет собой вложенный список списков, его можно легко преобразовать с помощью flattenметода.
flattenметодаflatten;; Слияние / сглаживание массива массивовflatten;; http://ruby-doc.org/core-2.2.2/Array.html#method-i-flattenflatten;; https://softwareengineering.stackexchange.com/a/254676/23884Это не сработает:
слияние поддерживается только спецификациями YAML для сопоставлений, но не для последовательностей
вы полностью смешиваете вещи, имея ключ слияния, <<
за которым следует разделитель ключ / значение :и значение, которое является ссылкой, а затем продолжаете со списком на том же уровне отступа
Это не правильный 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 с их описаниями на английском (или другом естественном языке).
Вы можете объединить сопоставления, а затем преобразовать их ключи в список при следующих условиях:
some_stuff: &some_stuff
a:
b:
c:
combined_stuff:
<<: *some_stuff
d:
e:
f:
{{ combined_stuff | list }}