wth | Python Fiddle

# encoding: utf8
import logging

from datetime import timedelta
from lxml import etree, builder

import settings
from common import build_authorization_xml, put_into_envelope
from gates import statuses
from gates.inventory import ptc
from gates.utils import first
from gates.utils.book import do_book_request, get_logger_for_book_error
from gates.utils.misc import get_today
from gates.utils.xml import NamespaceHelper

logger = logging.getLogger('order')
log_book_error = get_logger_for_book_error(settings.SUPPLIER_ID, logger)

def book_seats(fare, client_data, suppliment):
    """
    takes fare, client_data and services inside of suppliment
    returns booking status and book data

:param fare: our fare
    :param dict client_data:
    {
        "email": "residentsummer@gmail.com", str
        "phone": "79261232323", str
        "personal_data": [
            {
                "first_name": "TEST", str
                "last_name": "TEST", str
                "gender": true, boolean? maybe will be changed soon
                "citizenship": "RUS", str
                "birthday": datetime.datetime,
                "passport_type": "travel-passport",
                                 or 'national-passport', 'birth-certificate'
                "passport_series": "2122", str
                "passport_number": "122111", str
                "passport_validity": datetime.datetime
            },
            ...
        ]
    }
    :param suppliment:
    :return: tuple(status, book_data)
    """

from gates.utils.misc import pp
    pp(etree.fromstring(build_request_body_xml(fare, client_data)))

url = settings.MASTERTOUR_URL
    headers = {
        'Content-Type': 'text/xml; charset=utf-8',
        'SOAPAction':
            "http://tempuri.org/IMasterTourFlightsService/CreateFlightBooking"}
    body = build_request_body_xml(fare, client_data)
    callback = extract_booking_id

return do_book_request(url, body, headers, callback, log_book_error)

def extract_booking_id(response, book_data):
    """
    add booking_id to book_data and return a (booking_status, book_data) tuple

:param Response response:
    :param dict book_data:
    :return: tuple
    """
    book_data['booking_id'] = 'super_puper_booking_id'
    error = True
    if error:
        log_book_error('some shit happened during extracting booking_id')
        return statuses.ERROR, book_data

return statuses.BOOKED, book_data

E = builder.ElementMaker(nsmap=settings.REQUEST_NSMAP)

BACKOFFICE_NSMAP = {'d5p1': settings.BACKOFFICE_NAMESPACE}
E2 = builder.ElementMaker(nsmap=BACKOFFICE_NSMAP)

I = NamespaceHelper(settings.INSTANCE_NAMESPACE)
T = NamespaceHelper(settings.MASTERTOUR_NAMESPACE)
T2 = NamespaceHelper(settings.BACKOFFICE_NAMESPACE)

def build_request_body_xml(fare, client_data):
    """
    Returns unicoded XML for book request

:param dict fare:
    :param dict client_data:
    :return: str
    """
    passengers = client_data['personal_data']

request = E.request(
        etree.XML(build_authorization_xml()),
        E(T('FlightIdentity'),
          E(T('FlightID'), fare['identity']['flight_id']),
          E(T('SearchFlightsResponseID'), fare['identity']['backoffice_id'])),
        E(T('Cost'), **{I('nil'): 'true'}),
        E2(T('Customer'),
           E2(T2('Email'), client_data['email']),
           E2(T2('FullName'),
              passengers[0]['first_name'] + ' ' + passengers[0]['last_name']),
           E2(T2('Phone'), client_data['phone']),
           ),
        *list(build_tourists_xml(passengers))
    )

# we use it in requests.post, so it shouldn't be unicode, use .tostring
    return etree.tostring(put_into_envelope(request, 'CreateFlightBooking'))

def build_tourists_xml(passengers):
    """

:param list passengers:
    :return: etree._Element
    """
    for p in passengers:
        passport_number = p['passport_series'] + p['passport_number']
        expire_date = p['passport_validity'].strftime(settings.DATE_FORMAT)
        birthday = p['birthday'].strftime(settings.DATE_FORMAT)
        # issue_date = p['passport_issue'].strftime(variables.DATE_FORMAT)
        fake_issue_date = get_today() - timedelta(days=30)
        # TODO: maybe add to front? :-(
        issue_date = fake_issue_date.strftime(settings.DATE_FORMAT)
        yield E2(T('Tourists'),
                 E2(T2('Tourist'),
                    E2(T2('Age'),  # TODO: fix
                       E2(T2('AgeCategory'), 'Adult'),
                       E2(T2('Birthday'), birthday),
                       E2(T2('Years'), **{I('nil'): 'true'})
                       ),
                    E2(T2('Citezenship'), p['citizenship']),
                    E2(T2('FirstName'), p['first_name']),
                    E2(T2('LastName'), p['last_name']),
                    E2(T2('Gender'),
                       convert_gender(p['gender'])),
                    E2(T2('PassportIssueDate'), issue_date),
                    E2(T2('PassportExpirationDate'), expire_date),
                    E2(T2('PassportType'),
                       convert_passport_type(p['passport_type'])),
                    E2(T2('PassportNumber'), passport_number),
                    E2(T2('Phone'), **{I('nil'): 'true'}),
                    )
                 )

def convert_gender(gender):
    """
    returns supplier's form of gender

:param boolean gender: # TODO: really? check, maybe let's change it to smth
    :return: str
    """
    if gender == ptc.MALE:
        return 'Male'
    elif gender == ptc.FEMALE:
        return 'Female'

def convert_passport_type(passport_type):
    """

:param str passport_type:
    :return: str
    """
    if passport_type == 'travel-passport':
        return 'Foreign'
    elif passport_type in ('national-passport', 'birth-certificate'):
        return 'Russian'

Python Fiddle

Python Cloud IDE