Архив метки: 2.x

2.x/stdlib — parser. Документация

parser — Доступ к распарсенным деревьям Python

Модуль parser предоставляет интерфейс для внутреннего парсера Python и компилятора байт-кода. Основная цель этого интерфейса — позволить коду на Python редактировать дерево выражений Python и создавать из него выполняемый код. Это лучше чем пытаться разобрать и модифицировать произвольный фрагмент кода на Python because parsing is performed in a manner identical to the code forming the application. Кроме того, это быстрее.
Note

 

Начиная с 2.5, более удобно влезть в этапы генерации Abstract Syntax Tree (AST) и компиляции, при помощи подуля ast.
Модуль parser экспортирует имена, документированные тут, заменяя “st” на “ast”; это наследие ещё тех времён, когда не было другого AST и никак не связано с AST из Python 2.5. Кроме того, это ещё и причина того, что именованные аргументы функций называются ast, а не st. Функции “ast” убраны в Python 3.
Есть несколько вещей, которые надо иметь ввиду при работе с этим модулем. Данная документация не является руководством по редактированию распарсенного дерева кода Python, но некоторые примеры использования модуля parser Вы тут встретите.
Особенно важно хорошее понимание обработки грамматики Python внутренним парсером. Более подробная информация о синтаксисе языка находится в The Python Language Reference. Сам парсер создаётся из грамматических спецификаций, определённых в файлеGrammar/Grammar в стандартной постановке Python. Распарсенные деревья сохранённые в объектах ST, создаваемых этим модулем, являются актуальным выводом внутреннего парсера, когда они создаются функциями expr() или suite(), описанными ниже. Объекты ST создаваемые функцией sequence2st() имеют схожую структуру. Имейте ввиду, что значения последовательностей, которые “корректны” могут отличаться для разных версий Python, если отличается формальная грамматика языка. Однако, перенос кода из одной версии Python в другую всегда будет создавать корректное распарсенное дерево для данной
версии, с тем лишь ограничением, что переход на более старую версию не будет поддерживать более новые конструкции языка. Распарсенные деревья, обычно, не совместимы меду разными версиями, тогда как для исходного кода гарантируется forward-compatible.
Каждый элемент последовательности, возвращаемый функциями st2list() или st2tuple() имеет простую форму. Последоватльность, представляющая нетерминальные элементы грамматики всегда имеет длину больше одного. Первый элементом является число, которое идентифицирует выражение грамматики. Эти числа имеют символические имена, определённые в заголовочном файле CInclude/graminit.h и в модуле Python symbol. Каждый дополнительные элемент последовательности представляет компонент выражения, который был распознан в исходной строке: они всегда являются последовательносями той же формы, что и родительская последовательность. Важный аспект этой структуры, который надо иметь ввиду, что ключевые слова, используемые для идентификации типа родительского узла, такое как if в if_stmt, включается в узел дерева без дополнительной трактовки. Например, ключевое слово if представляется кортежем (1, 'if'), где 1 — числовое значение, ассоциированное с токеном NAME, который также включает переменные и функции, определённые пользователем. В альтернативной возвращаемой форме, когда требуется информация о номере строки, тот же самый токен может быть представлен как (1, 'if', 12), где 12 — номер строки, в которой был найден терминальный символ.
Терминальные элементы представляются похожим образом, но без дочерних элементов и без дополнений в виде исходного кода, который был идентифицирован. Опять же смотрите выше пример для ключевого слова if. Различные типы терминальных символов определены в заголовочном файле C Include/token.h и модуле Python token.
Объекты ST не требуются для поддержки функциональности этого модуля, но они используются для трёх целей: чтобы позволить приложению снизить стоимость обработки сложных распарсенных деревьев, чтобы предоставить представление распарсенного дерева, которое потребляет меньше памяти, чем представление при помощи списков или кортежей, и для того, чтобы проще сождавать дополнительные модули на С, которые манипулируют этими деревьями. Простой класс обёртка может быть создан в Python для того, чтобы скрыть использ

Скачивание файла с Google Docs и преобразование ods в csv

Возникла передо мной такая задача: мы храним таблицу соответсвия мака, ip и имени ПК в гуглодоксе, она и поддерживается в актуальном состоянии. DHCP сервер работает на FreeBSD, соответственно файл с настройками сервера вполне себе текстовый. И чтобы не обновлять данные и там и там был сделан скриптик. Наверняка можно было бы сделать проще, в некоторых случаях даже понятно как (например в функции csv2dhcp), но для небольшой таблицы я заморачиваться не стал.

Для работы понадобится pyquery и второй питон (считаем, что это у Вас уже есть). Кроме того, нам нужна библиотека для доступа к Google API.
Читать →

Запуск MoinMoin2.0 под Apache22 на FreeBSD9

