YAML в Python: руководство по работе с конфигурационными файлами

# Конфигурация для приложения
app:
name: My Application
version: 1.0.0
environment: production

database:
host: db.example.com
port: 5432
credentials:
username: admin
password: secure_password

features:
- login
- dashboard
- reports
- notifications: 
email: true
sms: false

{
"app": {
"name": "My Application",
"version": "1.0.0",
"environment": "production"
},
"database": {
"host": "db.example.com",
"port": 5432,
"credentials": {
"username": "admin",
"password": "secure_password"
}
},
"features": [
"login",
"dashboard",
"reports",
{
"notifications": {
"email": true,
"sms": false
}
}
]
}

# Установка PyYAML
pip install pyyaml

# Установка ruamel.yaml
pip install ruamel.yaml

import yaml

# Импорт из строки
yaml_str = """
app:
name: My Application
version: 1.0.0
"""
data = yaml.safe_load(yaml_str)
print(data) # {'app': {'name': 'My Application', 'version': '1.0.0'}}

# Экспорт в строку
new_data = {'server': {'host': 'localhost', 'port': 8080}}
yaml_output = yaml.dump(new_data, default_flow_style=False)
print(yaml_output)
# server:
# host: localhost
# port: 8080

from ruamel.yaml import YAML

yaml = YAML()
yaml.preserve_quotes = True # Сохраняет кавычки
yaml.indent(mapping=2, sequence=4, offset=2) # Настройка отступов

# Чтение с сохранением форматирования
with open('config.yaml', 'r') as file:
data = yaml.load(file)

# Изменение данных
data['app']['version'] = '1.1.0'

# Запись с сохранением форматирования
with open('config_updated.yaml', 'w') as file:
yaml.dump(data, file)

import yaml

# Чтение из файла
with open('config.yaml', 'r') as file:
config = yaml.safe_load(file)

print(config)

import yaml
import sys

def read_yaml(file_path):
try:
with open(file_path, 'r') as file:
return yaml.safe_load(file)
except yaml.YAMLError as e:
print(f"Ошибка парсинга YAML: {e}")
return None
except FileNotFoundError:
print(f"Файл {file_path} не найден")
return None
except Exception as e:
print(f"Непредвиденная ошибка: {e}")
return None

config = read_yaml('config.yaml')
if config is None:
sys.exit(1)

import yaml

# Файл содержит несколько YAML-документов, разделенных '---'
with open('multi_doc.yaml', 'r') as file:
# Получаем список всех документов
documents = list(yaml.safe_load_all(file))

# Теперь можно работать с каждым документом
for i, doc in enumerate(documents):
print(f"Документ {i+1}:")
print(doc)

import yaml
import os
import re

def env_var_constructor(loader, node):
"""Заменяет ${ENV_VAR} на значение из переменной окружения"""
value = loader.construct_scalar(node)
env_var_pattern = re.compile(r'\${([^}^{]+)}')
matches = env_var_pattern.findall(value)

if not matches:
return value

for match in matches:
env_var = os.environ.get(match)
if env_var:
value = value.replace(f'${{{match}}}', env_var)

return value

# Регистрируем конструктор для тега !env
yaml.add_constructor('!env', env_var_constructor)
yaml.add_implicit_resolver('!env', re.compile(r'\${([^}^{]+)}'), None)

# Чтение YAML с переменными окружения
with open('config_with_env.yaml', 'r') as file:
config = yaml.safe_load(file)

print(config)

database:
host: ${DB_HOST}
port: 5432
username: ${DB_USER}
password: ${DB_PASSWORD}

import yaml

# Данные для записи
data = {
'application': {
'name': 'MyApp',
'version': '2.1.0',
'settings': {
'debug': False,
'log_level': 'INFO',
'max_connections': 100
}
},
'database': {
'host': 'localhost',
'port': 5432,
'name': 'myapp_db',
'users': [
{'username': 'admin', 'permissions': ['read', 'write', 'delete']},
{'username': 'guest', 'permissions': ['read']}
]
}
}

# Запись в файл
with open('config_output.yaml', 'w') as file:
yaml.dump(data, file, default_flow_style=False)

import yaml

data = {'list': ['item1', 'item2'], 'dict': {'key1': 'value1', 'key2': 'value2'}}

# Базовая запись без форматирования (все в одну строку)
print(yaml.dump(data))
# list: [item1, item2]
# dict: {key1: value1, key2: value2}

# С отключенным flow_style (каждый элемент на новой строке)
print(yaml.dump(data, default_flow_style=False))
# dict:
# key1: value1
# key2: value2
# list:
# – item1
# – item2

# С настройкой отступов
print(yaml.dump(data, default_flow_style=False, indent=4))
# dict:
# key1: value1
# key2: value2
# list:
# – item1
# – item2

# Запись в файл с различными настройками
with open('formatted.yaml', 'w') as file:
yaml.dump(
data,
file,
default_flow_style=False,
indent=2,
sort_keys=False, # Сохранение порядка ключей (Python 3.7+)
allow_unicode=True, # Поддержка Unicode
width=80, # Максимальная ширина строки
explicit_start=True, # Добавить '---' в начале
explicit_end=True # Добавить '...' в конце
)

from ruamel.yaml import YAML

yaml = YAML()
yaml.indent(mapping=2, sequence=4, offset=2)
yaml.preserve_quotes = True
yaml.width = 80

# Чтение существующего файла
with open('original.yaml', 'r') as file:
data = yaml.load(file)

# Изменение данных
data['application']['version'] = '2.2.0'
data['database']['users'].append({
'username': 'reporter',
'permissions': ['read']
})

# Сохранение с сохранением комментариев и форматирования
with open('updated.yaml', 'w') as file:
yaml.dump(data, file)

import yaml

# Несколько документов
doc1 = {'env': 'production', 'debug': False}
doc2 = {'env': 'staging', 'debug': True}
doc3 = {'env': 'development', 'debug': True}

# Запись нескольких документов в один файл
with open('environments.yaml', 'w') as file:
yaml.dump_all([doc1, doc2, doc3], file, default_flow_style=False)

import yaml
from datetime import datetime, date
import numpy as np

# Пользовательский представитель для datetime
def datetime_representer(dumper, data):
return dumper.represent_scalar('!datetime', data.isoformat())

# Пользовательский представитель для date
def date_representer(dumper, data):
return dumper.represent_scalar('!date', data.isoformat())

# Пользовательский представитель для numpy.ndarray
def ndarray_representer(dumper, data):
return dumper.represent_sequence('!ndarray', data.tolist())

# Регистрация представителей
yaml.add_representer(datetime, datetime_representer)
yaml.add_representer(date, date_representer)
yaml.add_representer(np.ndarray, ndarray_representer)

# Данные с особыми типами
data = {
'created_at': datetime.now(),
'valid_until': date.today(),
'matrix': np.array([[1, 2], [3, 4]])
}

# Запись в файл
with open('special_types.yaml', 'w') as file:
yaml.dump(data, file, default_flow_style=False)

created_at: !datetime 2023-03-15T14:30:45.123456
valid_until: !date 2023-03-15
matrix: !ndarray
- [1, 2]
- [3, 4]

import yaml
from jsonschema import validate, ValidationError

# Определение схемы
schema = {
"type": "object",
"required": ["application", "database"],
"properties": {
"application": {
"type": "object",
"required": ["name", "version"],
"properties": {
"name": {"type": "string"},
"version": {"type": "string", "pattern": "^\\d+\\.\\d+\\.\\d+$"},
"settings": {
"type": "object",
"properties": {
"debug": {"type": "boolean"},
"log_level": {"type": "string", "enum": ["DEBUG", "INFO", "WARNING", "ERROR"]},
"max_connections": {"type": "integer", "minimum": 1, "maximum": 1000}
}
}
}
},
"database": {
"type": "object",
"required": ["host", "port", "name"],
"properties": {
"host": {"type": "string"},
"port": {"type": "integer", "minimum": 1, "maximum": 65535},
"name": {"type": "string"},
"users": {
"type": "array",
"items": {
"type": "object",
"required": ["username", "permissions"],
"properties": {
"username": {"type": "string"},
"permissions": {
"type": "array",
"items": {"type": "string"}
}
}
}
}
}
}
}
}

# Загрузка и валидация YAML
try:
with open('config.yaml', 'r') as file:
config = yaml.safe_load(file)

validate(instance=config, schema=schema)
print("Конфигурация валидна!")

# Теперь можно безопасно использовать данные
app_name = config['application']['name']
db_host = config['database']['host']

except FileNotFoundError:
print("Файл конфигурации не найден")
except yaml.YAMLError as e:
print(f"Ошибка парсинга YAML: {e}")
except ValidationError as e:
print(f"Ошибка валидации: {e.message}")

import yaml
import base64
from datetime import datetime
import numpy as np

# Определение конструкторов для пользовательских типов
def base64_constructor(loader, node):
value = loader.construct_scalar(node)
return base64.b64decode(value)

def datetime_constructor(loader, node):
value = loader.construct_scalar(node)
return datetime.fromisoformat(value)

def ndarray_constructor(loader, node):
seq = loader.construct_sequence(node)
return np.array(seq)

# Определение представителей для пользовательских типов
def base64_representer(dumper, data):
return dumper.represent_scalar('!base64', base64.b64encode(data).decode('ascii'))

def datetime_representer(dumper, data):
return dumper.represent_scalar('!datetime', data.isoformat())

def ndarray_representer(dumper, data):
return dumper.represent_sequence('!ndarray', data.tolist())