Предполагается, что moin2 расположен в /home/ishayahu/moin-2.0
Для начала нам надо установить сам апач и mod_wsgi, чтобы он мог работать с Flask (я использую для этого portmaster (/usr/ports/ports-mgmt/portmaster)):
#portmaster www/apache22 www/mod_wsgi
Далее создаём файл moin-2.0/moinmoin2.wsgi, чтобы апач мог запускать Flask приложение:
#для работы mod_wsgi, так как он блокирует sys.stdout
import sys
sys.stdout=sys.stderr
# Собственно для Flask
from MoinMoin.app import create_app
application = create_app('/home/ishayahu/moin-2.0/wikiconfig.py')

Теперь будем настроивать апач. Создадим конфигурацию виртульного хоста: файл /usr/local/etc/apache22/Includes/wiki.local.conf

    ServerAdmin meoc-it@mail.ru
    DocumentRoot /home/ishayahu/moin-2.0
    ServerName wiki.local
    ServerAlias www.wiki.local
    ErrorLog /home/ishayahu/wiki.local-error_log
    CustomLog /home/ishayahu/wiki.local-access_log combined
    WSGIDaemonProcess moinmoin2 user=ishayahu group=ishayahu threads=5
    WSGIScriptAlias / /home/ishayahu/moin-2.0/moinmoin2.wsgi
   
        WSGIProcessGroup moinmoin2
        WSGIApplicationGroup %{GLOBAL}
        Order deny,allow
        Allow from all
   
Настроиваем запуск вики как сервиса. Создаём файл для запуска апача в виртуальном окружении (нужно виртуальное окнужение для работы moin; не забыть chmod +x /root/start_wiki) /root/start_wiki:
#!/bin/bash
source /home/ishayahu/moin-2.0/env/bin/activate
/usr/local/etc/rc.d/apache22 onestart
Создаём файл для регистрации вики как сервиса /etc/rc.d/wiki (не забыть chmod +x /etc/rc.d/wiki):
#!/bin/sh
#
# PROVIDE: wiki
# REQUIRE: LOGIN
# KEYWORD: shutdown

. /etc/rc.subr

name=»wiki»
start_cmd=»${name}_start»
stop_cmd=»/usr/local/etc/rc.d/apache22 stop»

wiki_start()
{
    /bin/bash /root/start_wiki
}

load_rc_config $name
run_rc_command «$1»
И в /etc/rc.conf:
wiki_enable=»YES»

Автор: Ishayahu Lastov

Продвинутое руководство по логированию (Перевод)

Библиотека logging использует модульный подход и предлагает несколько категорий компонентов: loggers, handlers, filters, и formatters.
  • Logger представляет интерфейс, который использует непосредственно код приложения.
  • Handler посылает запись лога (созданную logger'ом) в соответствующее расположение.
  • Filter позволяет определить, какую запись лога выводить.
  • Formatter определяет расположение записи лога в итоговом выводе.
Информация логирования передаётся между logger, handler, filter и formatter в экземпляре LogRecord.
Логирование осуществляется вызовом методов экземпляра класса Logger (тут и далее он будет называться loggers). Каждый экземпляр имеет своё имя и эти имена располагаются в иерархии пространства имён, используя точки в качестве разделителей. Например, logger с именем ‘scan’ является родительским logger'ом для logger'ов ‘scan.text’, ‘scan.html’ и ‘scan.pdf’. Имена logger'ов могут быть любыми, как Вы хотите, и отображают место, где было создано сообщение лога.
Общепринято использовать  для имён logger'ов имена модулей:
logger = logging.getLogger(__name__)
В таком случае имя logger'a соответствует иерархии пакетов/модулей и интуитивно становится понято, где именно события логируются уже из имени logger'a.
Корень иерархии logger'ов называется root logger. Этот тот logger, который используется функциями debug(), info(), warning(), error() и critical(), которые просто вызывают одноимённые меоды root logger'a. Функции и методы имеют одну и ту же подпись. Имя root logger’а отображается как ‘root’ в выводе логов.
Конечно же возможно логировать сообщения в разные места. Вы можете записывать сообщения в файлы, передавать по HTTP GET/POST, email'y через SMTP, сокеты или OS-специфичные механизмы логирования, такие как syslog или Windows NT event log. Место, куда отправляются логи, определяется классами handler. Вы можете создать свой собственный класс направления логов, если у Вас есть какие-то свои особые потребности.
По умолчанию место направления не задано для сообщение логов. Вы можете определить его при помощи basicConfig(), как в примерах руководства. Если Вы вызываете функции debug(), info(), warning(), error() и critical(), они будут проверять, задано ли это место, и если оно не задано, то вывод направляется в консколь (sys.stderr) и используется формат отображения сообщений по умолчанию.
Формат отображения, задаваемый по умолчанию в basicConfig() для сообщений:
severity:logger name:message
Вы можете изменить его передав строку формата в basicConfig(
) в аргументе format. Более подробно все опции форматирования описаны в Formatter Objects.

Поток форматирования

иллюстрация тут

Перемещение информации лога между logger'ами и handler'ами иллюстрирован диаграммой по ссылке выше.

Logger'ы

Объекты Logger имеют тройную работу. Во-первых, они предоставляют методы коду приложения, так что приложение может в процессе выполнения логировать сообщения. Во-вторых, объекты logger определяют какие сообщения логов будут работать на этом уровне (объекте фильтра). В третих, объекты logger передают подходящие сообщения логов всем заинтересованным handler'ам.
Чаще всего используемые методы объекта logger относятся к одной из двух категорий: настройка и отправка сообщений.
Вот наиболее часто использемые методы настройки:

  • Logger.setLevel() определяет минимальный уровень сообщений, которые будут обработаны; debug — минимальный встроенный уровень, а critical — максимальный. Например, если установлен уровень INFO, logger будет обрабатывать сообщения уровня INFO, WARNING, ERROR и CRITICAL и игнорировать сообщения уровня DEBUG.
  • Logger.addHandler() и Logger.removeHandler() добавляют и удаляют объекты handler из объекта logger. Handler'ы более подробно обсуждены в Handlers.
  • Logger.addFilter() и Logger.removeFilter() добавляют и удалют объекты filter из объекта logger. Filter'ы более подробно обсуждаются в Filter Objects.

Вам не нужно вызывать эти методы каждый раз для каждого logger, который Вы создаёте. Смотрите последние два абазца этого раздела.
Когда объект logger настроен, следующие методы создают сообщения логов:

  • Logger.debug(), Logger.info(), Logger.warning(), Logger.error() и Logger.critical() создают записи логов с сообщением и уровнем, соответствующим названию метода. Сообщение — это строка формата, которая может содержать стандартный синтаксис подстановки, такой как %s, %d, %f. Остальные аргументы — список объектов, которые должны быть подставлены в поля подстановки сообщения. В соответствии с **kwargs, методы логирования учитывают только именованый аргумент exc_info и использует его для того, чтобы определить, логировать ли информацию об исключении.
  • Logger.exception() создаёт запись в логе, аналогичную методу Logger.error(). Разница в том, что Logger.exception() делает дамп трасировки стека при вызове. Вызывайте этот метод только из обработчика исключений.
  • Logger.log() принимает уровень логирования в качестве аргумента. В этом случае приходится больше печатать, но зато это способ залогировать события пользовательского уровня.

getLogger() возвращает ссылку на экземпляр logger'а с именем, если оно задано, или root, если нет. Имена представляют из себя иерархическую структуру с точками в качестве разделителей. Множественные вызовы getLogger() с одним и тем же имененм будут возвращать ссылку на один и тот же объект logger'а. Logger'ы, находящиеся ниже в иерархии являются дочерними для logger'ов, которые находятся выше. Например, для logger'а с имененм foo logger'ы с именами foo.bar, foo.bar.baz и foo.bam будут дочерними.
Logger'ы поддерживают концепцию эффективного уровня. Если для logger'а не задан уровень явно, то используется уровень его родителя. Если и его родитель не имеет заданного уровня — смотрится родитель родителя, и так далее. Корневой logger всегда имеет явно заданный уровень (по умолчанию это WARNING). При решении вопроса обрабатывать ли событи используется именно эффективный уровень.
Дочерние logger'ы распространяют сообщения handler'ам, связанным с родительским logger'ом. Из-за этого нет необходимости определять и настраивать handler'ы для всех logger'ов в приложении. Но важно сконфигурировать handler'ы для logger'ов верхнего уровня и уже потом создавать при необходимости дочерние logger'ы. (Однако, распространение сообщений можно отключить, задав значением атрибута propagate logger'a равным False.)

Handler'ы

Объекты Handler отвечают за отправку соответствующего сообщения (соответствующего уровня) к его месту назначения, определённого в handler'e. Объекты logger могут добавить себе ноль или более handler'ов при помощи метода addHandler(). Например, приложение может хотеть отправлять все сообщения в файл логов, сообщения уровня ошибки и выше в stdout, а все критические сообщения отправлять на почту. Этот сценарий требует три handler'a, каждый из которых отвечает за отправку сообщений определённого уровня в определённое место.
Стандартная библиотека включает в себя несколько типов handler'ов (см Useful Handlers); это руководство по большей части использует в примерах StreamHandler и FileHandler.
Есть несколько методов у handler'a для разработчиков приложений, о которых стоит позаботиться. Методы, которые нужны тем, кто будет пользоваться встроенными handler'ами (то есть, не будет использовать самописные) следующие:

  • Метод Handler.setLevel() аналогичен методу объекта logger, он определяет минимальный уровень, который будет направлен в соответствующее место. Зачем нужно два метода setLevel()? Уровень, заданный в logger'e определяет уровень сообщений, который будет передан в handler'ы. Уровень, заданный в каждом handler'e определяет сообщения, которые этот handler будут посылать.
  • setFormatter() определяет объект Formatter, который будет использовать этот handler.
  • addFilter() и removeFilter() соответственно добавляют и удаляют объекты фильтров из handler'a.

Код приложения не должен напрямую инициализировать и использовать экземпляры Handler. Вместо этого, класс Handler является базовым классом, который определяет интерфейс, которым должны обладать все handler'ы и определяет некоторое поведение по умолчанию, которое могут использовать дочерние классы (или переопределять их).

Formatter'ы

Fabric: Операции

Операции — функции, которые используются в fabfile и в другом «не ядерном» коде, таком как run()/sudo().

fabric.operations.get(remote_path, local_path = None)

Скачивает один или более файлов с удалённого узла.

get возвращает итерируемый объект, содержащий абсолютные пути ко всем загруженным файлам, который будет пустым, если local_path будет объектом StringIO (ниже мы познакомимся со StringIO более подробно). Этот объект так же выставляет атрибут .failed, содержащий все удалённые пути, загрузка с которых не удалась, и .succeeded, эквивалентный not .failed.
remote_path — это удалённый файл или каталог для загрузки, который может использовать синтаксис подстановки оболочки, например, /var/log/apache2/*.log, и тильды будут замещены на удалённую домашнюю директорию. Относительные пути будут рассматриваться относительно домашнего каталога удалённого пользователя или текущего рабочего каталога, если используются в команде cd. Если удалённый genm указывает на каталог, то он будет рекурсивно скачан.
local_path — локальный путь, куда будут загружены файлы. Если путь относительный, он будет трактоваться относительно текущей рабочей директории. Он может быть построен при помощи стандартной вставки на основании словарей со следующими переменными:
  • host: Значение env.host_string, например, myhostname или user@myhostname-222 (двоеточие между именем узла и номером порта заменено на тире для увеличения совместимости с разными ФС)
  • dirname: Часть каталога из удалённого пути, т.е. src/projectname в /src/projectname/utils.py
  • basename: Часть файла из удалённого пути, т.е. utils.py в /src/projectname/utils.py 
  • path: Полный удалённый путь: /src/projectname/utils.py 
Примечание
Если remote_path — абсолютный путь, то только подкаталоги будут созданы локально и переданы в  переменные выше. Так, например, get('/var/log', '%(path)s') будет записывать файлы как apache2/access.log,postgresql/8.4/postgresql.log и т.д. в локальный рабочий каталог. Он не будет записывать файлы как var/log/apache2/access.log.
Кроме того, когда скачивается один файл, %(dirname)s и %(path)s не имеют особого смысла и будут, соответственно иметь пустое значение и значение, равное %(basename)s. Таким образом, вызов вроде get('/var/log/apache2/access.log', '%(path)s') сохранит локальный файл под именем access.log, а не var/log/apache2/access.log.
Такое поведение предназначено для соответствия программе командной строки scp.
Если значение не задано, то local_path получает значение "%(host)s/%(path)s" чтобы это было безопасно для использования на нескольких узлах.
Предупреждение
Если ваш аргумент local_path не содержит %(host)s и ваш вызов get запускается на нескольких хостах, ваши локальные файлы будут перезаписаны при каждом удачном запуске!
Если local_path не использует вышеозначенные переменные (т.е. это просто явный путь) он будет действовать похоже командам scp или cp, перезаписывая при необходимости существующие файлы, скачивая их в нужное место (т.е. get('/path/to/remote_file.txt', 'local_directory') создаст local_directory/remote_file.txt) и т.п.
local_path может быть и файлоподобным объектом, например, результатом open('path', 'w') или экземпляром StringIO.
Примечание
Попытка выполнить get каталога в файлоподобный объект некорректна и вернёт ошибку.
Примечание
Эта функция будет использовать seek и tell для перезаписи всего содержимого файлоподобного объекта, чтобы это соответствовало поведению put (который тоже использует весь файл). Однако, в отличие от put, указатель файла не будет восстановлен в предыдущую локацию, так как это достаточно бессмыслен
но и/или даже не возможно.
Примечание
Из-за того, как работают наши слои SSH, временные файлы всё равно будут записаны во временный файл на диске, даже если Вы передаёте в качестве аргумента local_path файлоподобный объект или StringIO. Временные файлы будут удалены, но имейте это в виду и не ожидайте прямой передачи данных в память. (Мы надеемся исправить это в будущем, чтобы дать возможность прямой передачи данных в память.)
Примечание
Если файлоподбный объект, такой как StringIO имеет атрибут name, он будет использован в выводе Fabric, вместо простого  obj>
Изменения в версии 1.0: Теперь есть отдельный удалённый рабочий каталог, с которым работает cd, и локальный рабочий каталог, с которым работает lcd.
Изменения в версии 1.0: Теперь можно использовать файлоподобные объекты в качестве аргумента local_path.
Изменения в версии 1.0: local_path может теперь содержать переменные genb и узла.
Изменения в версии 1.0: В аргументе remote_path можно использовать каталоги, которые будут рекурсивно загружены.
Изменения в версии 1.0: Возвращает итерируемый объект, содержащий локальные пути, содержащий атрибуты .failed и.succeeded.
Изменения в версии 1.5: Использует атрибут name файлоподобного объекта для вывода лога
fabric.operations.local(command, capture=False, shell=None)
Выполняет команду на локальной системе.
local — это лишь оболочка вокруг использования встроенного модуля Python subprocess с shell=True. Если Вам надо сделать что-то особое — используйте модуль subprocess напрямую.
shell передаётся напрямую в аргумент execute subprocess.Popen‘а (что определяет используемую локально оболочку.) В соответствии со документацией, на Unix по умолчанию используется /bin/sh, так что эта опция полезна для установки других значений, например, /bin/bash.
local на данный момент не способен одновременно вводить и выводить информация, в отличие от run/sudo. Именованный аргумент capture позволяет переключаться между выводом и вводом при необходимости, значение по умолчанию — False.
Когда capture=False, локальные ввод и вывод  subprocess’a направляется напрямую на ваш терминал, хотя Вы можете использовать глобальные настройки вывода output.stdout и output.stderr, чтобы спрятать один из них или оба. В этом режиме возвращаемые значения stdout/stderr всегда будут пустыми.
Если capture=True, то Вы не увидите никакого вывода на вашем терминале, но возвращаемое значение будет храниться в stdout/stderr.
В любом случае, как и при запуске run и sudo, возвращаемое значение содержит атрибуты return_code, stderr, failed и succeeded. Более подробно это описано в run.
local будет учитывать менеджер контекста lcd, позволяющий Вам контролировать текущий рабочий каталог вне зависимости от удалённого каталога (которым управляет cd).
Изменения в версии 1.0: Добавлены атрибуты succeeded и stderr.
Изменения в версии 1.0: Теперь учитывает менеджер контекста lcd.
Изменения в версии 1.0: Значение по умолчанию для capture изменено с True на False.
fabric.operations.open_shell(command=None)
Вызывает интерактивную оболочку на удалённой системе.
Если передан аргумент command, то он будет передан  по каналу перед тем, как передать управление пользователю.
Эта функция чаще всего используется когда Вам нужно взаимодействовать с серьёзными командами оболочки или набором команд, например, при отладке или когда нужно провести полностью интерактивное восстановление при ошибке  удалённой программы.
Следует иметь ввиду, что интерактивная оболочка в середине скрипта и не является замено
й команды run, которая тоже может взаимодействовать с удалённым хостом (хотя только во время выполнения переданной команды) и подразумевает решение большего количества программных проблем, таких как обработка ошибок и захват ввода/вывода.
Конкретнее, open_shell предоставляет больше интерактивности, чем run, использование полноценной удалённой оболочки не позволяет Fabric определить, завершилась ли программа с ошибкой и заполняет ввод/вывод вводом/выводом оболочки, таким как заставки входа, приглашения и т.д.
Таким образом, эта функция не имеет возвращаемого значения и не вызывает обработку ошибок Fabric, если какая-либо удалённая программа завершилась с ошибкой.
Начиная с версии 1.0.
fabric.operations.prompt(text, key=None, default='', validate=None)
Выдаёт пользователю запрос с текстом text и возвращает полученное значение (как raw_input).
Для удобства к text будет добавлен одиночный пробел, ничего больше. Таким образом Вы можете завершить свой запрос вопросительным знаком или двоеточием, например prompt("What hostname?").
Если указан key, ввод пользователя и будет сохранён как env. и возвращён этой функцией prompt. Если этот ключ уже существует в env, то его значение  будет перезаписано и пользователю будет выдано предупреждение.
Если передан параметр default, то он будет выведен в квадратных скобках и будет использоваться в случае, если пользователь ничего не введёт (т.e. нажмёт Enter без ввода текста). По умолчанию значением default является пустая строка. Если значением является не пустая строка, то к нему будет добавлен пробел, так что вызов prompt("Каково имя узла?", default="foo") приведёт к отображению Каково имя узла? [foo]  (с пробелом после [foo].)
Опциональный именованный аргумент validate может быть вызываемым объектом или строкой:
  • Если это вызываемый объект, то он будет вызван с полученной от пользователя строкой и должен вернуть значение для сохранения в случае успеха. При ошибке он должен вызвать исключение с сообщением, которое будет показано пользователю.
  • Если это строка, то значение, переданное в параметре validate используется как регулярное выражение. Поэтому рекомендуется использовать «сырые» строки. Обратите внимание, что регулярное выражение будет (в любом случае?) требовать полного совпадения.
В любом случае prompt будет перезапрашивать ввод от пользователя до тех пор, пока не пройдёт валидация (или пользователь не нажмёт Ctrl-C).
Примечание
prompt учитывает env.abort_on_prompts и будет вызывать abort вместо запроса, если этот флаг установлен в True. Если Вы хотите заблокировать ввод пользователя безусловно, но в этом случае запросить информацию у пользователя — оберните код при помощи settings.
Примеры:

# Простейшая форма:


environment = prompt('Please specify target environment: ')



# Со значением по умолчанию и сохранением как env.dish:


prompt('Specify favorite dish: ', 'dish', default='spam & eggs')



# С валидацией, требуем ввод числа:


prompt('Please specify process nice level: ', key='nice', validate=int)



# С валидацией по регулярному выражению:


release = prompt('Please supply a release name',


        validate=r'^w+-d+(.d+)?$')


# Запрос вне зависимости от глобальной настройки:


with settings(abort_on_prompts=False):


    prompt('I seriously need an answer on this! ')

fabric.operations.put(local_path=None, remote_path=None, use_sudo=False, mirror_local_mode=False, mode=None)
Загружает один или более файлов на удалённый хост.
put возвращает итерируемый объект, содержащий абсолютные пути ко всем загруженным файлам. Этот итерируемый объект содержит также атрибут .failed, содержащий пути к локальным файлам, которые не удалось выгрузить (и потому его можно использовать для логической проверки.) Кроме того, Вы можете использовать .succeeded, который эквивалентен not .failed.
local_path может быть как относительным, так и абсолютным путём, или даже каталогом, может содержать символы подстановки оболочки, как они используются в модуле glob. Можно использовать и ~ (так же как в os.path.expanduser).
local_path может быть и файлоподобным объектом, как, например, результатом open('path') или экземпляром StringIO.
Примечание
В таком случае put постарается прочитать всё содержимое файлоподобного объекта, проматывая его при помощи seek (и будет использовать tell для сохранения предыдущей позиции файла).
Примечание
Использование файлоподобного объекта в команде put в аргументе local_path приведёт к удалению временного файла из-за нашей реалиации слоя SSH.
remote_path также может быть абсолютным или относительным путём, но применяется к удалённому узлу. Относительный genm трактуется относительно домашней директории удалённого пользователя, но, при необходимости, можно использовать и тильду (т.е. ~/.ssh/).
Пустая строка в качестве значения любого из двух аргументов пути будет замещена на текущий рабочий каталог.
Хотя протокол SFTP (который используется put) не имеет возможности загрузить файл в локацию, которая не принадлежит подключившемуся пользователю, Вы можете задать use_sudo=True, чтобы обойти это. При использовании этого параметра put загружает файлы во временный каталог на удалённом хосте и затем использует sudo для перемещения их в remote_path.
В некоторых случаях желательно чтобы загруженные файлы имели аналогичный  режим, как и их локальные «коллеги» (например, когда Вы загружаете выполняемые скрипты). Для этого используйте mirror_local_mode=True.
В качестве альтернативы Вы можете использовать именованный аргумент mode для того, чтобы задать режим извлечения так же как и os.chmod или команда Unix chmod.
put учитывает результат cd, так что относительные пути в remote_path будут толковаться относительно текущего удалённого рабочего каталога, если это возможно. Таким образом, например, код ниже выгрузит файл в /tmp/files/test.txt а не в ~/files/test.txt:

with cd('/tmp'):


    put('/path/to/local/test.txt', 'files')

Использование lcd будет влиять на local_path аналогичным образом.
Примеры:

put('bin/project.zip', '/tmp/project.zip')


put('*.py', 'cgi-bin/')


put('index.html', 'index.html', mode=0755)

Примечание
Если файлоподобный объект, такой как StringIO, имеет атрибут name, то его значение будет использоваться в выводе Fabric, вместо стандартного  obj>
Изменения в версии 1.0: Теперь учитывается удалённый рабочий каталог, управляемый cd, и локальный рабочий каталог, управляемый lcd.
Изменения в версии 1.0: Теперь можно использовать файлоподобные объекты в аргументе local_path.
Изменения в версии 1.0: В аргументе local_path можно задать каталог, который будет рекурсивно выгружен на удалённый узел.
Изменения в версии 1.0: Возвращает итерируемый объект, содержащий удалённые пути с атрибутами .failed и.succeeded.
Изменения в версии 1.5: Позволяет использовать атрибут name файлоподобного объекта для вывода лога
fabric.operations.reboot(wait=120)
Перезагружает удалённую систему.
Временно изменяет настройки переподключения (timeout и connection_attempts) чтобы убедиться, что попытки подключения не прекратятся как минимум раньше wait секунд.
Примечание
По состоянию на Fabric 1.4, способность переподключиться в пределах сессии больше не требует использования внутреннего API. Хотя мы и не объявляем эту функцию нежелательной, тем не менее добавление к ней новых возможностей не стоит у нас в приоритетах.
Пользователи, желающие получить больше возможностей должны посмотреть исходники этой функции (6 хорошо задокументированных строк) и написать свою собственную адаптацию с различными значениями timeout/attempts или дополнительной логикой.
Появился в версии 0.9.2.
Изменения в версии 1.4: Изменен именованный аргумент wait — ему добавлено значение по умолчанию.
fabric.operations.require(*keys, **kwargs)
Проверяет наличие переданных ключей в общем словаре окружения и прерывает выполнение, если их не находит.
Позиционными аргументами должны быть строки, определяющие то, какие переменные окружения должны быть проверены. Если какой-либо из этих переменных не существует, Fabric прервёт выполнение и выведен имена отсутствующих ключей.
Опциональный именованный аргумент used_for может быть строкой, которая будет отправлена на стандартный вывод, чтобы сообщить пользователю, для каких целей будет использоваться отсутствующая переменная. used_for выводится как часть строки вроде этой:
"Th(is|ese) variable(s) (are|is) used for %s"
Опциональный именованный аргумент provided_by может быть списком функций или имён функций, или одной функцией или её именем, которые должны быть выполнены для того, чтобы задать эти переменные; он будет включён в сообщение об ошибке.
Примечание: Подразумевается, что именованные аргументы применяются ко всем переданным ключам как к группе. Если Вам надо, например, указать для разных ключей разные used_for, Вы должны использовать несколько вызовов require().
Изменения в версии 1.1: Позволяет использовать итерируемые значения provided_by, а не одиночные значения.
fabric.operations.run(command, shell=True, pty=True, combine_stderr=None, quiet=False, warn_only=False, stdout=None,stderr=None)
Запускает команду оболочки на удалённом узле.
Если shell=True (значение gj умолчанию), run выполнит заданную команду через оболочку, которая определяется переменной env.shell (в сумме получается что-то вроде /bin/bash -l -c "".) Все двойные кавычки (") или знаки доллара ($) в command будут автоматически экранированы, если shell=True.
run возвращает результирующий вывод выполнения удалённой программы в качестве одной (скорее всего состоящей из нескольких строк) строки. Эта строка будет иметь логические атрибуты failed и succeeded, определяющие успешно или нет была выполнена команда, а в атрибуте return_code Вы получите код возврата команды. Более того, он содержит копии запрошенной и реальной строки команды в аргументах .command и .real_command соответственно.
Любой текст, введённый в вашем локальном терминале будет перенаправлен в удалённую программу, пока она выполняется; таким образом Вы можете взаимодействовать удалённой программой, вводя пароли и т.п. Более подробно смотрите в разделе Взаимодействие с удалённой программой.
Вы можете задать pty=False чтобы не создавать псевдотерминал на удалённом хосте в том случае, если это создаёт проблемы для выполняемой команды. Но, таким образом, Fabric надо будет самому передавать весь ввод удалённой программе, в том числе и пароли. (Если pty=True, удалённый псеводтерминал бдует делать всё это сам.) Подробнее об этом в разделе Псевдотерминалы.
Конкретнее, если Вам нужно программно проверить поток вывода ошибок удалённой программы (доступный через атрибут stderr возвращаемого значения функции), Вы можете задать combine_stderr=False. В этом случае есть большая вероятность получения путанного вывода на вашем терминале (хотя возвращаемая run строка будет разделена надлежащим образом). Более подробно смотрите в разделе Комбинирование stdout и stderr.
Чтобы игнорировать ненулевой код возвращения задайте warn_only=True. Чтобы и игнорировать ненулевое возвращаемое значение и принудить команду выполняться тихо, задайте quiet=True.
Чтобы переопределить какие локальные потоки будут использованы для отображения удалённых stdout и/ил
и stderr, определите stdout или stderr. (По умолчанию используются потоковые объекты Python sys.stdout и sys.stderr.)
Например, run("command", stderr=sys.stdout) будет выводить удалённый поток ошибок в локальный поток вывода, сохраняя его как свой собственный атрибут возвращаемого значения (как выше). Или же Вы можете даже передать свой собственный потоковый объект или логировщик, например myout = StringIO(); run("command", stdout=myout).
Примеры:

run("ls /var/www/")


run("ls /home/myuser", shell=False)


output = run('ls /var/www/site1')

Начиная с версии 1.0: Атрибуты succeeded и stderr возвращаемого значения, именованный аргумент combine_stderr, и интерактивное поведение.
Изменения в версии 1.0: Значением по умолчанию pty теперь является True.
Изменения в версии 1.0.2: Значением по умолчанию combine_stderr теперь является None вместо True. Однако поведение по умолчан

Fabric: Модель выполнения

Если Вы читали руководство, то Вы должны быть уже знакомы с тем, как Fabric работает (с одной задачей на одном хосте). Однако, во многих ситуациях Вы можете захотеть выполнить несколько задач и/или на нескольких хостах. Возможно, Вы захотите разделить одну большую задачу на несколько маленьких, или обойти список серверов в поисках тех, на которых надо удалить выбранного пользователя. Все эти сценарии требуют некоторых правил о том, как и когда выполняются задачи.
Этот документ описывает модель выполнения Fabric, включая главный цикл выполнения, определение списка хостов, создание подключений и т.д.

Стратегия выполнения

По умолчанию Fabric работает в одиночном, последовательном режиме выполнения, хотя, начиная с версии 1.3, доступна параллельная модель выполнения (см параллельное выполнение). Поведение по умолчанию заключается в следующем:
  • Создаётся список задач. На данный момент это просто список аргументов, переданных fab'y, сохраняя порядок аргументов
  • Для каждой задачи из разных источников создаётся список хостов (подробнее см «Как создаётся список хостов» ниже)
  • Проходится список задач, каждая задача запускается один раз для каждого хоста в списке
  • Задачи, для которых нет хостов в списке хостов, выполняются только локально и всегда запускаются только один раз
Таким образом, если у нас есть следующий fabfile:
    from fabric.api import run, env

    env.hosts = ['host1', 'host2']

    def taskA():
        run('ls')

    def taskB():
        run('whoami')
и мы выполняем команду:
 $ fab taskA taskB
мы увидим, что Fabric выполнит следующее:
  • taskA выполняется на host1
  • taskA выполняется на host2
  • taskB выполняется на host1
  • taskB выполняется на host2
Хотя это и упрощённый подход, он позволяет очевидно сопоставить задачи и хосты и (в отличие от инструментов, которые запускают задачу сразу на нескольких узлах) позволяют реализовать логику скрипта, где Вы проверяете результат выполнения предыдущей команды и на основании этого решаете что делать дальше.

Определение задач

Подробнее о том, что такое задачи Fabric и с чем их едят, смотрите «Определение задач«

Определение списка хостов

Если только Вы не используете Fabric как просто систему запуска локальных скриптов (что возможно, но не является его основной задачей), наличие задач без возможности определить хосты для их выполнения было бы малополезным. Есть несколько способов сделать это, область воздействия этих методов меняется от глобальной до «только на одну задачу» и их можно смешивать в нужных пропорциях.

Хосты

Хостами, в данном контексте, называется то, что обычно называется «строками хостов»: строка, которая определяет имя пользователя, имя хоста и номер порта: `username@hostname:port`. Пользователя и порт (и, соответственно, `@` и `:`) могут быть опущены; в таком случае будет использоваться локальное имя пользователя и порт 22. Таким образом, «admin@foo.com:222», «deploy@website» и «nameserver1» могут быть использованы в качестве строк хостов.
Так же поддерживается нотация IPv6, например, «::1», «[::1]:1222», «user@2001:db8::1» или «user@[2001:db8::1]:1222». Квадратные скобки нужны только для того, чтобы отделить адрес от номера порта. Если номер порта не указан, то скобки тоже можно не использовать. Кроме того, если строка хоста задаётся через командную строку, то в некоторых оболочках может потребоваться экранировать эти скобки.
Примечание: Раздел между именем пользователя и именем хоста происходит по последнему найденному знаку @, так что можно вполне использовать email адрес в качестве имени пользователя.
В процессе выполнения Fabric нормализует полученную строку хоста и затем сохраняет каждую часть (имя пользователя / имя хоста / порт) в словаре окружения и для их использования и для того, чтобы задачи по необходимости могли на них сослаться. Более детально смотри в «Словарь окружения«.

Роли

Строка хоста определяют один хост, но иногда бывает полезно объединить хосты в группы. Возможно, у Вас есть несколько Web серверов за балансировщиком нагрузки, и Вы хотите обновить их все; или Вы хотите запустить задачу на «всех клиентских серверах». Роли п