# Регистрация конструкторов и представителей
yaml.add_constructor('!base64', base64_constructor)
yaml.add_constructor('!datetime', datetime_constructor)
yaml.add_constructor('!ndarray', ndarray_constructor)

yaml.add_representer(bytes, base64_representer)
yaml.add_representer(datetime, datetime_representer)
yaml.add_representer(np.ndarray, ndarray_representer)

# Пример использования
data = {
'timestamp': datetime.now(),
'secret': b'sensitive data',
'matrix': np.array([[1, 2], [3, 4]])
}

# Запись в YAML
yaml_str = yaml.dump(data, default_flow_style=False)
print("Сериализованный YAML:")
print(yaml_str)

# Чтение из YAML
parsed_data = yaml.safe_load(yaml_str)
print("\nДесериализованные данные:")
print(f"Timestamp: {parsed_data['timestamp']}")
print(f"Secret: {parsed_data['secret']}")
print(f"Matrix:\n{parsed_data['matrix']}")

import yaml

# Пример YAML с якорями и ссылками
yaml_str = """
# Базовая конфигурация
base: &base_config
log_level: INFO
timeout: 30
retry:
enabled: true
max_attempts: 3

# Окружения
environments:
development:
<<: *base_config # Включение базовой конфигурации
debug: true
log_level: DEBUG # Переопределение значения

production:
<<: *base_config # Включение базовой конфигурации
debug: false
timeout: 60 # Переопределение значения
"""

# Парсинг YAML с обработкой якорей и ссылок
data = yaml.safe_load(yaml_str)
print("Конфигурация для разработки:")
print(data['environments']['development'])
print("\nКонфигурация для продакшена:")
print(data['environments']['production'])

# Создание YAML с якорями и ссылками
new_data = {
'defaults': {
'connection': {
'timeout': 10,
'retries': 3,
'ssl': True
}
},
'services': {
'primary': {
'connection': { # Это будет якорь
'timeout': 10,
'retries': 3,
'ssl': True
},
'host': 'primary.example.com'
},
'backup': {
'connection': { # Здесь мы хотим использовать ссылку
'timeout': 10,
'retries': 3,
'ssl': True
},
'host': 'backup.example.com'
}
}
}

# Функция для добавления якорей и ссылок
def add_anchors_and_aliases(data):
# Создаем объект YAML с поддержкой якорей
yaml = YAML()
yaml.default_flow_style = False

# Добавляем якорь к defaults.connection
data['defaults']['connection'] = yaml.yaml_anchor(
data['defaults']['connection'], 'connection_defaults'
)

# Заменяем services.primary.connection на ссылку
data['services']['primary']['connection'] = yaml.yaml_alias(
data['defaults']['connection']
)

# Заменяем services.backup.connection на ссылку
data['services']['backup']['connection'] = yaml.yaml_alias(
data['defaults']['connection']
)

return data

# Примечание: этот код требует использования ruamel.yaml
# from ruamel.yaml import YAML
# yaml_with_anchors = add_anchors_and_aliases(new_data)

import yaml
from typing import List, Optional, Dict
from pydantic import BaseModel, Field, validator

# Определение моделей данных с валидацией
class DatabaseUser(BaseModel):
username: str
permissions: List[str]

@validator('permissions')
def check_valid_permissions(cls, perms):
valid_perms = {'read', 'write', 'delete', 'admin'}
invalid_perms = set(perms) – valid_perms
if invalid_perms:
raise ValueError(f"Неизвестные права: {', '.join(invalid_perms)}")
return perms

class DatabaseConfig(BaseModel):
host: str
port: int = Field(..., gt=0, lt=65536)
name: str
users: List[DatabaseUser]

@validator('host')
def host_must_be_valid(cls, v):
if not (v.startswith('localhost') or '.' in v):
raise ValueError('Некорректный хост')
return v

class AppSettings(BaseModel):
debug: bool = False
log_level: str = Field(..., regex='^(DEBUG|INFO|WARNING|ERROR|CRITICAL)$')
max_connections: Optional[int] = Field(None, ge=1, le=1000)

class ApplicationConfig(BaseModel):
name: str
version: str = Field(..., regex=r'^\d+\.\d+\.\d+$')
settings: AppSettings

class Config(BaseModel):
application: ApplicationConfig
database: DatabaseConfig

# Чтение и валидация YAML с помощью Pydantic
try:
with open('config.yaml', 'r') as file:
yaml_data = yaml.safe_load(file)

# Создание и валидация конфигурации
config = Config(**yaml_data)
print("Конфигурация валидна!")

# Использование типизированных данных
app_name = config.application.name
db_users = [user.username for user in config.database.users]
print(f"Приложение: {app_name}")
print(f"Пользователи БД: {', '.join(db_users)}")

except Exception as e:
print(f"Ошибка: {e}")