Datasets:

0n1xus

/

codexglue

like 5

<s> from website . util import rubeus <EOL> from . . api import Figshare <EOL> def figshare_hgrid_data ( node_settings , auth , parent = None , ** kwargs ) : <EOL> node = node_settings . owner <EOL> if node_settings . figshare_type == '<STR_LIT>' : <EOL> item = Figshare . from_settings ( node_settings . user_settings ) . project ( node_settings , node_settings . figshare_id ) <EOL> else : <EOL> item = Figshare . from_settings ( node_settings . user_settings ) . article ( node_settings , node_settings . figshare_id ) <EOL> if not node_settings . figshare_id or not node_settings . has_auth or not item : <EOL> return <EOL> node_settings . figshare_title = item . get ( '<STR_LIT:title>' ) or item [ '<STR_LIT>' ] [ <NUM_LIT:0> ] [ '<STR_LIT:title>' ] <EOL> node_settings . save ( ) <EOL> return [ <EOL> rubeus . build_addon_root ( <EOL> node_settings , u'<STR_LIT>' . format ( node_settings . figshare_title or "<STR_LIT>" . format ( node_settings . figshare_type or '<STR_LIT>' ) , node_settings . figshare_id ) , permissions = auth , <EOL> nodeUrl = node . url , nodeApiUrl = node . api_url , <EOL> extra = { <EOL> '<STR_LIT:status>' : ( item . get ( '<STR_LIT>' ) or item [ '<STR_LIT>' ] ) [ <NUM_LIT:0> ] [ '<STR_LIT:status>' ] . lower ( ) <EOL> } <EOL> ) <EOL> ] </s>

<s> """<STR_LIT>""" <EOL> from dateutil . parser import parse as dateparse <EOL> import httplib as http <EOL> import logging <EOL> from flask import request , make_response <EOL> from framework . exceptions import HTTPError <EOL> from website . addons . base import generic_views <EOL> from website . addons . github . api import GitHubClient , ref_to_params <EOL> from website . addons . github . exceptions import NotFoundError , GitHubError <EOL> from website . addons . github . serializer import GitHubSerializer <EOL> from website . addons . github . utils import ( <EOL> get_refs , check_permissions , <EOL> verify_hook_signature , MESSAGES <EOL> ) <EOL> from website . models import NodeLog <EOL> from website . project . decorators import ( <EOL> must_have_addon , must_be_addon_authorizer , <EOL> must_have_permission , must_not_be_registration , <EOL> must_be_contributor_or_public , must_be_valid_project , <EOL> ) <EOL> from website . util import rubeus <EOL> logger = logging . getLogger ( __name__ ) <EOL> logging . getLogger ( '<STR_LIT>' ) . setLevel ( logging . WARNING ) <EOL> logging . getLogger ( '<STR_LIT>' ) . setLevel ( logging . WARNING ) <EOL> SHORT_NAME = '<STR_LIT>' <EOL> FULL_NAME = '<STR_LIT>' <EOL> github_account_list = generic_views . account_list ( <EOL> SHORT_NAME , <EOL> GitHubSerializer <EOL> ) <EOL> github_import_auth = generic_views . import_auth ( <EOL> SHORT_NAME , <EOL> GitHubSerializer <EOL> ) <EOL> def _get_folders ( node_addon , folder_id ) : <EOL> pass <EOL> github_folder_list = generic_views . folder_list ( <EOL> SHORT_NAME , <EOL> FULL_NAME , <EOL> _get_folders <EOL> ) <EOL> github_get_config = generic_views . get_config ( <EOL> SHORT_NAME , <EOL> GitHubSerializer <EOL> ) <EOL> github_deauthorize_node = generic_views . deauthorize_node ( <EOL> SHORT_NAME <EOL> ) <EOL> github_root_folder = generic_views . root_folder ( <EOL> SHORT_NAME <EOL> ) <EOL> @ must_not_be_registration <EOL> @ must_have_addon ( SHORT_NAME , '<STR_LIT:user>' ) <EOL> @ must_have_addon ( SHORT_NAME , '<STR_LIT>' ) <EOL> @ must_be_addon_authorizer ( SHORT_NAME ) <EOL> @ must_have_permission ( '<STR_LIT>' ) <EOL> def github_set_config ( auth , ** kwargs ) : <EOL> node_settings = kwargs . get ( '<STR_LIT>' , None ) <EOL> node = kwargs . get ( '<STR_LIT>' , None ) <EOL> user_settings = kwargs . get ( '<STR_LIT>' , None ) <EOL> try : <EOL> if not node : <EOL> node = node_settings . owner <EOL> if not user_settings : <EOL> user_settings = node_settings . user_settings <EOL> except AttributeError : <EOL> raise HTTPError ( http . BAD_REQUEST ) <EOL> github_user_name = request . json . get ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> github_repo_name = request . json . get ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> if not github_user_name or not github_repo_name : <EOL> raise HTTPError ( http . BAD_REQUEST ) <EOL> connection = GitHubClient ( external_account = node_settings . external_account ) <EOL> repo = connection . repo ( github_user_name , github_repo_name ) <EOL> if repo is None : <EOL> if user_settings : <EOL> message = ( <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' <EOL> ) <EOL> else : <EOL> message = ( <EOL> '<STR_LIT>' <EOL> ) <EOL> return { '<STR_LIT:message>' : message } , http . BAD_REQUEST <EOL> changed = ( <EOL> github_user_name != node_settings . user or <EOL> github_repo_name != node_settings . repo <EOL> ) <EOL> if changed : <EOL> node_settings . delete_hook ( ) <EOL> node_settings . user = github_user_name <EOL> node_settings . repo = github_repo_name <EOL> node . add_log ( <EOL> action = '<STR_LIT>' , <EOL> params = { <EOL> '<STR_LIT>' : node . parent_id , <EOL> '<STR_LIT>' : node . _id , <EOL> '<STR_LIT>' : { <EOL> '<STR_LIT:user>' : github_user_name , <EOL> '<STR_LIT>' : github_repo_name , <EOL> } <EOL> } , <EOL> auth = auth , <EOL> ) <EOL> if node_settings . user and node_settings . repo : <EOL> node_settings . add_hook ( save = False ) <EOL> node_settings . save ( ) <EOL> return { } <EOL> @ must_be_contributor_or_public <EOL> @ must_have_addon ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> def github_download_starball ( node_addon , ** kwargs ) : <EOL> archive = kwargs . get ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> ref = request . args . get ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> connection = GitHubClient ( external_account = node_addon . external_account ) <EOL> headers , data = connection . starball ( <EOL> node_addon . user , node_addon . repo , archive , ref <EOL> ) <EOL> resp = make_response ( data ) <EOL> for key , value in headers . iteritems ( ) : <EOL> resp . headers [ key ] = value <EOL> return resp <EOL> @ must_be_contributor_or_public <EOL> @ must_have_addon ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> def github_root_folder ( * args , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> node_settings = kwargs [ '<STR_LIT>' ] <EOL> auth = kwargs [ '<STR_LIT>' ] <EOL> data = request . args . to_dict ( ) <EOL> return github_hgrid_data ( node_settings , auth = auth , ** data ) <EOL> def github_hgrid_data ( node_settings , auth , ** kwargs ) : <EOL> if not node_settings . complete : <EOL> return <EOL> connection = GitHubClient ( external_account = node_settings . external_account ) <EOL> repo = None <EOL> node = node_settings . owner <EOL> if node . is_public and not node . is_contributor ( auth . user ) : <EOL> try : <EOL> repo = connection . repo ( node_settings . user , node_settings . repo ) <EOL> except NotFoundError : <EOL> logger . error ( '<STR_LIT>' ) <EOL> return None <EOL> if repo . private : <EOL> return None <EOL> try : <EOL> branch , sha , branches = get_refs ( <EOL> node_settings , <EOL> branch = kwargs . get ( '<STR_LIT>' ) , <EOL> sha = kwargs . get ( '<STR_LIT>' ) , <EOL> connection = connection , <EOL> ) <EOL> except ( NotFoundError , GitHubError ) : <EOL> logger . error ( '<STR_LIT>' ) <EOL> return <EOL> if branch is not None : <EOL> ref = ref_to_params ( branch , sha ) <EOL> can_edit = check_permissions ( <EOL> node_settings , auth , connection , branch , sha , repo = repo , <EOL> ) <EOL> else : <EOL> ref = None <EOL> can_edit = False <EOL> name_tpl = '<STR_LIT>' . format ( <EOL> user = node_settings . user , repo = node_settings . repo <EOL> ) <EOL> permissions = { <EOL> '<STR_LIT>' : can_edit , <EOL> '<STR_LIT>' : True , <EOL> '<STR_LIT>' : node_settings . is_private <EOL> } <EOL> urls = { <EOL> '<STR_LIT>' : node_settings . owner . api_url + '<STR_LIT>' + ( ref or '<STR_LIT>' ) , <EOL> '<STR_LIT>' : node_settings . owner . api_url + '<STR_LIT>' + ( ref or '<STR_LIT>' ) , <EOL> '<STR_LIT>' : node_settings . owner . api_url + '<STR_LIT>' , <EOL> '<STR_LIT>' : node_settings . owner . api_url + '<STR_LIT>' + ( ref or '<STR_LIT>' ) , <EOL> '<STR_LIT>' : "<STR_LIT>" . format ( node_settings . user , node_settings . repo , branch ) <EOL> } <EOL> branch_names = [ each . name for each in branches ] <EOL> if not branch_names : <EOL> branch_names = [ branch ] <EOL> return [ rubeus . build_addon_root ( <EOL> node_settings , <EOL> name_tpl , <EOL> urls = urls , <EOL> permissions = permissions , <EOL> branches = branch_names , <EOL> defaultBranch = branch , <EOL> ) ] <EOL> @ must_have_addon ( SHORT_NAME , '<STR_LIT:user>' ) <EOL> @ must_have_addon ( SHORT_NAME , '<STR_LIT>' ) <EOL> @ must_be_addon_authorizer ( SHORT_NAME ) <EOL> @ must_have_permission ( '<STR_LIT>' ) <EOL> def github_create_repo ( ** kwargs ) : <EOL> repo_name = request . json . get ( '<STR_LIT:name>' ) <EOL> if not repo_name : <EOL> raise HTTPError ( http . BAD_REQUEST ) <EOL> node_settings = kwargs [ '<STR_LIT>' ] <EOL> connection = GitHubClient ( external_account = node_settings . external_account ) <EOL> try : <EOL> repo = connection . create_repo ( repo_name , auto_init = True ) <EOL> except GitHubError : <EOL> raise HTTPError ( http . BAD_REQUEST ) <EOL> return { <EOL> '<STR_LIT:user>' : repo . owner . login , <EOL> '<STR_LIT>' : repo . name , <EOL> } <EOL> def add_hook_log ( node , github , action , path , date , committer , include_urls = False , <EOL> sha = None , save = False ) : <EOL> """<STR_LIT>""" <EOL> github_data = { <EOL> '<STR_LIT:user>' : github . user , <EOL> '<STR_LIT>' : github . repo , <EOL> } <EOL> urls = { } <EOL> if include_urls : <EOL> url = node . web_url_for ( '<STR_LIT>' , path = path , provider = SHORT_NAME ) <EOL> urls = { <EOL> '<STR_LIT>' : '<STR_LIT>' . format ( url , sha ) , <EOL> '<STR_LIT>' : '<STR_LIT>' . format ( url , sha ) <EOL> } <EOL> node . add_log ( <EOL> action = action , <EOL> params = { <EOL> '<STR_LIT>' : node . parent_id , <EOL> '<STR_LIT>' : node . _id , <EOL> '<STR_LIT:path>' : path , <EOL> '<STR_LIT>' : github_data , <EOL> '<STR_LIT>' : urls , <EOL> } , <EOL> auth = None , <EOL> foreign_user = committer , <EOL> log_date = date , <EOL> save = save , <EOL> ) <EOL> @ must_be_valid_project <EOL> @ must_not_be_registration <EOL> @ must_have_addon ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> def github_hook_callback ( node_addon , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> if request . json is None : <EOL> return { } <EOL> verify_hook_signature ( <EOL> node_addon , <EOL> request . data , <EOL> request . headers , <EOL> ) <EOL> node = kwargs [ '<STR_LIT>' ] or kwargs [ '<STR_LIT>' ] <EOL> payload = request . json <EOL> for commit in payload . get ( '<STR_LIT>' , [ ] ) : <EOL> if commit [ '<STR_LIT:message>' ] and commit [ '<STR_LIT:message>' ] in MESSAGES . values ( ) : <EOL> continue <EOL> _id = commit [ '<STR_LIT:id>' ] <EOL> date = dateparse ( commit [ '<STR_LIT>' ] ) <EOL> committer = commit [ '<STR_LIT>' ] [ '<STR_LIT:name>' ] <EOL> for path in commit . get ( '<STR_LIT>' , [ ] ) : <EOL> add_hook_log ( <EOL> node , node_addon , '<STR_LIT>' + NodeLog . FILE_ADDED , <EOL> path , date , committer , include_urls = True , sha = _id , <EOL> ) <EOL> for path in commit . get ( '<STR_LIT>' , [ ] ) : <EOL> add_hook_log ( <EOL> node , node_addon , '<STR_LIT>' + NodeLog . FILE_UPDATED , <EOL> path , date , committer , include_urls = True , sha = _id , <EOL> ) <EOL> for path in commit . get ( '<STR_LIT>' , [ ] ) : <EOL> add_hook_log ( <EOL> node , node_addon , '<STR_LIT>' + NodeLog . FILE_REMOVED , <EOL> path , date , committer , <EOL> ) <EOL> node . save ( ) </s>

<s> import mock <EOL> import urlparse <EOL> from website . addons . base . testing import views <EOL> from website . addons . base . testing . utils import MockFolder <EOL> from website . addons . mendeley . model import Mendeley <EOL> from website . addons . mendeley . provider import MendeleyCitationsProvider <EOL> from website . addons . mendeley . serializer import MendeleySerializer <EOL> from website . addons . mendeley . tests . utils import MendeleyTestCase , mock_responses <EOL> API_URL = '<STR_LIT>' <EOL> class TestAuthViews ( MendeleyTestCase , views . OAuthAddonAuthViewsTestCaseMixin ) : <EOL> pass <EOL> class TestConfigViews ( MendeleyTestCase , views . OAuthCitationAddonConfigViewsTestCaseMixin ) : <EOL> folder = MockFolder ( ) <EOL> Serializer = MendeleySerializer <EOL> client = Mendeley <EOL> citationsProvider = MendeleyCitationsProvider <EOL> foldersApiUrl = urlparse . urljoin ( API_URL , '<STR_LIT>' ) <EOL> documentsApiUrl = urlparse . urljoin ( API_URL , '<STR_LIT>' ) <EOL> mockResponses = mock_responses <EOL> @ mock . patch ( '<STR_LIT>' , mock . PropertyMock ( return_value = '<STR_LIT>' ) ) <EOL> def test_deauthorize_node ( self ) : <EOL> super ( TestConfigViews , self ) . test_deauthorize_node ( ) </s>

<s> import re <EOL> import httplib <EOL> from boto import exception <EOL> from boto . s3 . connection import S3Connection <EOL> from boto . s3 . connection import OrdinaryCallingFormat <EOL> from framework . exceptions import HTTPError <EOL> from website . addons . s3 . settings import BUCKET_LOCATIONS <EOL> def connect_s3 ( access_key = None , secret_key = None , node_settings = None ) : <EOL> """<STR_LIT>""" <EOL> if node_settings is not None : <EOL> if node_settings . external_account is not None : <EOL> access_key , secret_key = node_settings . external_account . oauth_key , node_settings . external_account . oauth_secret <EOL> connection = S3Connection ( access_key , secret_key , calling_format = OrdinaryCallingFormat ( ) ) <EOL> return connection <EOL> def get_bucket_names ( node_settings ) : <EOL> try : <EOL> buckets = connect_s3 ( node_settings = node_settings ) . get_all_buckets ( ) <EOL> except exception . NoAuthHandlerFound : <EOL> raise HTTPError ( httplib . FORBIDDEN ) <EOL> except exception . BotoServerError as e : <EOL> raise HTTPError ( e . status ) <EOL> return [ bucket . name for bucket in buckets ] <EOL> def validate_bucket_location ( location ) : <EOL> return location in BUCKET_LOCATIONS <EOL> def validate_bucket_name ( name ) : <EOL> """<STR_LIT>""" <EOL> label = '<STR_LIT>' <EOL> validate_name = re . compile ( '<STR_LIT>' + label + '<STR_LIT>' + label + '<STR_LIT>' ) <EOL> is_ip_address = re . compile ( '<STR_LIT>' ) <EOL> return ( <EOL> len ( name ) >= <NUM_LIT:3> and len ( name ) <= <NUM_LIT> and bool ( validate_name . match ( name ) ) and not bool ( is_ip_address . match ( name ) ) <EOL> ) <EOL> def create_bucket ( node_settings , bucket_name , location = '<STR_LIT>' ) : <EOL> return connect_s3 ( node_settings = node_settings ) . create_bucket ( bucket_name , location = location ) <EOL> def bucket_exists ( access_key , secret_key , bucket_name ) : <EOL> """<STR_LIT>""" <EOL> if not bucket_name : <EOL> return False <EOL> connection = connect_s3 ( access_key , secret_key ) <EOL> if bucket_name != bucket_name . lower ( ) : <EOL> connection . calling_format = OrdinaryCallingFormat ( ) <EOL> try : <EOL> connect_s3 ( access_key , secret_key ) . head_bucket ( bucket_name ) <EOL> except exception . S3ResponseError as e : <EOL> if e . status not in ( <NUM_LIT> , <NUM_LIT> ) : <EOL> return False <EOL> return True <EOL> def can_list ( access_key , secret_key ) : <EOL> """<STR_LIT>""" <EOL> if not ( access_key and secret_key ) : <EOL> return False <EOL> try : <EOL> connect_s3 ( access_key , secret_key ) . get_all_buckets ( ) <EOL> except exception . S3ResponseError : <EOL> return False <EOL> return True <EOL> def get_user_info ( access_key , secret_key ) : <EOL> """<STR_LIT>""" <EOL> if not ( access_key and secret_key ) : <EOL> return None <EOL> try : <EOL> return connect_s3 ( access_key , secret_key ) . get_all_buckets ( ) . owner <EOL> except exception . S3ResponseError : <EOL> return None <EOL> return None </s>

<s> from factory import SubFactory , Sequence <EOL> from tests . factories import ModularOdmFactory , UserFactory , ProjectFactory , ExternalAccountFactory <EOL> import datetime <EOL> from dateutil . relativedelta import relativedelta <EOL> from website . addons . zotero import model <EOL> class ZoteroAccountFactory ( ExternalAccountFactory ) : <EOL> provider = '<STR_LIT>' <EOL> provider_id = Sequence ( lambda n : '<STR_LIT>' . format ( n ) ) <EOL> provider_name = '<STR_LIT>' <EOL> oauth_key = Sequence ( lambda n : '<STR_LIT>' . format ( n ) ) <EOL> oauth_secret = Sequence ( lambda n : '<STR_LIT>' . format ( n ) ) <EOL> expires_at = datetime . datetime . now ( ) + relativedelta ( days = <NUM_LIT:1> ) <EOL> class ZoteroUserSettingsFactory ( ModularOdmFactory ) : <EOL> class Meta : <EOL> model = model . ZoteroUserSettings <EOL> owner = SubFactory ( UserFactory ) <EOL> class ZoteroNodeSettingsFactory ( ModularOdmFactory ) : <EOL> class Meta : <EOL> model = model . ZoteroNodeSettings <EOL> owner = SubFactory ( ProjectFactory ) </s>

<s> from website . files . models . base import * <EOL> from website . files . models . s3 import * <EOL> from website . files . models . box import * <EOL> from website . files . models . github import * <EOL> from website . files . models . dropbox import * <EOL> from website . files . models . figshare import * <EOL> from website . files . models . dataverse import * <EOL> from website . files . models . osfstorage import * <EOL> from website . files . models . googledrive import * </s>

<s> """<STR_LIT>""" <EOL> from framework . auth . core import User <EOL> from framework . guid . model import Guid , BlacklistGuid <EOL> from framework . sessions . model import Session <EOL> from website . project . model import ( <EOL> Node , NodeLog , <EOL> Tag , WatchConfig , MetaSchema , Pointer , <EOL> Comment , PrivateLink , MetaData , <EOL> AlternativeCitation , <EOL> DraftRegistration , <EOL> ) <EOL> from website . project . sanctions import ( <EOL> DraftRegistrationApproval , <EOL> Embargo , <EOL> EmbargoTerminationApproval , <EOL> RegistrationApproval , <EOL> Retraction , <EOL> ) <EOL> from website . oauth . models import ApiOAuth2Application , ExternalAccount , ApiOAuth2PersonalToken <EOL> from website . identifiers . model import Identifier <EOL> from website . citations . models import CitationStyle <EOL> from website . institutions . model import Institution <EOL> from website . mails import QueuedMail <EOL> from website . files . models . base import FileVersion <EOL> from website . files . models . base import StoredFileNode <EOL> from website . files . models . base import TrashedFileNode <EOL> from website . conferences . model import Conference , MailRecord <EOL> from website . notifications . model import NotificationDigest <EOL> from website . notifications . model import NotificationSubscription <EOL> from website . archiver . model import ArchiveJob , ArchiveTarget <EOL> from website . project . licenses import NodeLicense , NodeLicenseRecord <EOL> MODELS = ( <EOL> User , <EOL> ApiOAuth2Application , ApiOAuth2PersonalToken , Node , <EOL> NodeLog , StoredFileNode , TrashedFileNode , FileVersion , <EOL> Tag , WatchConfig , Session , Guid , MetaSchema , Pointer , <EOL> MailRecord , Comment , PrivateLink , MetaData , Conference , <EOL> NotificationSubscription , NotificationDigest , CitationStyle , <EOL> CitationStyle , ExternalAccount , Identifier , <EOL> Embargo , Retraction , RegistrationApproval , EmbargoTerminationApproval , <EOL> ArchiveJob , ArchiveTarget , BlacklistGuid , <EOL> QueuedMail , AlternativeCitation , <EOL> DraftRegistration , DraftRegistrationApproval , <EOL> NodeLicense , NodeLicenseRecord <EOL> ) <EOL> GUID_MODELS = ( User , Node , Comment , MetaData ) </s>

<s> from datetime import datetime <EOL> import markdown <EOL> import pytz <EOL> from flask import request <EOL> from api . caching . tasks import ban_url <EOL> from framework . guid . model import Guid <EOL> from framework . postcommit_tasks . handlers import enqueue_postcommit_task <EOL> from modularodm import Q <EOL> from website import settings <EOL> from website . addons . base . signals import file_updated <EOL> from website . files . models import FileNode , TrashedFileNode <EOL> from website . models import Comment <EOL> from website . notifications . constants import PROVIDERS <EOL> from website . notifications . emails import notify <EOL> from website . project . decorators import must_be_contributor_or_public <EOL> from website . project . model import Node <EOL> from website . project . signals import comment_added <EOL> @ file_updated . connect <EOL> def update_file_guid_referent ( self , node , event_type , payload , user = None ) : <EOL> if event_type == '<STR_LIT>' or event_type == '<STR_LIT>' : <EOL> source = payload [ '<STR_LIT:source>' ] <EOL> destination = payload [ '<STR_LIT>' ] <EOL> source_node = Node . load ( source [ '<STR_LIT>' ] [ '<STR_LIT>' ] ) <EOL> destination_node = node <EOL> file_guids = FileNode . resolve_class ( source [ '<STR_LIT>' ] , FileNode . ANY ) . get_file_guids ( <EOL> materialized_path = source [ '<STR_LIT>' ] if source [ '<STR_LIT>' ] != '<STR_LIT>' else source [ '<STR_LIT:path>' ] , <EOL> provider = source [ '<STR_LIT>' ] , <EOL> node = source_node ) <EOL> if event_type == '<STR_LIT>' and source [ '<STR_LIT>' ] in settings . ADDONS_BASED_ON_IDS : <EOL> return <EOL> if event_type == '<STR_LIT>' and ( source [ '<STR_LIT>' ] == destination [ '<STR_LIT>' ] and <EOL> source [ '<STR_LIT>' ] in settings . ADDONS_BASED_ON_IDS ) and source_node == destination_node : <EOL> return <EOL> for guid in file_guids : <EOL> obj = Guid . load ( guid ) <EOL> if source_node != destination_node and Comment . find ( Q ( '<STR_LIT>' , '<STR_LIT>' , guid ) ) . count ( ) != <NUM_LIT:0> : <EOL> update_comment_node ( guid , source_node , destination_node ) <EOL> if source [ '<STR_LIT>' ] != destination [ '<STR_LIT>' ] or source [ '<STR_LIT>' ] != '<STR_LIT>' : <EOL> old_file = FileNode . load ( obj . referent . _id ) <EOL> obj . referent = create_new_file ( obj , source , destination , destination_node ) <EOL> obj . save ( ) <EOL> if old_file and not TrashedFileNode . load ( old_file . _id ) : <EOL> old_file . delete ( ) <EOL> def create_new_file ( obj , source , destination , destination_node ) : <EOL> if not source [ '<STR_LIT>' ] . startswith ( '<STR_LIT:/>' ) : <EOL> source [ '<STR_LIT>' ] = '<STR_LIT:/>' + source [ '<STR_LIT>' ] <EOL> if not destination [ '<STR_LIT>' ] . startswith ( '<STR_LIT:/>' ) : <EOL> destination [ '<STR_LIT>' ] = '<STR_LIT:/>' + destination [ '<STR_LIT>' ] <EOL> if not source [ '<STR_LIT:path>' ] . endswith ( '<STR_LIT:/>' ) : <EOL> data = dict ( destination ) <EOL> new_file = FileNode . resolve_class ( destination [ '<STR_LIT>' ] , FileNode . FILE ) . get_or_create ( destination_node , destination [ '<STR_LIT:path>' ] ) <EOL> if destination [ '<STR_LIT>' ] != '<STR_LIT>' : <EOL> new_file . update ( revision = None , data = data ) <EOL> else : <EOL> new_file = find_and_create_file_from_metadata ( destination . get ( '<STR_LIT>' , [ ] ) , source , destination , destination_node , obj ) <EOL> if not new_file : <EOL> if source [ '<STR_LIT>' ] == '<STR_LIT>' : <EOL> new_path = obj . referent . path <EOL> else : <EOL> new_path = obj . referent . materialized_path . replace ( source [ '<STR_LIT>' ] , destination [ '<STR_LIT>' ] ) <EOL> new_file = FileNode . resolve_class ( destination [ '<STR_LIT>' ] , FileNode . FILE ) . get_or_create ( destination_node , new_path ) <EOL> new_file . name = new_path . split ( '<STR_LIT:/>' ) [ - <NUM_LIT:1> ] <EOL> new_file . materialized_path = new_path <EOL> new_file . save ( ) <EOL> return new_file <EOL> def find_and_create_file_from_metadata ( children , source , destination , destination_node , obj ) : <EOL> """<STR_LIT>""" <EOL> for item in children : <EOL> if not item [ '<STR_LIT>' ] . startswith ( '<STR_LIT:/>' ) : <EOL> item [ '<STR_LIT>' ] = '<STR_LIT:/>' + item [ '<STR_LIT>' ] <EOL> if item [ '<STR_LIT>' ] == '<STR_LIT>' : <EOL> return find_and_create_file_from_metadata ( item . get ( '<STR_LIT>' , [ ] ) , source , destination , destination_node , obj ) <EOL> elif item [ '<STR_LIT>' ] == '<STR_LIT:file>' and item [ '<STR_LIT>' ] . replace ( destination [ '<STR_LIT>' ] , source [ '<STR_LIT>' ] ) == obj . referent . materialized_path : <EOL> data = dict ( item ) <EOL> new_file = FileNode . resolve_class ( destination [ '<STR_LIT>' ] , FileNode . FILE ) . get_or_create ( destination_node , item [ '<STR_LIT:path>' ] ) <EOL> if destination [ '<STR_LIT>' ] != '<STR_LIT>' : <EOL> new_file . update ( revision = None , data = data ) <EOL> return new_file <EOL> def update_comment_node ( root_target_id , source_node , destination_node ) : <EOL> Comment . update ( Q ( '<STR_LIT>' , '<STR_LIT>' , root_target_id ) , data = { '<STR_LIT>' : destination_node } ) <EOL> source_node . save ( ) <EOL> destination_node . save ( ) <EOL> @ comment_added . connect <EOL> def send_comment_added_notification ( comment , auth ) : <EOL> node = comment . node <EOL> target = comment . target <EOL> context = dict ( <EOL> gravatar_url = auth . user . profile_image_url ( ) , <EOL> content = markdown . markdown ( comment . content , [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] ) , <EOL> page_type = comment . get_comment_page_type ( ) , <EOL> page_title = comment . get_comment_page_title ( ) , <EOL> provider = PROVIDERS [ comment . root_target . referent . provider ] if comment . page == Comment . FILES else '<STR_LIT>' , <EOL> target_user = target . referent . user if is_reply ( target ) else None , <EOL> parent_comment = target . referent . content if is_reply ( target ) else "<STR_LIT>" , <EOL> url = comment . get_comment_page_url ( ) <EOL> ) <EOL> time_now = datetime . utcnow ( ) . replace ( tzinfo = pytz . utc ) <EOL> sent_subscribers = notify ( <EOL> event = "<STR_LIT>" , <EOL> user = auth . user , <EOL> node = node , <EOL> timestamp = time_now , <EOL> ** context <EOL> ) <EOL> if is_reply ( target ) : <EOL> if target . referent . user and target . referent . user not in sent_subscribers : <EOL> notify ( <EOL> event = '<STR_LIT>' , <EOL> user = auth . user , <EOL> node = node , <EOL> timestamp = time_now , <EOL> ** context <EOL> ) <EOL> def is_reply ( target ) : <EOL> return isinstance ( target . referent , Comment ) <EOL> def _update_comments_timestamp ( auth , node , page = Comment . OVERVIEW , root_id = None ) : <EOL> if node . is_contributor ( auth . user ) : <EOL> enqueue_postcommit_task ( ( ban_url , ( node , ) ) ) <EOL> if root_id is not None : <EOL> guid_obj = Guid . load ( root_id ) <EOL> if guid_obj is not None : <EOL> enqueue_postcommit_task ( ( ban_url , ( guid_obj . referent , ) ) ) <EOL> if page == Comment . OVERVIEW : <EOL> root_id = node . _id <EOL> auth . user . comments_viewed_timestamp [ root_id ] = datetime . utcnow ( ) <EOL> auth . user . save ( ) <EOL> return { root_id : auth . user . comments_viewed_timestamp [ root_id ] . isoformat ( ) } <EOL> else : <EOL> return { } <EOL> @ must_be_contributor_or_public <EOL> def update_comments_timestamp ( auth , node , ** kwargs ) : <EOL> timestamp_info = request . get_json ( ) <EOL> page = timestamp_info . get ( '<STR_LIT>' ) <EOL> root_id = timestamp_info . get ( '<STR_LIT>' ) <EOL> return _update_comments_timestamp ( auth , node , page , root_id ) </s>

<s> import os <EOL> import itertools <EOL> import furl <EOL> import requests <EOL> from framework . exceptions import HTTPError <EOL> class BaseClient ( object ) : <EOL> @ property <EOL> def _auth ( self ) : <EOL> return None <EOL> @ property <EOL> def _default_headers ( self ) : <EOL> return { } <EOL> def _make_request ( self , method , url , params = None , ** kwargs ) : <EOL> expects = kwargs . pop ( '<STR_LIT>' , None ) <EOL> throws = kwargs . pop ( '<STR_LIT>' , None ) <EOL> kwargs [ '<STR_LIT>' ] = self . _build_headers ( ** kwargs . get ( '<STR_LIT>' , { } ) ) <EOL> response = requests . request ( method , url , params = params , auth = self . _auth , ** kwargs ) <EOL> if expects and response . status_code not in expects : <EOL> raise throws if throws else HTTPError ( response . status_code , message = response . content ) <EOL> return response <EOL> def _build_headers ( self , ** kwargs ) : <EOL> headers = self . _default_headers <EOL> headers . update ( kwargs ) <EOL> return { <EOL> key : value <EOL> for key , value in headers . items ( ) <EOL> if value is not None <EOL> } <EOL> def _build_url ( self , base , * segments ) : <EOL> url = furl . furl ( base ) <EOL> segments = filter ( <EOL> lambda segment : segment , <EOL> map ( <EOL> lambda segment : segment . strip ( '<STR_LIT:/>' ) , <EOL> itertools . chain ( url . path . segments , segments ) <EOL> ) <EOL> ) <EOL> url . path = os . path . join ( * segments ) <EOL> return url . url </s>

<s> from __future__ import ( <EOL> absolute_import , <EOL> print_function , <EOL> unicode_literals , <EOL> ) <EOL> from pydocx . models import XmlModel , XmlChild , XmlAttribute <EOL> from pydocx . openxml . drawing . extents import Extents <EOL> class Transform2D ( XmlModel ) : <EOL> XML_TAG = '<STR_LIT>' <EOL> extents = XmlChild ( type = Extents ) <EOL> rotate = XmlAttribute ( name = '<STR_LIT>' , default = None ) </s>

<s> from __future__ import ( <EOL> absolute_import , <EOL> print_function , <EOL> unicode_literals , <EOL> ) <EOL> from pydocx . models import XmlModel , XmlContent <EOL> class FieldCode ( XmlModel ) : <EOL> XML_TAG = '<STR_LIT>' <EOL> content = XmlContent ( ) </s>

<s> from __future__ import ( <EOL> absolute_import , <EOL> print_function , <EOL> unicode_literals , <EOL> ) <EOL> from collections import defaultdict <EOL> from pydocx . models import XmlModel , XmlCollection <EOL> from pydocx . openxml . wordprocessing . table_cell import TableCell <EOL> from pydocx . openxml . wordprocessing . table_row import TableRow <EOL> class Table ( XmlModel ) : <EOL> XML_TAG = '<STR_LIT>' <EOL> rows = XmlCollection ( <EOL> TableRow , <EOL> ) <EOL> def calculate_table_cell_spans ( self ) : <EOL> if not self . rows : <EOL> return <EOL> active_rowspan_cells_by_column = { } <EOL> cell_to_rowspan_count = defaultdict ( int ) <EOL> for row in self . rows : <EOL> for column_index , cell in enumerate ( row . cells ) : <EOL> properties = cell . properties <EOL> if properties is None or properties . vertical_merge is None : <EOL> active_rowspan_cells_by_column [ column_index ] = None <EOL> elif properties : <EOL> vertical_merge = properties . vertical_merge . get ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> if vertical_merge == '<STR_LIT>' : <EOL> active_rowspan_cells_by_column [ column_index ] = cell <EOL> cell_to_rowspan_count [ cell ] += <NUM_LIT:1> <EOL> elif vertical_merge == '<STR_LIT>' : <EOL> active_rowspan_for_column = active_rowspan_cells_by_column . get ( column_index ) <EOL> if active_rowspan_for_column : <EOL> cell_to_rowspan_count [ active_rowspan_for_column ] += <NUM_LIT:1> <EOL> return dict ( cell_to_rowspan_count ) <EOL> TableCell . children . types . add ( Table ) </s>

<s> from __future__ import ( <EOL> absolute_import , <EOL> print_function , <EOL> unicode_literals , <EOL> ) <EOL> from pydocx . test import DocumentGeneratorTestCase <EOL> from pydocx . test . utils import WordprocessingDocumentFactory <EOL> from pydocx . openxml . packaging import MainDocumentPart , StyleDefinitionsPart <EOL> class StyleBasedOnTestCase ( DocumentGeneratorTestCase ) : <EOL> def test_style_chain_ends_when_loop_is_detected ( self ) : <EOL> style_xml = '''<STR_LIT>''' <EOL> document_xml = '''<STR_LIT>''' <EOL> document = WordprocessingDocumentFactory ( ) <EOL> document . add ( StyleDefinitionsPart , style_xml ) <EOL> document . add ( MainDocumentPart , document_xml ) <EOL> expected_html = '<STR_LIT>' <EOL> self . assert_document_generates_html ( document , expected_html ) <EOL> def test_styles_are_inherited ( self ) : <EOL> style_xml = '''<STR_LIT>''' <EOL> document_xml = '''<STR_LIT>''' <EOL> document = WordprocessingDocumentFactory ( ) <EOL> document . add ( StyleDefinitionsPart , style_xml ) <EOL> document . add ( MainDocumentPart , document_xml ) <EOL> expected_html = '''<STR_LIT>''' <EOL> self . assert_document_generates_html ( document , expected_html ) <EOL> def test_basedon_ignored_for_character_based_on_paragraph ( self ) : <EOL> style_xml = '''<STR_LIT>''' <EOL> document_xml = '''<STR_LIT>''' <EOL> document = WordprocessingDocumentFactory ( ) <EOL> document . add ( StyleDefinitionsPart , style_xml ) <EOL> document . add ( MainDocumentPart , document_xml ) <EOL> expected_html = '<STR_LIT>' <EOL> self . assert_document_generates_html ( document , expected_html ) <EOL> def test_basedon_ignored_for_paragraph_based_on_character ( self ) : <EOL> style_xml = '''<STR_LIT>''' <EOL> document_xml = '''<STR_LIT>''' <EOL> document = WordprocessingDocumentFactory ( ) <EOL> document . add ( StyleDefinitionsPart , style_xml ) <EOL> document . add ( MainDocumentPart , document_xml ) <EOL> expected_html = '<STR_LIT>' <EOL> self . assert_document_generates_html ( document , expected_html ) </s>

<s> from __future__ import ( <EOL> absolute_import , <EOL> print_function , <EOL> unicode_literals , <EOL> ) <EOL> import unittest <EOL> from pydocx . packaging import ZipPackage <EOL> class ZipPackageTestCase ( unittest . TestCase ) : <EOL> def setUp ( self ) : <EOL> self . package = ZipPackage ( <EOL> path = '<STR_LIT>' , <EOL> ) <EOL> def test_relationship_uri ( self ) : <EOL> self . assertEqual ( <EOL> self . package . relationship_uri , <EOL> '<STR_LIT>' , <EOL> ) <EOL> def test_relationship_part_exists ( self ) : <EOL> assert self . package . part_exists ( self . package . relationship_uri ) <EOL> def test_word_document_part_exists ( self ) : <EOL> assert self . package . part_exists ( '<STR_LIT>' ) <EOL> def test_package_relationship_part_stream ( self ) : <EOL> part = self . package . get_part ( '<STR_LIT>' ) <EOL> data = part . stream . read ( ) <EOL> assert data <EOL> assert data . startswith ( b'<STR_LIT>' ) </s>

<s> '''<STR_LIT>''' <EOL> from __future__ import unicode_literals <EOL> from scrapi . base import OAIHarvester <EOL> from scrapi . base import helpers <EOL> def oai_process_uris_addis_ababa ( * args ) : <EOL> identifiers = helpers . gather_identifiers ( args ) <EOL> provider_uris , object_uris = helpers . seperate_provider_object_uris ( <EOL> list ( map ( lambda x : x . replace ( '<STR_LIT>' , '<STR_LIT>' ) , identifiers ) ) <EOL> ) <EOL> potential_uris = ( provider_uris + object_uris ) <EOL> try : <EOL> canonical_uri = potential_uris [ <NUM_LIT:0> ] <EOL> except IndexError : <EOL> raise ValueError ( '<STR_LIT>' ) <EOL> return { <EOL> '<STR_LIT>' : canonical_uri , <EOL> '<STR_LIT>' : object_uris , <EOL> '<STR_LIT>' : provider_uris <EOL> } <EOL> class AauHarvester ( OAIHarvester ) : <EOL> short_name = '<STR_LIT>' <EOL> long_name = '<STR_LIT>' <EOL> url = '<STR_LIT>' <EOL> @ property <EOL> def schema ( self ) : <EOL> return helpers . updated_schema ( self . _schema , { <EOL> "<STR_LIT>" : ( '<STR_LIT>' , '<STR_LIT>' , oai_process_uris_addis_ababa ) <EOL> } ) <EOL> base_url = '<STR_LIT>' <EOL> property_list = [ '<STR_LIT:date>' , '<STR_LIT:type>' , '<STR_LIT>' , '<STR_LIT>' ] <EOL> timezone_granularity = True </s>

<s> """<STR_LIT>""" <EOL> from __future__ import unicode_literals <EOL> from scrapi . base import OAIHarvester <EOL> class DukeUniversityLib ( OAIHarvester ) : <EOL> short_name = '<STR_LIT>' <EOL> long_name = '<STR_LIT>' <EOL> url = '<STR_LIT>' <EOL> base_url = '<STR_LIT>' <EOL> timezone_granularity = True <EOL> property_list = [ <EOL> '<STR_LIT:type>' , '<STR_LIT:source>' , '<STR_LIT>' , <EOL> '<STR_LIT>' , '<STR_LIT>' <EOL> ] <EOL> approved_sets = [ <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' <EOL> ] </s>

<s> '''<STR_LIT>''' <EOL> from __future__ import unicode_literals <EOL> from scrapi . base import OAIHarvester <EOL> class Npp_ksuHarvester ( OAIHarvester ) : <EOL> short_name = '<STR_LIT>' <EOL> long_name = '<STR_LIT>' <EOL> url = '<STR_LIT>' <EOL> base_url = '<STR_LIT>' <EOL> property_list = [ '<STR_LIT>' , '<STR_LIT:source>' , '<STR_LIT:date>' , '<STR_LIT:type>' , '<STR_LIT>' , '<STR_LIT>' ] <EOL> timezone_granularity = True </s>

<s> '''<STR_LIT>''' <EOL> from __future__ import unicode_literals <EOL> from scrapi . base import OAIHarvester <EOL> class U_south_flHarvester ( OAIHarvester ) : <EOL> short_name = '<STR_LIT>' <EOL> long_name = '<STR_LIT>' <EOL> url = '<STR_LIT>' <EOL> base_url = '<STR_LIT>' <EOL> property_list = [ '<STR_LIT>' , '<STR_LIT:date>' , '<STR_LIT:type>' , '<STR_LIT:source>' , '<STR_LIT>' , '<STR_LIT>' ] <EOL> approved_sets = [ <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' , <EOL> u'<STR_LIT>' <EOL> ] <EOL> timezone_granularity = True </s>

<s> '''<STR_LIT>''' <EOL> from __future__ import unicode_literals <EOL> from scrapi . base import OAIHarvester <EOL> class ZenodoHarvester ( OAIHarvester ) : <EOL> short_name = '<STR_LIT>' <EOL> long_name = '<STR_LIT>' <EOL> url = '<STR_LIT>' <EOL> base_url = '<STR_LIT>' <EOL> property_list = [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT:source>' , '<STR_LIT>' , '<STR_LIT:date>' , '<STR_LIT>' , '<STR_LIT:type>' ] <EOL> timezone_granularity = True </s>

<s> import logging <EOL> import vcr <EOL> import mock <EOL> import pytest <EOL> from scrapi import base <EOL> from scrapi import registry , requests <EOL> logger = logging . getLogger ( __name__ ) <EOL> @ pytest . fixture ( autouse = True ) <EOL> def mock_maybe_load_response ( monkeypatch ) : <EOL> mock_mlr = mock . Mock ( ) <EOL> mock_mlr . return_value = None <EOL> mock_save = lambda x : x <EOL> monkeypatch . setattr ( requests , '<STR_LIT>' , mock_mlr ) <EOL> monkeypatch . setattr ( requests . HarvesterResponse , '<STR_LIT>' , mock_save ) <EOL> @ pytest . mark . parametrize ( '<STR_LIT>' , filter ( lambda x : x != '<STR_LIT:test>' , sorted ( map ( str , registry . keys ( ) ) ) ) ) <EOL> def test_harvester ( monkeypatch , harvester_name , * args , ** kwargs ) : <EOL> monkeypatch . setattr ( requests . time , '<STR_LIT>' , lambda * _ , ** __ : None ) <EOL> base . settings . RAISE_IN_TRANSFORMER = True <EOL> harvester = registry [ harvester_name ] <EOL> with vcr . use_cassette ( '<STR_LIT>' . format ( harvester_name ) , match_on = [ '<STR_LIT:host>' ] , record_mode = '<STR_LIT:none>' ) : <EOL> harvested = harvester . harvest ( ) <EOL> assert len ( harvested ) > <NUM_LIT:0> <EOL> normalized = list ( filter ( lambda x : x is not None , map ( harvester . normalize , harvested [ : <NUM_LIT> ] ) ) ) <EOL> assert len ( normalized ) > <NUM_LIT:0> </s>

<s> __version__ = '<STR_LIT>' <EOL> __import__ ( '<STR_LIT>' ) . declare_namespace ( __name__ ) </s>

<s> import os <EOL> from waterbutler . core import metadata <EOL> class BaseCloudFilesMetadata ( metadata . BaseMetadata ) : <EOL> @ property <EOL> def provider ( self ) : <EOL> return '<STR_LIT>' <EOL> class CloudFilesFileMetadata ( BaseCloudFilesMetadata , metadata . BaseFileMetadata ) : <EOL> @ property <EOL> def name ( self ) : <EOL> return os . path . split ( self . raw [ '<STR_LIT:name>' ] ) [ <NUM_LIT:1> ] <EOL> @ property <EOL> def path ( self ) : <EOL> return self . build_path ( self . raw [ '<STR_LIT:name>' ] ) <EOL> @ property <EOL> def size ( self ) : <EOL> return self . raw [ '<STR_LIT>' ] <EOL> @ property <EOL> def modified ( self ) : <EOL> return self . raw [ '<STR_LIT>' ] <EOL> @ property <EOL> def content_type ( self ) : <EOL> return self . raw [ '<STR_LIT>' ] <EOL> @ property <EOL> def etag ( self ) : <EOL> return self . raw [ '<STR_LIT>' ] <EOL> class CloudFilesHeaderMetadata ( BaseCloudFilesMetadata , metadata . BaseFileMetadata ) : <EOL> def __init__ ( self , raw , path ) : <EOL> super ( ) . __init__ ( raw ) <EOL> self . _path = path <EOL> @ property <EOL> def name ( self ) : <EOL> return os . path . split ( self . _path ) [ <NUM_LIT:1> ] <EOL> @ property <EOL> def path ( self ) : <EOL> return self . build_path ( self . _path ) <EOL> @ property <EOL> def size ( self ) : <EOL> return int ( self . raw [ '<STR_LIT>' ] ) <EOL> @ property <EOL> def modified ( self ) : <EOL> return self . raw [ '<STR_LIT>' ] <EOL> @ property <EOL> def content_type ( self ) : <EOL> return self . raw [ '<STR_LIT:Content-Type>' ] <EOL> @ property <EOL> def etag ( self ) : <EOL> return self . raw [ '<STR_LIT>' ] <EOL> class CloudFilesFolderMetadata ( BaseCloudFilesMetadata , metadata . BaseFolderMetadata ) : <EOL> @ property <EOL> def name ( self ) : <EOL> return os . path . split ( self . raw [ '<STR_LIT>' ] . rstrip ( '<STR_LIT:/>' ) ) [ <NUM_LIT:1> ] <EOL> @ property <EOL> def path ( self ) : <EOL> return self . build_path ( self . raw [ '<STR_LIT>' ] ) </s>

<s> try : <EOL> from waterbutler import settings <EOL> except ImportError : <EOL> settings = { } <EOL> config = settings . get ( '<STR_LIT>' , { } ) <EOL> BASE_URL = config . get ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> BASE_UPLOAD_URL = config . get ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> DRIVE_IGNORE_VERSION = config . get ( '<STR_LIT>' , '<STR_LIT>' ) </s>

<s> import os <EOL> import asyncio <EOL> import tornado . web <EOL> import tornado . httpserver <EOL> import tornado . platform . asyncio <EOL> from raven . contrib . tornado import AsyncSentryClient <EOL> import waterbutler <EOL> from waterbutler import settings <EOL> from waterbutler . server . api import v0 <EOL> from waterbutler . server . api import v1 <EOL> from waterbutler . server import handlers <EOL> from waterbutler . server import settings as server_settings <EOL> def api_to_handlers ( api ) : <EOL> return [ <EOL> ( os . path . join ( '<STR_LIT:/>' , api . PREFIX , pattern . lstrip ( '<STR_LIT:/>' ) ) , handler ) <EOL> for ( pattern , handler ) in api . HANDLERS <EOL> ] <EOL> def make_app ( debug ) : <EOL> app = tornado . web . Application ( <EOL> api_to_handlers ( v0 ) + <EOL> api_to_handlers ( v1 ) + <EOL> [ ( r'<STR_LIT>' , handlers . StatusHandler ) ] , <EOL> debug = debug , <EOL> ) <EOL> app . sentry_client = AsyncSentryClient ( settings . SENTRY_DSN , release = waterbutler . __version__ ) <EOL> return app <EOL> def serve ( ) : <EOL> tornado . platform . asyncio . AsyncIOMainLoop ( ) . install ( ) <EOL> app = make_app ( server_settings . DEBUG ) <EOL> ssl_options = None <EOL> if server_settings . SSL_CERT_FILE and server_settings . SSL_KEY_FILE : <EOL> ssl_options = { <EOL> '<STR_LIT>' : server_settings . SSL_CERT_FILE , <EOL> '<STR_LIT>' : server_settings . SSL_KEY_FILE , <EOL> } <EOL> app . listen ( <EOL> server_settings . PORT , <EOL> address = server_settings . ADDRESS , <EOL> xheaders = server_settings . XHEADERS , <EOL> max_body_size = server_settings . MAX_BODY_SIZE , <EOL> ssl_options = ssl_options , <EOL> ) <EOL> asyncio . get_event_loop ( ) . set_debug ( server_settings . DEBUG ) <EOL> asyncio . get_event_loop ( ) . run_forever ( ) </s>

<s> __version__ = '<STR_LIT>' </s>

<s> """<STR_LIT>""" <EOL> from warnings import warn <EOL> warn ( DeprecationWarning ( '<STR_LIT>' ) ) <EOL> from . sessions import SecureCookieSession , NullSession <EOL> Session = SecureCookieSession <EOL> _NullSession = NullSession </s>

<s> ext_id = '<STR_LIT>' </s>

<s> """<STR_LIT>""" <EOL> from base64 import ( urlsafe_b64encode as b64encode , <EOL> urlsafe_b64decode as b64decode ) <EOL> from urllib import urlencode <EOL> from urlparse import parse_qsl <EOL> from functools import wraps <EOL> from flask import request , redirect , abort , current_app , url_for <EOL> from flask_login import LoginManager , make_secure_token <EOL> import requests <EOL> GOOGLE_OAUTH2_AUTH_URL = '<STR_LIT>' <EOL> GOOGLE_OAUTH2_TOKEN_URL = '<STR_LIT>' <EOL> GOOGLE_OAUTH2_USERINFO_URL = '<STR_LIT>' <EOL> USERINFO_PROFILE_SCOPE = '<STR_LIT>' <EOL> class GoogleLogin ( object ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , app = None , login_manager = None ) : <EOL> if login_manager : <EOL> self . login_manager = login_manager <EOL> else : <EOL> self . login_manager = LoginManager ( ) <EOL> if app : <EOL> self . _app = app <EOL> self . init_app ( app ) <EOL> def init_app ( self , app , add_context_processor = True , login_manager = None ) : <EOL> """<STR_LIT>""" <EOL> if login_manager : <EOL> self . login_manager = login_manager <EOL> else : <EOL> self . login_manager = LoginManager ( ) <EOL> if not hasattr ( app , '<STR_LIT>' ) : <EOL> self . login_manager . init_app ( <EOL> app , <EOL> add_context_processor = add_context_processor ) <EOL> self . login_manager . login_message = None <EOL> self . login_manager . needs_refresh_message = None <EOL> self . login_manager . unauthorized_handler ( self . unauthorized_callback ) <EOL> @ property <EOL> def app ( self ) : <EOL> return getattr ( self , '<STR_LIT>' , current_app ) <EOL> @ property <EOL> def scopes ( self ) : <EOL> return self . app . config . get ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> @ property <EOL> def client_id ( self ) : <EOL> return self . app . config [ '<STR_LIT>' ] <EOL> @ property <EOL> def client_secret ( self ) : <EOL> return self . app . config [ '<STR_LIT>' ] <EOL> @ property <EOL> def redirect_uri ( self ) : <EOL> return self . app . config . get ( '<STR_LIT>' ) <EOL> @ property <EOL> def redirect_scheme ( self ) : <EOL> return self . app . config . get ( '<STR_LIT>' , '<STR_LIT:http>' ) <EOL> def sign_params ( self , params ) : <EOL> return b64encode ( urlencode ( dict ( sig = make_secure_token ( ** params ) , <EOL> ** params ) ) ) <EOL> def parse_state ( self , state ) : <EOL> return dict ( parse_qsl ( b64decode ( str ( state ) ) ) ) <EOL> def login_url ( self , params = None , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> kwargs . setdefault ( '<STR_LIT>' , '<STR_LIT:code>' ) <EOL> kwargs . setdefault ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> if '<STR_LIT>' not in kwargs : <EOL> kwargs . setdefault ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> scopes = kwargs . pop ( '<STR_LIT>' , self . scopes . split ( '<STR_LIT:U+002C>' ) ) <EOL> if USERINFO_PROFILE_SCOPE not in scopes : <EOL> scopes . append ( USERINFO_PROFILE_SCOPE ) <EOL> redirect_uri = kwargs . pop ( '<STR_LIT>' , self . redirect_uri ) <EOL> state = self . sign_params ( params or { } ) <EOL> return GOOGLE_OAUTH2_AUTH_URL + '<STR_LIT:?>' + urlencode ( <EOL> dict ( client_id = self . client_id , <EOL> scope = '<STR_LIT:U+0020>' . join ( scopes ) , <EOL> redirect_uri = redirect_uri , <EOL> state = state , <EOL> ** kwargs ) ) <EOL> def unauthorized_callback ( self ) : <EOL> """<STR_LIT>""" <EOL> return redirect ( self . login_url ( params = dict ( next = request . url ) ) ) <EOL> def exchange_code ( self , code , redirect_uri ) : <EOL> """<STR_LIT>""" <EOL> token = requests . post ( GOOGLE_OAUTH2_TOKEN_URL , data = dict ( <EOL> code = code , <EOL> redirect_uri = redirect_uri , <EOL> grant_type = '<STR_LIT>' , <EOL> client_id = self . client_id , <EOL> client_secret = self . client_secret , <EOL> ) ) . json <EOL> if not token : <EOL> abort ( <NUM_LIT> ) <EOL> return token <EOL> def get_userinfo ( self , access_token ) : <EOL> userinfo = requests . get ( GOOGLE_OAUTH2_USERINFO_URL , params = dict ( <EOL> access_token = access_token , <EOL> ) ) . json <EOL> if not userinfo : <EOL> abort ( <NUM_LIT> ) <EOL> return userinfo <EOL> def get_access_token ( self , refresh_token ) : <EOL> """<STR_LIT>""" <EOL> token = requests . post ( GOOGLE_OAUTH2_TOKEN_URL , data = dict ( <EOL> refresh_token = refresh_token , <EOL> grant_type = '<STR_LIT>' , <EOL> client_id = self . client_id , <EOL> client_secret = self . client_secret , <EOL> ) ) . json <EOL> if not token : <EOL> return <EOL> return token <EOL> def oauth2callback ( self , view_func ) : <EOL> """<STR_LIT>""" <EOL> @ wraps ( view_func ) <EOL> def decorated ( * args , ** kwargs ) : <EOL> params = { } <EOL> if '<STR_LIT:state>' in request . args : <EOL> params . update ( ** self . parse_state ( request . args . get ( '<STR_LIT:state>' ) ) ) <EOL> if params . pop ( '<STR_LIT>' , None ) != make_secure_token ( ** params ) : <EOL> return self . login_manager . unauthorized ( ) <EOL> code = request . args . get ( '<STR_LIT:code>' ) <EOL> if code : <EOL> token = self . exchange_code ( <EOL> code , <EOL> url_for ( <EOL> request . endpoint , <EOL> _external = True , <EOL> _scheme = self . redirect_scheme , <EOL> ) , <EOL> ) <EOL> received = self . get_access_token ( token [ '<STR_LIT>' ] ) <EOL> userinfo = self . get_userinfo ( received ) <EOL> params . update ( token = token , userinfo = userinfo ) <EOL> else : <EOL> if params : <EOL> params . update ( dict ( request . args . items ( ) ) ) <EOL> else : <EOL> return '''<STR_LIT>''' <EOL> return view_func ( ** params ) <EOL> return decorated <EOL> def user_loader ( self , func ) : <EOL> """<STR_LIT>""" <EOL> self . login_manager . user_loader ( func ) </s>

<s> __version__ = "<STR_LIT>" <EOL> GOOGLE_AUTH_URI = '<STR_LIT>' <EOL> GOOGLE_REVOKE_URI = '<STR_LIT>' <EOL> GOOGLE_TOKEN_URI = '<STR_LIT>' </s>

<s> from . mbcharsetprober import MultiByteCharSetProber <EOL> from . codingstatemachine import CodingStateMachine <EOL> from . chardistribution import Big5DistributionAnalysis <EOL> from . mbcssm import Big5SMModel <EOL> class Big5Prober ( MultiByteCharSetProber ) : <EOL> def __init__ ( self ) : <EOL> MultiByteCharSetProber . __init__ ( self ) <EOL> self . _mCodingSM = CodingStateMachine ( Big5SMModel ) <EOL> self . _mDistributionAnalyzer = Big5DistributionAnalysis ( ) <EOL> self . reset ( ) <EOL> def get_charset_name ( self ) : <EOL> return "<STR_LIT>" </s>

<s> from . import constants <EOL> from . charsetprober import CharSetProber <EOL> from . codingstatemachine import CodingStateMachine <EOL> from . mbcssm import UTF8SMModel <EOL> ONE_CHAR_PROB = <NUM_LIT:0.5> <EOL> class UTF8Prober ( CharSetProber ) : <EOL> def __init__ ( self ) : <EOL> CharSetProber . __init__ ( self ) <EOL> self . _mCodingSM = CodingStateMachine ( UTF8SMModel ) <EOL> self . reset ( ) <EOL> def reset ( self ) : <EOL> CharSetProber . reset ( self ) <EOL> self . _mCodingSM . reset ( ) <EOL> self . _mNumOfMBChar = <NUM_LIT:0> <EOL> def get_charset_name ( self ) : <EOL> return "<STR_LIT:utf-8>" <EOL> def feed ( self , aBuf ) : <EOL> for c in aBuf : <EOL> codingState = self . _mCodingSM . next_state ( c ) <EOL> if codingState == constants . eError : <EOL> self . _mState = constants . eNotMe <EOL> break <EOL> elif codingState == constants . eItsMe : <EOL> self . _mState = constants . eFoundIt <EOL> break <EOL> elif codingState == constants . eStart : <EOL> if self . _mCodingSM . get_current_charlen ( ) >= <NUM_LIT:2> : <EOL> self . _mNumOfMBChar += <NUM_LIT:1> <EOL> if self . get_state ( ) == constants . eDetecting : <EOL> if self . get_confidence ( ) > constants . SHORTCUT_THRESHOLD : <EOL> self . _mState = constants . eFoundIt <EOL> return self . get_state ( ) <EOL> def get_confidence ( self ) : <EOL> unlike = <NUM_LIT> <EOL> if self . _mNumOfMBChar < <NUM_LIT:6> : <EOL> for i in range ( <NUM_LIT:0> , self . _mNumOfMBChar ) : <EOL> unlike = unlike * ONE_CHAR_PROB <EOL> return <NUM_LIT:1.0> - unlike <EOL> else : <EOL> return unlike </s>

<s> try : <EOL> from cStringIO import StringIO <EOL> except ImportError : <EOL> from StringIO import StringIO <EOL> from . . import KeyValueStore <EOL> class RedisStore ( KeyValueStore ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , redis ) : <EOL> self . redis = redis <EOL> def _delete ( self , key ) : <EOL> return self . redis . delete ( key ) <EOL> def keys ( self ) : <EOL> return self . redis . keys ( ) <EOL> def iter_keys ( self ) : <EOL> return iter ( self . keys ( ) ) <EOL> def _has_key ( self , key ) : <EOL> return self . redis . exists ( key ) <EOL> def _get ( self , key ) : <EOL> val = self . redis . get ( key ) <EOL> if val == None : <EOL> raise KeyError ( key ) <EOL> return val <EOL> def _get_file ( self , key , file ) : <EOL> file . write ( self . _get ( key ) ) <EOL> def _open ( self , key ) : <EOL> return StringIO ( self . _get ( key ) ) <EOL> def _put ( self , key , value ) : <EOL> self . redis . set ( key , value ) <EOL> return key <EOL> def _put_file ( self , key , file ) : <EOL> self . _put ( key , file . read ( ) ) <EOL> return key </s>

<s> """<STR_LIT>""" <EOL> import re <EOL> import posixpath <EOL> from pprint import pformat <EOL> from urlparse import urljoin <EOL> from werkzeug . urls import url_encode , url_decode , url_quote <EOL> from werkzeug . utils import redirect , format_string <EOL> from werkzeug . exceptions import HTTPException , NotFound , MethodNotAllowed <EOL> from werkzeug . _internal import _get_environ <EOL> from werkzeug . datastructures import ImmutableDict , MultiDict <EOL> _rule_re = re . compile ( r'''<STR_LIT>''' , re . VERBOSE ) <EOL> _simple_rule_re = re . compile ( r'<STR_LIT>' ) <EOL> _converter_args_re = re . compile ( r'''<STR_LIT>''' , re . VERBOSE | re . UNICODE ) <EOL> _PYTHON_CONSTANTS = { <EOL> '<STR_LIT:None>' : None , <EOL> '<STR_LIT:True>' : True , <EOL> '<STR_LIT:False>' : False <EOL> } <EOL> def _pythonize ( value ) : <EOL> if value in _PYTHON_CONSTANTS : <EOL> return _PYTHON_CONSTANTS [ value ] <EOL> for convert in int , float : <EOL> try : <EOL> return convert ( value ) <EOL> except ValueError : <EOL> pass <EOL> if value [ : <NUM_LIT:1> ] == value [ - <NUM_LIT:1> : ] and value [ <NUM_LIT:0> ] in '<STR_LIT>' : <EOL> value = value [ <NUM_LIT:1> : - <NUM_LIT:1> ] <EOL> return unicode ( value ) <EOL> def parse_converter_args ( argstr ) : <EOL> argstr += '<STR_LIT:U+002C>' <EOL> args = [ ] <EOL> kwargs = { } <EOL> for item in _converter_args_re . finditer ( argstr ) : <EOL> value = item . group ( '<STR_LIT>' ) <EOL> if value is None : <EOL> value = item . group ( '<STR_LIT:value>' ) <EOL> value = _pythonize ( value ) <EOL> if not item . group ( '<STR_LIT:name>' ) : <EOL> args . append ( value ) <EOL> else : <EOL> name = item . group ( '<STR_LIT:name>' ) <EOL> kwargs [ name ] = value <EOL> return tuple ( args ) , kwargs <EOL> def parse_rule ( rule ) : <EOL> """<STR_LIT>""" <EOL> pos = <NUM_LIT:0> <EOL> end = len ( rule ) <EOL> do_match = _rule_re . match <EOL> used_names = set ( ) <EOL> while pos < end : <EOL> m = do_match ( rule , pos ) <EOL> if m is None : <EOL> break <EOL> data = m . groupdict ( ) <EOL> if data [ '<STR_LIT>' ] : <EOL> yield None , None , data [ '<STR_LIT>' ] <EOL> variable = data [ '<STR_LIT>' ] <EOL> converter = data [ '<STR_LIT>' ] or '<STR_LIT:default>' <EOL> if variable in used_names : <EOL> raise ValueError ( '<STR_LIT>' % variable ) <EOL> used_names . add ( variable ) <EOL> yield converter , data [ '<STR_LIT:args>' ] or None , variable <EOL> pos = m . end ( ) <EOL> if pos < end : <EOL> remaining = rule [ pos : ] <EOL> if '<STR_LIT:>>' in remaining or '<STR_LIT:<>' in remaining : <EOL> raise ValueError ( '<STR_LIT>' % rule ) <EOL> yield None , None , remaining <EOL> def get_converter ( map , name , args ) : <EOL> """<STR_LIT>""" <EOL> if not name in map . converters : <EOL> raise LookupError ( '<STR_LIT>' % name ) <EOL> if args : <EOL> args , kwargs = parse_converter_args ( args ) <EOL> else : <EOL> args = ( ) <EOL> kwargs = { } <EOL> return map . converters [ name ] ( map , * args , ** kwargs ) <EOL> class RoutingException ( Exception ) : <EOL> """<STR_LIT>""" <EOL> class RequestRedirect ( HTTPException , RoutingException ) : <EOL> """<STR_LIT>""" <EOL> code = <NUM_LIT> <EOL> def __init__ ( self , new_url ) : <EOL> RoutingException . __init__ ( self , new_url ) <EOL> self . new_url = new_url <EOL> def get_response ( self , environ ) : <EOL> return redirect ( self . new_url , self . code ) <EOL> class RequestSlash ( RoutingException ) : <EOL> """<STR_LIT>""" <EOL> class RequestAliasRedirect ( RoutingException ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , matched_values ) : <EOL> self . matched_values = matched_values <EOL> class BuildError ( RoutingException , LookupError ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , endpoint , values , method ) : <EOL> LookupError . __init__ ( self , endpoint , values , method ) <EOL> self . endpoint = endpoint <EOL> self . values = values <EOL> self . method = method <EOL> class ValidationError ( ValueError ) : <EOL> """<STR_LIT>""" <EOL> class RuleFactory ( object ) : <EOL> """<STR_LIT>""" <EOL> def get_rules ( self , map ) : <EOL> """<STR_LIT>""" <EOL> raise NotImplementedError ( ) <EOL> class Subdomain ( RuleFactory ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , subdomain , rules ) : <EOL> self . subdomain = subdomain <EOL> self . rules = rules <EOL> def get_rules ( self , map ) : <EOL> for rulefactory in self . rules : <EOL> for rule in rulefactory . get_rules ( map ) : <EOL> rule = rule . empty ( ) <EOL> rule . subdomain = self . subdomain <EOL> yield rule <EOL> class Submount ( RuleFactory ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , path , rules ) : <EOL> self . path = path . rstrip ( '<STR_LIT:/>' ) <EOL> self . rules = rules <EOL> def get_rules ( self , map ) : <EOL> for rulefactory in self . rules : <EOL> for rule in rulefactory . get_rules ( map ) : <EOL> rule = rule . empty ( ) <EOL> rule . rule = self . path + rule . rule <EOL> yield rule <EOL> class EndpointPrefix ( RuleFactory ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , prefix , rules ) : <EOL> self . prefix = prefix <EOL> self . rules = rules <EOL> def get_rules ( self , map ) : <EOL> for rulefactory in self . rules : <EOL> for rule in rulefactory . get_rules ( map ) : <EOL> rule = rule . empty ( ) <EOL> rule . endpoint = self . prefix + rule . endpoint <EOL> yield rule <EOL> class RuleTemplate ( object ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , rules ) : <EOL> self . rules = list ( rules ) <EOL> def __call__ ( self , * args , ** kwargs ) : <EOL> return RuleTemplateFactory ( self . rules , dict ( * args , ** kwargs ) ) <EOL> class RuleTemplateFactory ( RuleFactory ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , rules , context ) : <EOL> self . rules = rules <EOL> self . context = context <EOL> def get_rules ( self , map ) : <EOL> for rulefactory in self . rules : <EOL> for rule in rulefactory . get_rules ( map ) : <EOL> new_defaults = subdomain = None <EOL> if rule . defaults : <EOL> new_defaults = { } <EOL> for key , value in rule . defaults . iteritems ( ) : <EOL> if isinstance ( value , basestring ) : <EOL> value = format_string ( value , self . context ) <EOL> new_defaults [ key ] = value <EOL> if rule . subdomain is not None : <EOL> subdomain = format_string ( rule . subdomain , self . context ) <EOL> new_endpoint = rule . endpoint <EOL> if isinstance ( new_endpoint , basestring ) : <EOL> new_endpoint = format_string ( new_endpoint , self . context ) <EOL> yield Rule ( <EOL> format_string ( rule . rule , self . context ) , <EOL> new_defaults , <EOL> subdomain , <EOL> rule . methods , <EOL> rule . build_only , <EOL> new_endpoint , <EOL> rule . strict_slashes <EOL> ) <EOL> class Rule ( RuleFactory ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , string , defaults = None , subdomain = None , methods = None , <EOL> build_only = False , endpoint = None , strict_slashes = None , <EOL> redirect_to = None , alias = False , host = None ) : <EOL> if not string . startswith ( '<STR_LIT:/>' ) : <EOL> raise ValueError ( '<STR_LIT>' ) <EOL> self . rule = string <EOL> self . is_leaf = not string . endswith ( '<STR_LIT:/>' ) <EOL> self . map = None <EOL> self . strict_slashes = strict_slashes <EOL> self . subdomain = subdomain <EOL> self . host = host <EOL> self . defaults = defaults <EOL> self . build_only = build_only <EOL> self . alias = alias <EOL> if methods is None : <EOL> self . methods = None <EOL> else : <EOL> self . methods = set ( [ x . upper ( ) for x in methods ] ) <EOL> if '<STR_LIT>' not in self . methods and '<STR_LIT:GET>' in self . methods : <EOL> self . methods . add ( '<STR_LIT>' ) <EOL> self . endpoint = endpoint <EOL> self . redirect_to = redirect_to <EOL> if defaults : <EOL> self . arguments = set ( map ( str , defaults ) ) <EOL> else : <EOL> self . arguments = set ( ) <EOL> self . _trace = self . _converters = self . _regex = self . _weights = None <EOL> def empty ( self ) : <EOL> """<STR_LIT>""" <EOL> defaults = None <EOL> if self . defaults : <EOL> defaults = dict ( self . defaults ) <EOL> return Rule ( self . rule , defaults , self . subdomain , self . methods , <EOL> self . build_only , self . endpoint , self . strict_slashes , <EOL> self . redirect_to , self . alias , self . host ) <EOL> def get_rules ( self , map ) : <EOL> yield self <EOL> def refresh ( self ) : <EOL> """<STR_LIT>""" <EOL> self . bind ( self . map , rebind = True ) <EOL> def bind ( self , map , rebind = False ) : <EOL> """<STR_LIT>""" <EOL> if self . map is not None and not rebind : <EOL> raise RuntimeError ( '<STR_LIT>' % <EOL> ( self , self . map ) ) <EOL> self . map = map <EOL> if self . strict_slashes is None : <EOL> self . strict_slashes = map . strict_slashes <EOL> if self . subdomain is None : <EOL> self . subdomain = map . default_subdomain <EOL> self . compile ( ) <EOL> def compile ( self ) : <EOL> """<STR_LIT>""" <EOL> assert self . map is not None , '<STR_LIT>' <EOL> if self . map . host_matching : <EOL> domain_rule = self . host or '<STR_LIT>' <EOL> else : <EOL> domain_rule = self . subdomain or '<STR_LIT>' <EOL> self . _trace = [ ] <EOL> self . _converters = { } <EOL> self . _weights = [ ] <EOL> regex_parts = [ ] <EOL> def _build_regex ( rule ) : <EOL> for converter , arguments , variable in parse_rule ( rule ) : <EOL> if converter is None : <EOL> regex_parts . append ( re . escape ( variable ) ) <EOL> self . _trace . append ( ( False , variable ) ) <EOL> for part in variable . split ( '<STR_LIT:/>' ) : <EOL> if part : <EOL> self . _weights . append ( ( <NUM_LIT:0> , - len ( part ) ) ) <EOL> else : <EOL> convobj = get_converter ( self . map , converter , arguments ) <EOL> regex_parts . append ( '<STR_LIT>' % ( variable , convobj . regex ) ) <EOL> self . _converters [ variable ] = convobj <EOL> self . _trace . append ( ( True , variable ) ) <EOL> self . _weights . append ( ( <NUM_LIT:1> , convobj . weight ) ) <EOL> self . arguments . add ( str ( variable ) ) <EOL> _build_regex ( domain_rule ) <EOL> regex_parts . append ( '<STR_LIT>' ) <EOL> self . _trace . append ( ( False , '<STR_LIT:|>' ) ) <EOL> _build_regex ( self . is_leaf and self . rule or self . rule . rstrip ( '<STR_LIT:/>' ) ) <EOL> if not self . is_leaf : <EOL> self . _trace . append ( ( False , '<STR_LIT:/>' ) ) <EOL> if self . build_only : <EOL> return <EOL> regex = r'<STR_LIT>' % ( <EOL> u'<STR_LIT>' . join ( regex_parts ) , <EOL> ( not self . is_leaf or not self . strict_slashes ) and '<STR_LIT>' or '<STR_LIT>' <EOL> ) <EOL> self . _regex = re . compile ( regex , re . UNICODE ) <EOL> def match ( self , path ) : <EOL> """<STR_LIT>""" <EOL> if not self . build_only : <EOL> m = self . _regex . search ( path ) <EOL> if m is not None : <EOL> groups = m . groupdict ( ) <EOL> if self . strict_slashes and not self . is_leaf and not groups . pop ( '<STR_LIT>' ) : <EOL> raise RequestSlash ( ) <EOL> elif not self . strict_slashes : <EOL> del groups [ '<STR_LIT>' ] <EOL> result = { } <EOL> for name , value in groups . iteritems ( ) : <EOL> try : <EOL> value = self . _converters [ name ] . to_python ( value ) <EOL> except ValidationError : <EOL> return <EOL> result [ str ( name ) ] = value <EOL> if self . defaults : <EOL> result . update ( self . defaults ) <EOL> if self . alias and self . map . redirect_defaults : <EOL> raise RequestAliasRedirect ( result ) <EOL> return result <EOL> def build ( self , values , append_unknown = True ) : <EOL> """<STR_LIT>""" <EOL> tmp = [ ] <EOL> add = tmp . append <EOL> processed = set ( self . arguments ) <EOL> for is_dynamic , data in self . _trace : <EOL> if is_dynamic : <EOL> try : <EOL> add ( self . _converters [ data ] . to_url ( values [ data ] ) ) <EOL> except ValidationError : <EOL> return <EOL> processed . add ( data ) <EOL> else : <EOL> add ( url_quote ( data , self . map . charset , safe = '<STR_LIT>' ) ) <EOL> domain_part , url = ( u'<STR_LIT>' . join ( tmp ) ) . split ( '<STR_LIT:|>' , <NUM_LIT:1> ) <EOL> if append_unknown : <EOL> query_vars = MultiDict ( values ) <EOL> for key in processed : <EOL> if key in query_vars : <EOL> del query_vars [ key ] <EOL> if query_vars : <EOL> url += '<STR_LIT:?>' + url_encode ( query_vars , self . map . charset , <EOL> sort = self . map . sort_parameters , <EOL> key = self . map . sort_key ) <EOL> return domain_part , url <EOL> def provides_defaults_for ( self , rule ) : <EOL> """<STR_LIT>""" <EOL> return not self . build_only and self . defaults and self . endpoint == rule . endpoint and self != rule and self . arguments == rule . arguments <EOL> def suitable_for ( self , values , method = None ) : <EOL> """<STR_LIT>""" <EOL> if method is not None and self . methods is not None and method not in self . methods : <EOL> return False <EOL> defaults = self . defaults or ( ) <EOL> for key in self . arguments : <EOL> if key not in defaults and key not in values : <EOL> return False <EOL> if defaults : <EOL> for key , value in defaults . iteritems ( ) : <EOL> if key in values and value != values [ key ] : <EOL> return False <EOL> return True <EOL> def match_compare_key ( self ) : <EOL> """<STR_LIT>""" <EOL> return bool ( self . arguments ) , - len ( self . _weights ) , self . _weights <EOL> def build_compare_key ( self ) : <EOL> """<STR_LIT>""" <EOL> return self . alias and <NUM_LIT:1> or <NUM_LIT:0> , - len ( self . arguments ) , - len ( self . defaults or ( ) ) <EOL> def __eq__ ( self , other ) : <EOL> return self . __class__ is other . __class__ and self . _trace == other . _trace <EOL> def __ne__ ( self , other ) : <EOL> return not self . __eq__ ( other ) <EOL> def __unicode__ ( self ) : <EOL> return self . rule <EOL> def __str__ ( self ) : <EOL> charset = self . map is not None and self . map . charset or '<STR_LIT:utf-8>' <EOL> return unicode ( self ) . encode ( charset ) <EOL> def __repr__ ( self ) : <EOL> if self . map is None : <EOL> return '<STR_LIT>' % self . __class__ . __name__ <EOL> charset = self . map is not None and self . map . charset or '<STR_LIT:utf-8>' <EOL> tmp = [ ] <EOL> for is_dynamic , data in self . _trace : <EOL> if is_dynamic : <EOL> tmp . append ( '<STR_LIT>' % data ) <EOL> else : <EOL> tmp . append ( data ) <EOL> return '<STR_LIT>' % ( <EOL> self . __class__ . __name__ , <EOL> ( u'<STR_LIT>' . join ( tmp ) . encode ( charset ) ) . lstrip ( '<STR_LIT:|>' ) , <EOL> self . methods is not None and '<STR_LIT>' % '<STR_LIT:U+002CU+0020>' . join ( self . methods ) or '<STR_LIT>' , <EOL> self . endpoint <EOL> ) <EOL> class BaseConverter ( object ) : <EOL> """<STR_LIT>""" <EOL> regex = '<STR_LIT>' <EOL> weight = <NUM_LIT:100> <EOL> def __init__ ( self , map ) : <EOL> self . map = map <EOL> def to_python ( self , value ) : <EOL> return value <EOL> def to_url ( self , value ) : <EOL> return url_quote ( value , self . map . charset ) <EOL> class UnicodeConverter ( BaseConverter ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , map , minlength = <NUM_LIT:1> , maxlength = None , length = None ) : <EOL> BaseConverter . __init__ ( self , map ) <EOL> if length is not None : <EOL> length = '<STR_LIT>' % int ( length ) <EOL> else : <EOL> if maxlength is None : <EOL> maxlength = '<STR_LIT>' <EOL> else : <EOL> maxlength = int ( maxlength ) <EOL> length = '<STR_LIT>' % ( <EOL> int ( minlength ) , <EOL> maxlength <EOL> ) <EOL> self . regex = '<STR_LIT>' + length <EOL> class AnyConverter ( BaseConverter ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , map , * items ) : <EOL> BaseConverter . __init__ ( self , map ) <EOL> self . regex = '<STR_LIT>' % '<STR_LIT:|>' . join ( [ re . escape ( x ) for x in items ] ) <EOL> class PathConverter ( BaseConverter ) : <EOL> """<STR_LIT>""" <EOL> regex = '<STR_LIT>' <EOL> weight = <NUM_LIT:200> <EOL> class NumberConverter ( BaseConverter ) : <EOL> """<STR_LIT>""" <EOL> weight = <NUM_LIT:50> <EOL> def __init__ ( self , map , fixed_digits = <NUM_LIT:0> , min = None , max = None ) : <EOL> BaseConverter . __init__ ( self , map ) <EOL> self . fixed_digits = fixed_digits <EOL> self . min = min <EOL> self . max = max <EOL> def to_python ( self , value ) : <EOL> if ( self . fixed_digits and len ( value ) != self . fixed_digits ) : <EOL> raise ValidationError ( ) <EOL> value = self . num_convert ( value ) <EOL> if ( self . min is not None and value < self . min ) or ( self . max is not None and value > self . max ) : <EOL> raise ValidationError ( ) <EOL> return value <EOL> def to_url ( self , value ) : <EOL> value = self . num_convert ( value ) <EOL> if self . fixed_digits : <EOL> value = ( '<STR_LIT>' % self . fixed_digits ) % value <EOL> return str ( value ) <EOL> class IntegerConverter ( NumberConverter ) : <EOL> """<STR_LIT>""" <EOL> regex = r'<STR_LIT>' <EOL> num_convert = int <EOL> class FloatConverter ( NumberConverter ) : <EOL> """<STR_LIT>""" <EOL> regex = r'<STR_LIT>' <EOL> num_convert = float <EOL> def __init__ ( self , map , min = None , max = None ) : <EOL> NumberConverter . __init__ ( self , map , <NUM_LIT:0> , min , max ) <EOL> DEFAULT_CONVERTERS = { <EOL> '<STR_LIT:default>' : UnicodeConverter , <EOL> '<STR_LIT:string>' : UnicodeConverter , <EOL> '<STR_LIT>' : AnyConverter , <EOL> '<STR_LIT:path>' : PathConverter , <EOL> '<STR_LIT:int>' : IntegerConverter , <EOL> '<STR_LIT:float>' : FloatConverter <EOL> } <EOL> class Map ( object ) : <EOL> """<STR_LIT>""" <EOL> default_converters = ImmutableDict ( DEFAULT_CONVERTERS ) <EOL> def __init__ ( self , rules = None , default_subdomain = '<STR_LIT>' , charset = '<STR_LIT:utf-8>' , <EOL> strict_slashes = True , redirect_defaults = True , <EOL> converters = None , sort_parameters = False , sort_key = None , <EOL> encoding_errors = '<STR_LIT:replace>' , host_matching = False ) : <EOL> self . _rules = [ ] <EOL> self . _rules_by_endpoint = { } <EOL> self . _remap = True <EOL> self . default_subdomain = default_subdomain <EOL> self . charset = charset <EOL> self . encoding_errors = encoding_errors <EOL> self . strict_slashes = strict_slashes <EOL> self . redirect_defaults = redirect_defaults <EOL> self . host_matching = host_matching <EOL> self . converters = self . default_converters . copy ( ) <EOL> if converters : <EOL> self . converters . update ( converters ) <EOL> self . sort_parameters = sort_parameters <EOL> self . sort_key = sort_key <EOL> for rulefactory in rules or ( ) : <EOL> self . add ( rulefactory ) <EOL> def is_endpoint_expecting ( self , endpoint , * arguments ) : <EOL> """<STR_LIT>""" <EOL> self . update ( ) <EOL> arguments = set ( arguments ) <EOL> for rule in self . _rules_by_endpoint [ endpoint ] : <EOL> if arguments . issubset ( rule . arguments ) : <EOL> return True <EOL> return False <EOL> def iter_rules ( self , endpoint = None ) : <EOL> """<STR_LIT>""" <EOL> self . update ( ) <EOL> if endpoint is not None : <EOL> return iter ( self . _rules_by_endpoint [ endpoint ] ) <EOL> return iter ( self . _rules ) <EOL> def add ( self , rulefactory ) : <EOL> """<STR_LIT>""" <EOL> for rule in rulefactory . get_rules ( self ) : <EOL> rule . bind ( self ) <EOL> self . _rules . append ( rule ) <EOL> self . _rules_by_endpoint . setdefault ( rule . endpoint , [ ] ) . append ( rule ) <EOL> self . _remap = True <EOL> def bind ( self , server_name , script_name = None , subdomain = None , <EOL> url_scheme = '<STR_LIT:http>' , default_method = '<STR_LIT:GET>' , path_info = None , <EOL> query_args = None ) : <EOL> """<STR_LIT>""" <EOL> server_name = server_name . lower ( ) <EOL> if self . host_matching : <EOL> if subdomain is not None : <EOL> raise RuntimeError ( '<STR_LIT>' <EOL> '<STR_LIT>' ) <EOL> elif subdomain is None : <EOL> subdomain = self . default_subdomain <EOL> if script_name is None : <EOL> script_name = '<STR_LIT:/>' <EOL> if isinstance ( server_name , unicode ) : <EOL> server_name = server_name . encode ( '<STR_LIT>' ) <EOL> return MapAdapter ( self , server_name , script_name , subdomain , <EOL> url_scheme , path_info , default_method , query_args ) <EOL> def bind_to_environ ( self , environ , server_name = None , subdomain = None ) : <EOL> """<STR_LIT>""" <EOL> environ = _get_environ ( environ ) <EOL> if server_name is None : <EOL> if '<STR_LIT>' in environ : <EOL> server_name = environ [ '<STR_LIT>' ] <EOL> else : <EOL> server_name = environ [ '<STR_LIT>' ] <EOL> if ( environ [ '<STR_LIT>' ] , environ [ '<STR_LIT>' ] ) not in ( ( '<STR_LIT>' , '<STR_LIT>' ) , ( '<STR_LIT:http>' , '<STR_LIT>' ) ) : <EOL> server_name += '<STR_LIT::>' + environ [ '<STR_LIT>' ] <EOL> elif subdomain is None and not self . host_matching : <EOL> server_name = server_name . lower ( ) <EOL> if '<STR_LIT>' in environ : <EOL> wsgi_server_name = environ . get ( '<STR_LIT>' ) <EOL> else : <EOL> wsgi_server_name = environ . get ( '<STR_LIT>' ) <EOL> if ( environ [ '<STR_LIT>' ] , environ [ '<STR_LIT>' ] ) not in ( ( '<STR_LIT>' , '<STR_LIT>' ) , ( '<STR_LIT:http>' , '<STR_LIT>' ) ) : <EOL> wsgi_server_name += '<STR_LIT::>' + environ [ '<STR_LIT>' ] <EOL> wsgi_server_name = wsgi_server_name . lower ( ) <EOL> cur_server_name = wsgi_server_name . split ( '<STR_LIT:.>' ) <EOL> real_server_name = server_name . split ( '<STR_LIT:.>' ) <EOL> offset = - len ( real_server_name ) <EOL> if cur_server_name [ offset : ] != real_server_name : <EOL> subdomain = '<STR_LIT>' <EOL> else : <EOL> subdomain = '<STR_LIT:.>' . join ( filter ( None , cur_server_name [ : offset ] ) ) <EOL> return Map . bind ( self , server_name , environ . get ( '<STR_LIT>' ) , <EOL> subdomain , environ [ '<STR_LIT>' ] , <EOL> environ [ '<STR_LIT>' ] , environ . get ( '<STR_LIT>' ) , <EOL> query_args = environ . get ( '<STR_LIT>' , '<STR_LIT>' ) ) <EOL> def update ( self ) : <EOL> """<STR_LIT>""" <EOL> if self . _remap : <EOL> self . _rules . sort ( key = lambda x : x . match_compare_key ( ) ) <EOL> for rules in self . _rules_by_endpoint . itervalues ( ) : <EOL> rules . sort ( key = lambda x : x . build_compare_key ( ) ) <EOL> self . _remap = False <EOL> def __repr__ ( self ) : <EOL> rules = self . iter_rules ( ) <EOL> return '<STR_LIT>' % ( self . __class__ . __name__ , pformat ( list ( rules ) ) ) <EOL> class MapAdapter ( object ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , map , server_name , script_name , subdomain , <EOL> url_scheme , path_info , default_method , query_args = None ) : <EOL> self . map = map <EOL> self . server_name = server_name <EOL> if not script_name . endswith ( '<STR_LIT:/>' ) : <EOL> script_name += '<STR_LIT:/>' <EOL> self . script_name = script_name <EOL> self . subdomain = subdomain <EOL> self . url_scheme = url_scheme <EOL> self . path_info = path_info or u'<STR_LIT>' <EOL> self . default_method = default_method <EOL> self . query_args = query_args <EOL> def dispatch ( self , view_func , path_info = None , method = None , <EOL> catch_http_exceptions = False ) : <EOL> """<STR_LIT>""" <EOL> try : <EOL> try : <EOL> endpoint , args = self . match ( path_info , method ) <EOL> except RequestRedirect , e : <EOL> return e <EOL> return view_func ( endpoint , args ) <EOL> except HTTPException , e : <EOL> if catch_http_exceptions : <EOL> return e <EOL> raise <EOL> def match ( self , path_info = None , method = None , return_rule = False , <EOL> query_args = None ) : <EOL> """<STR_LIT>""" <EOL> self . map . update ( ) <EOL> if path_info is None : <EOL> path_info = self . path_info <EOL> if not isinstance ( path_info , unicode ) : <EOL> path_info = path_info . decode ( self . map . charset , <EOL> self . map . encoding_errors ) <EOL> if query_args is None : <EOL> query_args = self . query_args <EOL> method = ( method or self . default_method ) . upper ( ) <EOL> path = u'<STR_LIT>' % ( self . map . host_matching and self . server_name or <EOL> self . subdomain , path_info . lstrip ( '<STR_LIT:/>' ) ) <EOL> have_match_for = set ( ) <EOL> for rule in self . map . _rules : <EOL> try : <EOL> rv = rule . match ( path ) <EOL> except RequestSlash : <EOL> raise RequestRedirect ( self . make_redirect_url ( <EOL> path_info + '<STR_LIT:/>' , query_args ) ) <EOL> except RequestAliasRedirect , e : <EOL> raise RequestRedirect ( self . make_alias_redirect_url ( <EOL> path , rule . endpoint , e . matched_values , method , query_args ) ) <EOL> if rv is None : <EOL> continue <EOL> if rule . methods is not None and method not in rule . methods : <EOL> have_match_for . update ( rule . methods ) <EOL> continue <EOL> if self . map . redirect_defaults : <EOL> redirect_url = self . get_default_redirect ( rule , method , rv , <EOL> query_args ) <EOL> if redirect_url is not None : <EOL> raise RequestRedirect ( redirect_url ) <EOL> if rule . redirect_to is not None : <EOL> if isinstance ( rule . redirect_to , basestring ) : <EOL> def _handle_match ( match ) : <EOL> value = rv [ match . group ( <NUM_LIT:1> ) ] <EOL> return rule . _converters [ match . group ( <NUM_LIT:1> ) ] . to_url ( value ) <EOL> redirect_url = _simple_rule_re . sub ( _handle_match , <EOL> rule . redirect_to ) <EOL> else : <EOL> redirect_url = rule . redirect_to ( self , ** rv ) <EOL> raise RequestRedirect ( str ( urljoin ( '<STR_LIT>' % ( <EOL> self . url_scheme , <EOL> self . subdomain and self . subdomain + '<STR_LIT:.>' or '<STR_LIT>' , <EOL> self . server_name , <EOL> self . script_name <EOL> ) , redirect_url ) ) ) <EOL> if return_rule : <EOL> return rule , rv <EOL> else : <EOL> return rule . endpoint , rv <EOL> if have_match_for : <EOL> raise MethodNotAllowed ( valid_methods = list ( have_match_for ) ) <EOL> raise NotFound ( ) <EOL> def test ( self , path_info = None , method = None ) : <EOL> """<STR_LIT>""" <EOL> try : <EOL> self . match ( path_info , method ) <EOL> except RequestRedirect : <EOL> pass <EOL> except HTTPException : <EOL> return False <EOL> return True <EOL> def allowed_methods ( self , path_info = None ) : <EOL> """<STR_LIT>""" <EOL> try : <EOL> self . match ( path_info , method = '<STR_LIT>' ) <EOL> except MethodNotAllowed , e : <EOL> return e . valid_methods <EOL> except HTTPException , e : <EOL> pass <EOL> return [ ] <EOL> def get_host ( self , domain_part ) : <EOL> """<STR_LIT>""" <EOL> if self . map . host_matching : <EOL> if domain_part is None : <EOL> return self . server_name <EOL> return domain_part <EOL> subdomain = domain_part <EOL> if subdomain is None : <EOL> subdomain = self . subdomain <EOL> return ( subdomain and subdomain + '<STR_LIT:.>' or '<STR_LIT>' ) + self . server_name <EOL> def get_default_redirect ( self , rule , method , values , query_args ) : <EOL> """<STR_LIT>""" <EOL> assert self . map . redirect_defaults <EOL> for r in self . map . _rules_by_endpoint [ rule . endpoint ] : <EOL> if r is rule : <EOL> break <EOL> if r . provides_defaults_for ( rule ) and r . suitable_for ( values , method ) : <EOL> values . update ( r . defaults ) <EOL> domain_part , path = r . build ( values ) <EOL> return self . make_redirect_url ( <EOL> path , query_args , domain_part = domain_part ) <EOL> def encode_query_args ( self , query_args ) : <EOL> if not isinstance ( query_args , basestring ) : <EOL> query_args = url_encode ( query_args , self . map . charset ) <EOL> return query_args <EOL> def make_redirect_url ( self , path_info , query_args = None , domain_part = None ) : <EOL> """<STR_LIT>""" <EOL> suffix = '<STR_LIT>' <EOL> if query_args : <EOL> suffix = '<STR_LIT:?>' + self . encode_query_args ( query_args ) <EOL> return str ( '<STR_LIT>' % ( <EOL> self . url_scheme , <EOL> self . get_host ( domain_part ) , <EOL> posixpath . join ( self . script_name [ : - <NUM_LIT:1> ] . lstrip ( '<STR_LIT:/>' ) , <EOL> url_quote ( path_info . lstrip ( '<STR_LIT:/>' ) , self . map . charset ) ) , <EOL> suffix <EOL> ) ) <EOL> def make_alias_redirect_url ( self , path , endpoint , values , method , query_args ) : <EOL> """<STR_LIT>""" <EOL> url = self . build ( endpoint , values , method , append_unknown = False , <EOL> force_external = True ) <EOL> if query_args : <EOL> url += '<STR_LIT:?>' + self . encode_query_args ( query_args ) <EOL> assert url != path , '<STR_LIT>' '<STR_LIT>' <EOL> return url <EOL> def _partial_build ( self , endpoint , values , method , append_unknown ) : <EOL> """<STR_LIT>""" <EOL> if method is None : <EOL> rv = self . _partial_build ( endpoint , values , self . default_method , <EOL> append_unknown ) <EOL> if rv is not None : <EOL> return rv <EOL> for rule in self . map . _rules_by_endpoint . get ( endpoint , ( ) ) : <EOL> if rule . suitable_for ( values , method ) : <EOL> rv = rule . build ( values , append_unknown ) <EOL> if rv is not None : <EOL> return rv <EOL> def build ( self , endpoint , values = None , method = None , force_external = False , <EOL> append_unknown = True ) : <EOL> """<STR_LIT>""" <EOL> self . map . update ( ) <EOL> if values : <EOL> if isinstance ( values , MultiDict ) : <EOL> valueiter = values . iteritems ( multi = True ) <EOL> else : <EOL> valueiter = values . iteritems ( ) <EOL> values = dict ( ( k , v ) for k , v in valueiter if v is not None ) <EOL> else : <EOL> values = { } <EOL> rv = self . _partial_build ( endpoint , values , method , append_unknown ) <EOL> if rv is None : <EOL> raise BuildError ( endpoint , values , method ) <EOL> domain_part , path = rv <EOL> host = self . get_host ( domain_part ) <EOL> if not force_external and ( <EOL> ( self . map . host_matching and host == self . server_name ) or <EOL> ( not self . map . host_matching and domain_part == self . subdomain ) ) : <EOL> return str ( urljoin ( self . script_name , '<STR_LIT>' + path . lstrip ( '<STR_LIT:/>' ) ) ) <EOL> return str ( '<STR_LIT>' % ( <EOL> self . url_scheme , <EOL> host , <EOL> self . script_name [ : - <NUM_LIT:1> ] , <EOL> path . lstrip ( '<STR_LIT:/>' ) <EOL> ) ) </s>

<s> from wtforms . fields . core import * <EOL> from wtforms . fields . simple import * <EOL> from wtforms . fields . core import Label , Field , _unset_value , SelectFieldBase , Flags </s>

<s> from django import forms <EOL> from multiupload . fields import MultiFileField <EOL> class UploadTestForm ( forms . Form ) : <EOL> attachments = MultiFileField ( <EOL> min_num = <NUM_LIT:1> , <EOL> max_num = <NUM_LIT:3> , <EOL> max_file_size = <NUM_LIT> * <NUM_LIT> * <NUM_LIT:5> <EOL> ) </s>

<s> """<STR_LIT>""" <EOL> import ds9 <EOL> import os <EOL> from bubbly . field import Field <EOL> __all__ = [ '<STR_LIT>' ] <EOL> class BubblyViewer ( object ) : <EOL> def __init__ ( self ) : <EOL> self . ds9 = None <EOL> def start ( self ) : <EOL> """<STR_LIT>""" <EOL> if self . ds9 is None : <EOL> self . ds9 = ds9 . ds9 ( ) <EOL> def load_longitude ( self , lon ) : <EOL> """<STR_LIT>""" <EOL> self . start ( ) <EOL> f = Field ( lon ) <EOL> g = os . path . join ( f . path , '<STR_LIT>' , '<STR_LIT>' % lon ) <EOL> r = os . path . join ( f . path , '<STR_LIT>' , '<STR_LIT>' % lon ) <EOL> self . ds9 . set ( '<STR_LIT>' ) <EOL> self . ds9 . set ( '<STR_LIT>' ) <EOL> self . ds9 . set ( '<STR_LIT>' ) <EOL> self . ds9 . set ( '<STR_LIT>' % r ) <EOL> self . ds9 . set ( '<STR_LIT>' ) <EOL> self . ds9 . set ( '<STR_LIT>' % g ) <EOL> self . _set_zscale ( ) <EOL> self . _align_galactic ( ) <EOL> def _set_zscale ( self ) : <EOL> self . ds9 . set ( '<STR_LIT>' ) <EOL> self . ds9 . set ( '<STR_LIT>' ) <EOL> self . ds9 . set ( '<STR_LIT>' ) <EOL> self . ds9 . set ( '<STR_LIT>' ) <EOL> def _align_galactic ( self ) : <EOL> self . ds9 . set ( '<STR_LIT>' ) <EOL> self . ds9 . set ( '<STR_LIT>' ) <EOL> def look_at ( self , params ) : <EOL> """<STR_LIT>""" <EOL> if self . ds9 is None : <EOL> self . load_longitude ( params [ <NUM_LIT:0> ] ) <EOL> l , b = params [ <NUM_LIT:1> : <NUM_LIT:3> ] <EOL> r = params [ - <NUM_LIT:1> ] <EOL> zoom = <NUM_LIT:2> / <NUM_LIT> / r * <NUM_LIT> <EOL> self . ds9 . set ( '<STR_LIT>' . format ( l = l , b = b ) ) <EOL> self . ds9 . set ( '<STR_LIT>' % zoom ) <EOL> def outline ( self , params , color = '<STR_LIT>' ) : <EOL> """<STR_LIT>""" <EOL> if not hasattr ( params [ <NUM_LIT:0> ] , '<STR_LIT>' ) : <EOL> params = [ params ] <EOL> for i , p in enumerate ( params ) : <EOL> l , b , r = p [ <NUM_LIT:1> : ] <EOL> self . ds9 . set ( '<STR_LIT>' , <EOL> '<STR_LIT>' % <EOL> ( l , b , r , color , i ) ) <EOL> def clear ( self ) : <EOL> """<STR_LIT>""" <EOL> self . ds9 . set ( '<STR_LIT>' ) </s>

<s> from glob import glob <EOL> import os <EOL> import h5py <EOL> import numpy as np <EOL> from astropy . table import Table <EOL> from bubbly . cluster import merge , xmatch <EOL> def above_thresh ( thresh ) : <EOL> result = [ ] <EOL> scores = [ ] <EOL> for file in glob ( '<STR_LIT>' ) : <EOL> with h5py . File ( file , '<STR_LIT:r>' ) as data : <EOL> good = data [ '<STR_LIT>' ] [ ... ] > thresh <EOL> result . append ( data [ '<STR_LIT>' ] [ ... ] [ good ] ) <EOL> scores . append ( data [ '<STR_LIT>' ] [ ... ] [ good ] ) <EOL> print file , good . sum ( ) <EOL> return np . vstack ( result ) , np . hstack ( scores ) <EOL> def chunked_merge ( stamps , scores ) : <EOL> stamps [ stamps [ : , <NUM_LIT:1> ] > <NUM_LIT> , <NUM_LIT:1> ] -= <NUM_LIT> <EOL> lon = stamps [ : , <NUM_LIT:1> ] <EOL> ostamps , oscores = [ ] , [ ] <EOL> for lcen in np . arange ( lon . min ( ) , lon . max ( ) + <NUM_LIT:1> , <NUM_LIT:1> ) : <EOL> good = np . abs ( lon - lcen ) < <NUM_LIT:1> <EOL> if good . sum ( ) == <NUM_LIT:0> : <EOL> continue <EOL> st , sc = merge ( stamps [ good ] , scores [ good ] ) <EOL> good = np . abs ( st [ : , <NUM_LIT:1> ] - lcen ) < <NUM_LIT> <EOL> if good . sum ( ) == <NUM_LIT:0> : <EOL> continue <EOL> ostamps . append ( st [ good ] ) <EOL> oscores . append ( sc [ good ] ) <EOL> print lcen , good . sum ( ) <EOL> result = merge ( np . vstack ( ostamps ) , np . hstack ( oscores ) ) <EOL> result [ <NUM_LIT:0> ] [ result [ <NUM_LIT:0> ] [ : , <NUM_LIT:1> ] < <NUM_LIT:0> , <NUM_LIT:1> ] += <NUM_LIT> <EOL> return result <EOL> def write_catalog ( stamps , scores , outfile ) : <EOL> t = Table ( [ stamps [ : , <NUM_LIT:1> ] , stamps [ : , <NUM_LIT:2> ] , stamps [ : , <NUM_LIT:3> ] , scores ] , <EOL> names = [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] ) <EOL> t . write ( outfile , format = '<STR_LIT:ascii>' , delimiter = '<STR_LIT:U+002C>' ) <EOL> def main ( ) : <EOL> thresh = <NUM_LIT> <EOL> stamps , scores = above_thresh ( thresh ) <EOL> print "<STR_LIT>" % ( thresh , len ( scores ) ) <EOL> merged , mscores = chunked_merge ( stamps , scores ) <EOL> print "<STR_LIT>" % len ( mscores ) <EOL> write_catalog ( merged , mscores , '<STR_LIT>' ) <EOL> if __name__ == '<STR_LIT:__main__>' : <EOL> main ( ) </s>

<s> from HybridModel import HybridModel <EOL> class SynthModel ( HybridModel ) : <EOL> def __init__ ( self , configModel , utils , strTrial ) : <EOL> self . tag = configModel [ <NUM_LIT:0> ] <EOL> self . mode = configModel [ <NUM_LIT:1> ] <EOL> self . misc = configModel [ <NUM_LIT:2> ] <EOL> self . trial = strTrial <EOL> self . masterTest = utils . TEST_IDS_PATH <EOL> self . runTrain = utils . SYNTH_BOOT_PATH + '<STR_LIT>' + strTrial <EOL> self . runCV = utils . SYNTH_BOOT_PATH + '<STR_LIT>' + strTrial <EOL> self . runTest = utils . SYNTH_ORIGINAL_PATH + '<STR_LIT>' + strTrial <EOL> self . predTest = utils . SYNTH_PREDICT_PATH + '<STR_LIT:t>' + strTrial <EOL> self . bootCV = self . runCV + '<STR_LIT>' <EOL> self . predCV = utils . SYNTH_PREDICT_PATH + '<STR_LIT>' + strTrial <EOL> self . predTestTmp = self . predTest + '<STR_LIT>' <EOL> self . predCVTmp = self . predCV + '<STR_LIT>' <EOL> self . log = utils . SYNTH_LOG_PATH + self . tag + '<STR_LIT>' + strTrial <EOL> self . RMSEPath = utils . SYNTH_RMSE_PATH + self . tag + '<STR_LIT>' + strTrial <EOL> self . setupRVars ( utils ) </s>

<s> """<STR_LIT>""" <EOL> from tagger import ID3FrameException <EOL> from tagger import ID3v1 <EOL> from tagger import ID3v2 <EOL> __all__ = [ "<STR_LIT>" ] <EOL> def _genre_convert ( genre ) : <EOL> """<STR_LIT>""" <EOL> genre_number = None <EOL> try : <EOL> genre_number = int ( genre . strip ( "<STR_LIT>" ) ) <EOL> except ( ValueError , TypeError ) : <EOL> pass <EOL> if genre_number is not None : <EOL> try : <EOL> return _NUMERIC_GENRES [ genre_number ] <EOL> except KeyError : <EOL> pass <EOL> return genre <EOL> def _track_convert ( track ) : <EOL> """<STR_LIT>""" <EOL> if '<STR_LIT:/>' in track : <EOL> return int ( track . split ( "<STR_LIT:/>" ) [ <NUM_LIT:0> ] ) <EOL> return int ( track ) <EOL> def _force_unicode ( bstr , encoding , fallback_encodings = None ) : <EOL> """<STR_LIT>""" <EOL> if isinstance ( bstr , unicode ) : <EOL> return bstr <EOL> if fallback_encodings is None : <EOL> fallback_encodings = [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] <EOL> encodings = [ encoding ] + fallback_encodings <EOL> for enc in encodings : <EOL> try : <EOL> return bstr . decode ( enc ) <EOL> except UnicodeDecodeError : <EOL> pass <EOL> return bstr . decode ( encoding , '<STR_LIT:ignore>' ) <EOL> class ID3TagDescriptor ( object ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , v24fid , v23fid = None , v22fid = None , v1fid = None , <EOL> converter = None ) : <EOL> """<STR_LIT>""" <EOL> self . v1fid = v1fid <EOL> self . v22fid = v22fid <EOL> self . v23fid = v23fid <EOL> self . v24fid = v24fid <EOL> self . converter = converter or ( lambda x : x ) <EOL> def _get_fid_by_version ( self , instance ) : <EOL> """<STR_LIT>""" <EOL> if instance . _id3v2 . version in ( <NUM_LIT> , "<STR_LIT>" ) : <EOL> return self . v24fid <EOL> elif instance . _id3v2 . version in ( <NUM_LIT> , "<STR_LIT>" ) : <EOL> return self . v23fid <EOL> elif instance . _id3v2 . version in ( <NUM_LIT> , "<STR_LIT>" ) : <EOL> return self . v22fid <EOL> else : <EOL> return self . v24fid <EOL> def __set__ ( self , instance , value ) : <EOL> """<STR_LIT>""" <EOL> if not hasattr ( instance , "<STR_LIT>" ) : <EOL> return <EOL> fid = self . _get_fid_by_version ( instance ) <EOL> if fid is None : <EOL> return <EOL> new_frame = instance . _id3v2 . new_frame ( fid ) <EOL> new_frame . set_text ( _force_unicode ( value , '<STR_LIT>' ) ) <EOL> if instance . _id3v2_frames . has_key ( fid ) : <EOL> instance . _id3v2 . frames . remove ( instance . _id3v2_frames [ fid ] [ <NUM_LIT:0> ] ) <EOL> del instance . _id3v2_frames [ fid ] [ <NUM_LIT:0> ] <EOL> instance . _id3v2 . frames . append ( new_frame ) <EOL> instance . _id3v2_frames . setdefault ( fid , [ ] ) <EOL> instance . _id3v2_frames [ fid ] . append ( new_frame ) <EOL> def __get__ ( self , instance , instance_class = None ) : <EOL> """<STR_LIT>""" <EOL> if instance is None : <EOL> return None <EOL> try : <EOL> return self . converter ( self . _get_id3v2 ( instance ) ) <EOL> except ValueError : <EOL> pass <EOL> try : <EOL> return self . converter ( self . _get_id3v1 ( instance ) ) <EOL> except ValueError : <EOL> pass <EOL> return None <EOL> def _get_id3v1 ( self , instance ) : <EOL> """<STR_LIT>""" <EOL> try : <EOL> return _force_unicode ( getattr ( instance . _id3v1 , self . v1fid ) , <EOL> '<STR_LIT>' ) <EOL> except AttributeError : <EOL> raise ValueError ( '<STR_LIT>' ) <EOL> def _get_id3v2 ( self , instance ) : <EOL> """<STR_LIT>""" <EOL> id3v2_frames = instance . _id3v2_frames <EOL> fid = self . _get_fid_by_version ( instance ) <EOL> try : <EOL> first_frame = id3v2_frames [ fid ] [ <NUM_LIT:0> ] <EOL> except KeyError : <EOL> pass <EOL> else : <EOL> first_frame . parse_field ( ) <EOL> first_string = first_frame . strings [ <NUM_LIT:0> ] . replace ( "<STR_LIT:\x00>" , "<STR_LIT>" ) <EOL> return _force_unicode ( first_string , first_frame . encoding ) <EOL> raise ValueError ( '<STR_LIT>' ) <EOL> @ classmethod <EOL> def initialize_owner ( cls , instance , filepath , force = False ) : <EOL> """<STR_LIT>""" <EOL> if not hasattr ( instance , "<STR_LIT>" ) or force : <EOL> instance . _id3v1 = ID3v1 ( filepath ) <EOL> if not hasattr ( instance , "<STR_LIT>" ) or force : <EOL> instance . _id3v2 = ID3v2 ( filepath ) <EOL> if not hasattr ( instance , "<STR_LIT>" ) or force : <EOL> instance . _id3v2_frames = { } <EOL> for frame in instance . _id3v2 . frames : <EOL> instance . _id3v2_frames . setdefault ( frame . fid , [ ] ) <EOL> instance . _id3v2_frames [ frame . fid ] . append ( frame ) <EOL> @ classmethod <EOL> def save ( cls , instance ) : <EOL> """<STR_LIT>""" <EOL> instance . _id3v2 . commit ( ) <EOL> _NUMERIC_GENRES = { <EOL> <NUM_LIT:0> : "<STR_LIT>" , <EOL> <NUM_LIT:1> : "<STR_LIT>" , <EOL> <NUM_LIT:2> : "<STR_LIT>" , <EOL> <NUM_LIT:3> : "<STR_LIT>" , <EOL> <NUM_LIT:4> : "<STR_LIT>" , <EOL> <NUM_LIT:5> : "<STR_LIT>" , <EOL> <NUM_LIT:6> : "<STR_LIT>" , <EOL> <NUM_LIT:7> : "<STR_LIT>" , <EOL> <NUM_LIT:8> : "<STR_LIT>" , <EOL> <NUM_LIT:9> : "<STR_LIT>" , <EOL> <NUM_LIT:10> : "<STR_LIT>" , <EOL> <NUM_LIT:11> : "<STR_LIT>" , <EOL> <NUM_LIT:12> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT:15> : "<STR_LIT>" , <EOL> <NUM_LIT:16> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT:20> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT:30> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT:32> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT:50> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT:64> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT:100> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> <NUM_LIT> : "<STR_LIT>" , <EOL> } </s>

<s> import unittest <EOL> from JustReleaseNotes . artifacters import GitHubReleases <EOL> import requests <EOL> import requests_mock <EOL> import sys <EOL> class GitHubReleases_Test ( unittest . TestCase ) : <EOL> def setUp ( self ) : <EOL> self . __stdoutSaved = sys . stdout <EOL> try : <EOL> from StringIO import StringIO <EOL> except ImportError : <EOL> from io import StringIO <EOL> self . __out = StringIO ( ) <EOL> sys . stdout = self . __out <EOL> def tearDown ( self ) : <EOL> sys . stdout = self . __stdoutSaved <EOL> def test_retrievePromotedVersionsContainsValidVersions ( self ) : <EOL> requests . packages . urllib3 . disable_warnings ( ) <EOL> fileContents = '<STR_LIT>' '<STR_LIT>' <EOL> config = { "<STR_LIT>" : "<STR_LIT>" , <EOL> "<STR_LIT>" : "<STR_LIT>" , <EOL> "<STR_LIT>" : "<STR_LIT>" } <EOL> artifacter = GitHubReleases . GitHubReleases ( config ) ; <EOL> with requests_mock . mock ( ) as m : <EOL> m . get ( '<STR_LIT>' , text = fileContents ) <EOL> promotedVersion = artifacter . retrievePromotedVersions ( ) <EOL> self . assertIn ( "<STR_LIT>" , promotedVersion ) <EOL> self . assertIn ( "<STR_LIT>" , promotedVersion ) <EOL> self . assertTrue ( <NUM_LIT:2> , len ( promotedVersion ) ) <EOL> sys . stdout = self . __stdoutSaved <EOL> self . assertEquals ( '<STR_LIT>' <EOL> '<STR_LIT>' , <EOL> self . __out . getvalue ( ) ) <EOL> def test_retrievePromotedVersionsFromEmptyArrayRaises ( self ) : <EOL> requests . packages . urllib3 . disable_warnings ( ) <EOL> fileContents = '<STR_LIT>' <EOL> config = { "<STR_LIT>" : "<STR_LIT>" , <EOL> "<STR_LIT>" : "<STR_LIT>" , <EOL> "<STR_LIT>" : "<STR_LIT>" } <EOL> artifacter = GitHubReleases . GitHubReleases ( config ) ; <EOL> with requests_mock . mock ( ) as m : <EOL> m . get ( '<STR_LIT>' , text = fileContents ) <EOL> with self . assertRaises ( ValueError ) : <EOL> artifacter . retrievePromotedVersions ( ) <EOL> if __name__ == '<STR_LIT:__main__>' : <EOL> unittest . main ( ) </s>

<s> import json <EOL> import os <EOL> import requests <EOL> import sys <EOL> def credentials ( ) : <EOL> """<STR_LIT>""" <EOL> username = os . environ . get ( '<STR_LIT>' ) <EOL> password = os . environ . get ( '<STR_LIT>' ) <EOL> tenant_name = os . environ . get ( '<STR_LIT>' ) <EOL> auth_url = os . environ . get ( '<STR_LIT>' ) <EOL> if not all ( ( username , password , tenant_name , auth_url ) ) : <EOL> sys . stderr . write ( "<STR_LIT>" ) <EOL> exit ( <NUM_LIT:1> ) <EOL> return { <EOL> '<STR_LIT:username>' : username , <EOL> '<STR_LIT:password>' : password , <EOL> '<STR_LIT>' : tenant_name , <EOL> '<STR_LIT>' : auth_url <EOL> } <EOL> def get_catalog ( ) : <EOL> """<STR_LIT>""" <EOL> creds = credentials ( ) <EOL> headers = { '<STR_LIT:Content-Type>' : '<STR_LIT:application/json>' } <EOL> payload = { <EOL> "<STR_LIT>" : <EOL> { <EOL> "<STR_LIT>" : creds [ '<STR_LIT>' ] , <EOL> "<STR_LIT>" : { <EOL> "<STR_LIT:username>" : creds [ '<STR_LIT:username>' ] , <EOL> "<STR_LIT:password>" : creds [ '<STR_LIT:password>' ] <EOL> } <EOL> } <EOL> } <EOL> auth_url = creds [ '<STR_LIT>' ] + "<STR_LIT>" <EOL> r = requests . post ( auth_url , headers = headers , data = json . dumps ( payload ) ) <EOL> parsed_json = json . loads ( r . text ) <EOL> if not parsed_json or '<STR_LIT:error>' in parsed_json : <EOL> sys . stderr . write ( "<STR_LIT>" ) <EOL> exit ( <NUM_LIT:1> ) <EOL> return parsed_json <EOL> def get_token ( catalog ) : <EOL> """<STR_LIT>""" <EOL> return catalog [ '<STR_LIT>' ] [ '<STR_LIT>' ] [ '<STR_LIT:id>' ] <EOL> def neutron_public_url ( catalog ) : <EOL> """<STR_LIT>""" <EOL> for i in catalog [ '<STR_LIT>' ] [ '<STR_LIT>' ] : <EOL> if i [ '<STR_LIT:name>' ] == '<STR_LIT>' : <EOL> for endpoint in i [ '<STR_LIT>' ] : <EOL> return endpoint [ '<STR_LIT>' ] <EOL> def list_ports ( token , public_url ) : <EOL> """<STR_LIT>""" <EOL> headers = { '<STR_LIT>' : token } <EOL> auth_url = public_url + "<STR_LIT>" <EOL> r = requests . get ( auth_url , headers = headers ) <EOL> if r . text : <EOL> parsed_json = json . loads ( r . text ) <EOL> return parsed_json [ '<STR_LIT>' ] <EOL> else : <EOL> sys . stderr . write ( "<STR_LIT>" ) <EOL> exit ( <NUM_LIT:1> ) <EOL> def update_port ( token , public_url , port_id , mac_address , calico_network ) : <EOL> """<STR_LIT>""" <EOL> headers = { '<STR_LIT:Content-Type>' : '<STR_LIT:application/json>' , '<STR_LIT>' : token } <EOL> payload = { <EOL> "<STR_LIT:port>" : { <EOL> "<STR_LIT>" : [ <EOL> { <EOL> "<STR_LIT>" : calico_network , <EOL> "<STR_LIT>" : mac_address <EOL> } <EOL> ] <EOL> } <EOL> } <EOL> auth_url = public_url + "<STR_LIT>" + port_id <EOL> r = requests . put ( auth_url , headers = headers , data = json . dumps ( payload ) ) <EOL> parsed_json = json . loads ( r . text ) <EOL> if r . status_code != <NUM_LIT:200> or '<STR_LIT>' in parsed_json : <EOL> sys . stderr . write ( "<STR_LIT>" % parsed_json [ '<STR_LIT>' ] ) <EOL> exit ( <NUM_LIT:1> ) <EOL> else : <EOL> return r . status_code <EOL> if __name__ == "<STR_LIT:__main__>" : <EOL> if len ( sys . argv ) < <NUM_LIT:3> : <EOL> sys . stderr . write ( "<STR_LIT>" ) <EOL> exit ( <NUM_LIT:1> ) <EOL> calico_network = sys . argv [ <NUM_LIT:1> ] <EOL> vms_mac_addresses = sys . argv [ <NUM_LIT:2> : ] <EOL> catalog = get_catalog ( ) <EOL> token = get_token ( catalog ) <EOL> public_url = neutron_public_url ( catalog ) <EOL> ports = list_ports ( token , public_url ) <EOL> exit_code = <NUM_LIT:0> <EOL> for port in ports : <EOL> port_id = port [ '<STR_LIT:id>' ] <EOL> mac_address = port [ '<STR_LIT>' ] <EOL> if mac_address in vms_mac_addresses and not port [ '<STR_LIT>' ] : <EOL> status_code = update_port ( token , public_url , port_id , mac_address , calico_network ) <EOL> if status_code == <NUM_LIT:200> : <EOL> exit_code = <NUM_LIT:2> <EOL> exit ( exit_code ) </s>

<s> import requests <EOL> import json <EOL> controller_url = "<STR_LIT>" <EOL> get_devices_url = controller_url + '<STR_LIT>' <EOL> get_devices_response = requests . get ( get_devices_url , verify = False ) <EOL> get_devices_json = get_devices_response . json ( ) <EOL> print ( "<STR_LIT>" ) <EOL> print ( json . dumps ( get_devices_json , indent = <NUM_LIT:4> , separators = ( '<STR_LIT:U+002C>' , '<STR_LIT>' ) ) ) </s>

<s> import requests <EOL> import json <EOL> controller_url = "<STR_LIT>" <EOL> payload = { "<STR_LIT:username>" : "<STR_LIT>" , "<STR_LIT:password>" : "<STR_LIT>" } <EOL> ticket_url = controller_url + "<STR_LIT>" <EOL> header = { "<STR_LIT>" : "<STR_LIT:application/json>" } <EOL> response = requests . post ( ticket_url , data = json . dumps ( payload ) , headers = header , verify = False ) <EOL> r_json = response . json ( ) <EOL> ticket = r_json [ "<STR_LIT>" ] [ "<STR_LIT>" ] <EOL> get_devices_url = controller_url + '<STR_LIT>' <EOL> header = { "<STR_LIT>" : "<STR_LIT:application/json>" , "<STR_LIT>" : ticket } <EOL> get_devices_response = requests . get ( get_devices_url , headers = header , verify = False ) <EOL> get_devices_json = get_devices_response . json ( ) <EOL> parent = get_devices_json [ "<STR_LIT>" ] <EOL> print ( "<STR_LIT>" ) <EOL> with open ( "<STR_LIT>" , "<STR_LIT:w>" ) as file : <EOL> for item in parent : <EOL> device = "<STR_LIT>" + item [ "<STR_LIT:id>" ] + "<STR_LIT>" + item [ "<STR_LIT:type>" ] <EOL> file . write ( device + "<STR_LIT:\n>" ) <EOL> print ( device ) </s>

<s> """<STR_LIT>""" <EOL> import os <EOL> import logging <EOL> import lxml . etree as ET <EOL> class Cxml : <EOL> def __init__ ( self , filename ) : <EOL> self . filename = filename <EOL> self . modulename = os . path . splitext ( os . path . basename ( filename ) ) [ <NUM_LIT:0> ] <EOL> if os . path . exists ( filename ) : <EOL> logging . debug ( '<STR_LIT>' % filename ) <EOL> try : <EOL> self . cxml = ET . parse ( filename ) <EOL> except : <EOL> self . cxml = None <EOL> logging . error ( '<STR_LIT>' % filename ) <EOL> else : <EOL> self . cxml = None <EOL> logging . error ( '<STR_LIT>' % filename ) <EOL> def toxpath ( self , path ) : <EOL> path_elems = path . split ( '<STR_LIT:/>' ) <EOL> xpath = '<STR_LIT>' % path_elems [ <NUM_LIT:0> ] <EOL> for elem in path_elems [ <NUM_LIT:1> : ] : <EOL> xpath += '<STR_LIT>' % elem <EOL> return xpath <EOL> def get_lazy_node_internal ( self , cxml_element , base = '<STR_LIT>' ) : <EOL> node = ET . Element ( '<STR_LIT>' ) <EOL> add_placeholder = True <EOL> for attrib in cxml_element . attrib : <EOL> node . set ( attrib , cxml_element . attrib [ attrib ] ) <EOL> if ( attrib == '<STR_LIT:type>' and cxml_element . attrib [ attrib ] in [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] ) : <EOL> add_placeholder = False <EOL> try : <EOL> desc = cxml_element . find ( '<STR_LIT:description>' ) <EOL> if desc is not None : <EOL> node . set ( '<STR_LIT:description>' , desc . text . strip ( ) ) <EOL> except : <EOL> pass <EOL> if base == '<STR_LIT>' : <EOL> node . set ( '<STR_LIT:path>' , self . modulename ) <EOL> else : <EOL> base += '<STR_LIT:/>' <EOL> node . set ( '<STR_LIT:path>' , base + cxml_element . get ( '<STR_LIT:name>' ) ) <EOL> if add_placeholder : <EOL> pnode = ET . Element ( '<STR_LIT>' ) <EOL> pnode . set ( '<STR_LIT:name>' , '<STR_LIT>' ) <EOL> pnode . set ( '<STR_LIT:type>' , '<STR_LIT>' ) <EOL> node . append ( pnode ) <EOL> return node <EOL> def get_lazy_node ( self , path = '<STR_LIT>' , add_ns = True ) : <EOL> """<STR_LIT>""" <EOL> logging . debug ( '<STR_LIT>' + path ) <EOL> root = ET . Element ( '<STR_LIT:root>' ) <EOL> if self . cxml is None : <EOL> return root <EOL> cxml_root = self . cxml . getroot ( ) <EOL> if path == '<STR_LIT>' : <EOL> node = self . get_lazy_node_internal ( cxml_root ) <EOL> nslist = [ c . get ( '<STR_LIT>' ) + '<STR_LIT:U+002C>' + c . text for c in cxml_root if c . tag == '<STR_LIT>' ] <EOL> node . set ( '<STR_LIT>' , '<STR_LIT:|>' . join ( nslist ) ) <EOL> node . set ( '<STR_LIT:name>' , self . modulename ) <EOL> root . append ( node ) <EOL> return root <EOL> elements = path . split ( '<STR_LIT:/>' ) <EOL> for name in elements [ <NUM_LIT:1> : ] : <EOL> for child in cxml_root : <EOL> if child . get ( '<STR_LIT:name>' , '<STR_LIT>' ) == name : <EOL> cxml_root = child <EOL> break <EOL> for child in cxml_root : <EOL> if child . tag == '<STR_LIT>' : <EOL> node = self . get_lazy_node_internal ( child , path ) <EOL> root . append ( node ) <EOL> if child . tag == '<STR_LIT>' and add_ns : <EOL> if cxml_root . get ( '<STR_LIT>' , '<STR_LIT>' ) == child . get ( '<STR_LIT>' ) : <EOL> child . set ( '<STR_LIT:default>' , '<STR_LIT:true>' ) <EOL> root . append ( child ) <EOL> return root <EOL> def get_lazy_tree_one ( self , path , value ) : <EOL> """<STR_LIT>""" <EOL> tree = None <EOL> path_elems = path . split ( '<STR_LIT:/>' ) <EOL> subpath = xpath = '<STR_LIT>' <EOL> for elems in path_elems : <EOL> nodes = self . get_lazy_node ( subpath ) <EOL> if tree is None : <EOL> tree = nodes . find ( '<STR_LIT>' ) <EOL> xpath = '<STR_LIT>' % elems <EOL> logging . info ( ET . tostring ( tree ) ) <EOL> else : <EOL> subpath += '<STR_LIT:/>' <EOL> temp = tree . find ( xpath ) <EOL> if temp is not None : <EOL> tree . find ( xpath ) . remove ( tree . find ( xpath ) [ <NUM_LIT:0> ] ) <EOL> for child in nodes : <EOL> if child . get ( '<STR_LIT:path>' ) == path : <EOL> child . set ( '<STR_LIT:value>' , value ) <EOL> tree . find ( xpath ) . append ( child ) <EOL> xpath += '<STR_LIT>' % elems <EOL> subpath += elems <EOL> return tree <EOL> def get_lazy_tree ( self , pathvalues ) : <EOL> """<STR_LIT>""" <EOL> logging . debug ( '<STR_LIT>' ) <EOL> plist = [ ] <EOL> vdict = { } <EOL> for ( path , value ) in pathvalues : <EOL> plist . append ( path . split ( '<STR_LIT:/>' ) ) <EOL> vdict [ path ] = value <EOL> level = <NUM_LIT:0> <EOL> logging . info ( str ( plist ) ) <EOL> tree = self . get_lazy_node ( ) <EOL> tree = tree [ <NUM_LIT:0> ] <EOL> while True : <EOL> pending = [ ] <EOL> for path_elems in plist : <EOL> if level >= len ( path_elems ) : <EOL> continue <EOL> cxpath = '<STR_LIT:/>' . join ( path_elems [ : level + <NUM_LIT:1> ] ) <EOL> if cxpath not in pending : <EOL> pending . append ( cxpath ) <EOL> if len ( pending ) == <NUM_LIT:0> : <EOL> break <EOL> for cxpath in pending : <EOL> subtree = self . get_lazy_node ( cxpath , False ) <EOL> xpath = self . toxpath ( cxpath ) <EOL> if len ( subtree ) == <NUM_LIT:0> : <EOL> continue <EOL> tree . find ( xpath ) . remove ( tree . find ( xpath ) [ <NUM_LIT:0> ] ) <EOL> for child in subtree : <EOL> cpath = child . get ( '<STR_LIT:path>' , '<STR_LIT>' ) <EOL> values = vdict . get ( cpath , '<STR_LIT>' ) <EOL> if values is not None : <EOL> for key in values : <EOL> child . set ( key , values [ key ] ) <EOL> tree . find ( xpath ) . append ( child ) <EOL> level += <NUM_LIT:1> <EOL> return tree <EOL> def get_namespaces ( self ) : <EOL> if self . cxml is None : <EOL> return [ ] <EOL> return [ ( ns . get ( '<STR_LIT>' , '<STR_LIT>' ) , ns . get ( '<STR_LIT>' , '<STR_LIT>' ) , ns . text ) <EOL> for ns in self . cxml . getroot ( ) if ns . tag == '<STR_LIT>' ] </s>

<s> """<STR_LIT>""" <EOL> from horizon import conf <EOL> def horizon ( request ) : <EOL> """<STR_LIT>""" <EOL> context = { "<STR_LIT>" : conf . HORIZON_CONFIG , <EOL> "<STR_LIT:True>" : True , <EOL> "<STR_LIT:False>" : False } <EOL> return context </s>

<s> from django . template import base <EOL> from django . template import defaultfilters <EOL> from django . utils import safestring <EOL> register = base . Library ( ) <EOL> @ register . filter ( is_safe = True ) <EOL> @ defaultfilters . stringfilter <EOL> def shellfilter ( value ) : <EOL> """<STR_LIT>""" <EOL> replacements = { '<STR_LIT:\\>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> "<STR_LIT:'>" : "<STR_LIT>" , <EOL> '<STR_LIT:">' : '<STR_LIT>' } <EOL> for search , repl in replacements . items ( ) : <EOL> value = value . replace ( search , repl ) <EOL> return safestring . mark_safe ( value ) </s>

<s> import time <EOL> from django . conf import settings <EOL> from django . http import HttpResponseRedirect <EOL> from horizon import exceptions <EOL> from horizon import middleware <EOL> from horizon . test import helpers as test <EOL> class MiddlewareTests ( test . TestCase ) : <EOL> def test_redirect_login_fail_to_login ( self ) : <EOL> url = settings . LOGIN_URL <EOL> request = self . factory . post ( url ) <EOL> mw = middleware . HorizonMiddleware ( ) <EOL> resp = mw . process_exception ( request , exceptions . NotAuthorized ( ) ) <EOL> resp . client = self . client <EOL> self . assertRedirects ( resp , url ) <EOL> def test_session_timeout ( self ) : <EOL> requested_url = '<STR_LIT>' <EOL> request = self . factory . get ( requested_url ) <EOL> try : <EOL> timeout = settings . SESSION_TIMEOUT <EOL> except AttributeError : <EOL> timeout = <NUM_LIT> <EOL> request . session [ '<STR_LIT>' ] = int ( time . time ( ) ) - ( timeout + <NUM_LIT:10> ) <EOL> mw = middleware . HorizonMiddleware ( ) <EOL> resp = mw . process_request ( request ) <EOL> self . assertEqual ( <NUM_LIT> , resp . status_code ) <EOL> self . assertEqual ( requested_url , resp . get ( '<STR_LIT>' ) ) <EOL> def test_process_response_redirect_on_ajax_request ( self ) : <EOL> url = settings . LOGIN_URL <EOL> mw = middleware . HorizonMiddleware ( ) <EOL> request = self . factory . post ( url , <EOL> HTTP_X_REQUESTED_WITH = '<STR_LIT>' ) <EOL> request . META [ '<STR_LIT>' ] = '<STR_LIT>' <EOL> request . horizon = { '<STR_LIT>' : <EOL> [ ( '<STR_LIT:error>' , '<STR_LIT>' , '<STR_LIT>' ) ] } <EOL> response = HttpResponseRedirect ( url ) <EOL> response . client = self . client <EOL> resp = mw . process_response ( request , response ) <EOL> self . assertEqual ( <NUM_LIT:200> , resp . status_code ) <EOL> self . assertEqual ( url , resp [ '<STR_LIT>' ] ) </s>

<s> from __future__ import absolute_import <EOL> import logging <EOL> from django . conf import settings <EOL> from django . utils . translation import pgettext_lazy <EOL> from django . utils . translation import ugettext_lazy as _ <EOL> from cinderclient . v2 . contrib import list_extensions as cinder_list_extensions <EOL> from horizon import exceptions <EOL> from horizon . utils . memoized import memoized <EOL> from openstack_dashboard . api import base <EOL> from openstack_dashboard . api import nova <EOL> LOG = logging . getLogger ( __name__ ) <EOL> VOLUME_STATE_AVAILABLE = "<STR_LIT>" <EOL> DEFAULT_QUOTA_NAME = '<STR_LIT:default>' <EOL> CONSUMER_CHOICES = ( <EOL> ( '<STR_LIT>' , _ ( '<STR_LIT>' ) ) , <EOL> ( '<STR_LIT>' , _ ( '<STR_LIT>' ) ) , <EOL> ( '<STR_LIT>' , pgettext_lazy ( '<STR_LIT>' , u'<STR_LIT>' ) ) , <EOL> ) <EOL> VERSIONS = base . APIVersionManager ( "<STR_LIT>" , preferred_version = <NUM_LIT:2> ) <EOL> try : <EOL> from cinderclient . v2 import client as cinder_client_v2 <EOL> VERSIONS . load_supported_version ( <NUM_LIT:2> , { "<STR_LIT>" : cinder_client_v2 , <EOL> "<STR_LIT:version>" : <NUM_LIT:2> } ) <EOL> except ImportError : <EOL> pass <EOL> class BaseCinderAPIResourceWrapper ( base . APIResourceWrapper ) : <EOL> @ property <EOL> def name ( self ) : <EOL> return ( getattr ( self . _apiresource , '<STR_LIT:name>' , None ) or <EOL> getattr ( self . _apiresource , '<STR_LIT>' , None ) or <EOL> getattr ( self . _apiresource , '<STR_LIT:id>' , None ) ) <EOL> @ property <EOL> def description ( self ) : <EOL> return ( getattr ( self . _apiresource , '<STR_LIT:description>' , None ) or <EOL> getattr ( self . _apiresource , '<STR_LIT>' , None ) ) <EOL> class Volume ( BaseCinderAPIResourceWrapper ) : <EOL> _attrs = [ '<STR_LIT:id>' , '<STR_LIT:name>' , '<STR_LIT:description>' , '<STR_LIT:size>' , '<STR_LIT:status>' , '<STR_LIT>' , <EOL> '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , <EOL> '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , <EOL> '<STR_LIT>' , '<STR_LIT>' , <EOL> '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] <EOL> @ property <EOL> def is_bootable ( self ) : <EOL> return self . bootable == '<STR_LIT:true>' <EOL> class VolumeSnapshot ( BaseCinderAPIResourceWrapper ) : <EOL> _attrs = [ '<STR_LIT:id>' , '<STR_LIT:name>' , '<STR_LIT:description>' , '<STR_LIT:size>' , '<STR_LIT:status>' , <EOL> '<STR_LIT>' , '<STR_LIT>' , <EOL> '<STR_LIT>' ] <EOL> class VolumeType ( BaseCinderAPIResourceWrapper ) : <EOL> _attrs = [ '<STR_LIT:id>' , '<STR_LIT:name>' , '<STR_LIT>' , '<STR_LIT>' , <EOL> '<STR_LIT>' ] <EOL> class VolumeBackup ( BaseCinderAPIResourceWrapper ) : <EOL> _attrs = [ '<STR_LIT:id>' , '<STR_LIT:name>' , '<STR_LIT:description>' , '<STR_LIT>' , '<STR_LIT:size>' , '<STR_LIT:status>' , <EOL> '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] <EOL> _volume = None <EOL> @ property <EOL> def volume ( self ) : <EOL> return self . _volume <EOL> @ volume . setter <EOL> def volume ( self , value ) : <EOL> self . _volume = value <EOL> class VolTypeExtraSpec ( object ) : <EOL> def __init__ ( self , type_id , key , val ) : <EOL> self . type_id = type_id <EOL> self . id = key <EOL> self . key = key <EOL> self . value = val <EOL> class QosSpec ( object ) : <EOL> def __init__ ( self , id , key , val ) : <EOL> self . id = id <EOL> self . key = key <EOL> self . value = val <EOL> @ memoized <EOL> def cinderclient ( request ) : <EOL> api_version = VERSIONS . get_active_version ( ) <EOL> insecure = getattr ( settings , '<STR_LIT>' , False ) <EOL> cacert = getattr ( settings , '<STR_LIT>' , None ) <EOL> cinder_url = "<STR_LIT>" <EOL> try : <EOL> if api_version [ '<STR_LIT:version>' ] == <NUM_LIT:2> : <EOL> try : <EOL> cinder_url = base . url_for ( request , '<STR_LIT>' ) <EOL> except exceptions . ServiceCatalogException : <EOL> LOG . warning ( "<STR_LIT>" <EOL> "<STR_LIT>" ) <EOL> except exceptions . ServiceCatalogException : <EOL> LOG . debug ( '<STR_LIT>' ) <EOL> raise <EOL> c = api_version [ '<STR_LIT>' ] . Client ( request . user . username , <EOL> request . user . token . id , <EOL> project_id = request . user . tenant_id , <EOL> auth_url = cinder_url , <EOL> insecure = insecure , <EOL> cacert = cacert , <EOL> http_log_debug = settings . DEBUG ) <EOL> c . client . auth_token = request . user . token . id <EOL> c . client . management_url = cinder_url <EOL> return c <EOL> def _replace_v2_parameters ( data ) : <EOL> if VERSIONS . active < <NUM_LIT:2> : <EOL> data [ '<STR_LIT>' ] = data [ '<STR_LIT:name>' ] <EOL> data [ '<STR_LIT>' ] = data [ '<STR_LIT:description>' ] <EOL> del data [ '<STR_LIT:name>' ] <EOL> del data [ '<STR_LIT:description>' ] <EOL> return data <EOL> def version_get ( ) : <EOL> api_version = VERSIONS . get_active_version ( ) <EOL> return api_version [ '<STR_LIT:version>' ] <EOL> def volume_list ( request , search_opts = None ) : <EOL> """<STR_LIT>""" <EOL> c_client = cinderclient ( request ) <EOL> if c_client is None : <EOL> return [ ] <EOL> return [ Volume ( v ) for v in c_client . volumes . list ( search_opts = search_opts ) ] <EOL> def volume_get ( request , volume_id ) : <EOL> volume_data = cinderclient ( request ) . volumes . get ( volume_id ) <EOL> for attachment in volume_data . attachments : <EOL> if "<STR_LIT>" in attachment : <EOL> instance = nova . server_get ( request , attachment [ '<STR_LIT>' ] ) <EOL> attachment [ '<STR_LIT>' ] = instance . name <EOL> else : <EOL> attachment [ '<STR_LIT>' ] = _ ( "<STR_LIT>" ) <EOL> return Volume ( volume_data ) <EOL> def volume_create ( request , size , name , description , volume_type , <EOL> snapshot_id = None , metadata = None , image_id = None , <EOL> availability_zone = None , source_volid = None ) : <EOL> data = { '<STR_LIT:name>' : name , <EOL> '<STR_LIT:description>' : description , <EOL> '<STR_LIT>' : volume_type , <EOL> '<STR_LIT>' : snapshot_id , <EOL> '<STR_LIT>' : metadata , <EOL> '<STR_LIT>' : image_id , <EOL> '<STR_LIT>' : availability_zone , <EOL> '<STR_LIT>' : source_volid } <EOL> data = _replace_v2_parameters ( data ) <EOL> volume = cinderclient ( request ) . volumes . create ( size , ** data ) <EOL> return Volume ( volume ) <EOL> def volume_extend ( request , volume_id , new_size ) : <EOL> return cinderclient ( request ) . volumes . extend ( volume_id , new_size ) <EOL> def volume_delete ( request , volume_id ) : <EOL> return cinderclient ( request ) . volumes . delete ( volume_id ) <EOL> def volume_retype ( request , volume_id , new_type , migration_policy ) : <EOL> return cinderclient ( request ) . volumes . retype ( volume_id , <EOL> new_type , <EOL> migration_policy ) <EOL> def volume_update ( request , volume_id , name , description ) : <EOL> vol_data = { '<STR_LIT:name>' : name , <EOL> '<STR_LIT:description>' : description } <EOL> vol_data = _replace_v2_parameters ( vol_data ) <EOL> return cinderclient ( request ) . volumes . update ( volume_id , <EOL> ** vol_data ) <EOL> def volume_reset_state ( request , volume_id , state ) : <EOL> return cinderclient ( request ) . volumes . reset_state ( volume_id , state ) <EOL> def volume_upload_to_image ( request , volume_id , force , image_name , <EOL> container_format , disk_format ) : <EOL> return cinderclient ( request ) . volumes . upload_to_image ( volume_id , <EOL> force , <EOL> image_name , <EOL> container_format , <EOL> disk_format ) <EOL> def volume_snapshot_get ( request , snapshot_id ) : <EOL> snapshot = cinderclient ( request ) . volume_snapshots . get ( snapshot_id ) <EOL> return VolumeSnapshot ( snapshot ) <EOL> def volume_snapshot_list ( request , search_opts = None ) : <EOL> c_client = cinderclient ( request ) <EOL> if c_client is None : <EOL> return [ ] <EOL> return [ VolumeSnapshot ( s ) for s in c_client . volume_snapshots . list ( <EOL> search_opts = search_opts ) ] <EOL> def volume_snapshot_create ( request , volume_id , name , <EOL> description = None , force = False ) : <EOL> data = { '<STR_LIT:name>' : name , <EOL> '<STR_LIT:description>' : description , <EOL> '<STR_LIT>' : force } <EOL> data = _replace_v2_parameters ( data ) <EOL> return VolumeSnapshot ( cinderclient ( request ) . volume_snapshots . create ( <EOL> volume_id , ** data ) ) <EOL> def volume_snapshot_delete ( request , snapshot_id ) : <EOL> return cinderclient ( request ) . volume_snapshots . delete ( snapshot_id ) <EOL> def volume_snapshot_update ( request , snapshot_id , name , description ) : <EOL> snapshot_data = { '<STR_LIT:name>' : name , <EOL> '<STR_LIT:description>' : description } <EOL> snapshot_data = _replace_v2_parameters ( snapshot_data ) <EOL> return cinderclient ( request ) . volume_snapshots . update ( snapshot_id , <EOL> ** snapshot_data ) <EOL> def volume_snapshot_reset_state ( request , snapshot_id , state ) : <EOL> return cinderclient ( request ) . volume_snapshots . reset_state ( <EOL> snapshot_id , state ) <EOL> @ memoized <EOL> def volume_backup_supported ( request ) : <EOL> """<STR_LIT>""" <EOL> cinder_config = getattr ( settings , '<STR_LIT>' , { } ) <EOL> return cinder_config . get ( '<STR_LIT>' , False ) <EOL> def volume_backup_get ( request , backup_id ) : <EOL> backup = cinderclient ( request ) . backups . get ( backup_id ) <EOL> return VolumeBackup ( backup ) <EOL> def volume_backup_list ( request ) : <EOL> c_client = cinderclient ( request ) <EOL> if c_client is None : <EOL> return [ ] <EOL> return [ VolumeBackup ( b ) for b in c_client . backups . list ( ) ] <EOL> def volume_backup_create ( request , <EOL> volume_id , <EOL> container_name , <EOL> name , <EOL> description ) : <EOL> backup = cinderclient ( request ) . backups . create ( <EOL> volume_id , <EOL> container = container_name , <EOL> name = name , <EOL> description = description ) <EOL> return VolumeBackup ( backup ) <EOL> def volume_backup_delete ( request , backup_id ) : <EOL> return cinderclient ( request ) . backups . delete ( backup_id ) <EOL> def volume_backup_restore ( request , backup_id , volume_id ) : <EOL> return cinderclient ( request ) . restores . restore ( backup_id = backup_id , <EOL> volume_id = volume_id ) <EOL> def tenant_quota_get ( request , tenant_id ) : <EOL> c_client = cinderclient ( request ) <EOL> if c_client is None : <EOL> return base . QuotaSet ( ) <EOL> return base . QuotaSet ( c_client . quotas . get ( tenant_id ) ) <EOL> def tenant_quota_update ( request , tenant_id , ** kwargs ) : <EOL> return cinderclient ( request ) . quotas . update ( tenant_id , ** kwargs ) <EOL> def default_quota_get ( request , tenant_id ) : <EOL> return base . QuotaSet ( cinderclient ( request ) . quotas . defaults ( tenant_id ) ) <EOL> def volume_type_list_with_qos_associations ( request ) : <EOL> vol_types = volume_type_list ( request ) <EOL> vol_types_dict = { } <EOL> for vol_type in vol_types : <EOL> vol_type . associated_qos_spec = "<STR_LIT>" <EOL> vol_types_dict [ vol_type . id ] = vol_type <EOL> qos_specs = qos_spec_list ( request ) <EOL> for qos_spec in qos_specs : <EOL> assoc_vol_types = qos_spec_get_associations ( request , qos_spec . id ) <EOL> for assoc_vol_type in assoc_vol_types : <EOL> vol_type = vol_types_dict [ assoc_vol_type . id ] <EOL> vol_type . associated_qos_spec = qos_spec . name <EOL> return vol_types <EOL> def default_quota_update ( request , ** kwargs ) : <EOL> cinderclient ( request ) . quota_classes . update ( DEFAULT_QUOTA_NAME , ** kwargs ) <EOL> def volume_type_list ( request ) : <EOL> return cinderclient ( request ) . volume_types . list ( ) <EOL> def volume_type_create ( request , name ) : <EOL> return cinderclient ( request ) . volume_types . create ( name ) <EOL> def volume_type_delete ( request , volume_type_id ) : <EOL> return cinderclient ( request ) . volume_types . delete ( volume_type_id ) <EOL> def volume_type_get ( request , volume_type_id ) : <EOL> return cinderclient ( request ) . volume_types . get ( volume_type_id ) <EOL> def volume_encryption_type_create ( request , volume_type_id , data ) : <EOL> return cinderclient ( request ) . volume_encryption_types . create ( volume_type_id , <EOL> specs = data ) <EOL> def volume_encryption_type_delete ( request , volume_type_id ) : <EOL> return cinderclient ( request ) . volume_encryption_types . delete ( volume_type_id ) <EOL> def volume_encryption_type_get ( request , volume_type_id ) : <EOL> return cinderclient ( request ) . volume_encryption_types . get ( volume_type_id ) <EOL> def volume_encryption_type_list ( request ) : <EOL> return cinderclient ( request ) . volume_encryption_types . list ( ) <EOL> def volume_type_extra_get ( request , type_id , raw = False ) : <EOL> vol_type = volume_type_get ( request , type_id ) <EOL> extras = vol_type . get_keys ( ) <EOL> if raw : <EOL> return extras <EOL> return [ VolTypeExtraSpec ( type_id , key , value ) for <EOL> key , value in extras . items ( ) ] <EOL> def volume_type_extra_set ( request , type_id , metadata ) : <EOL> vol_type = volume_type_get ( request , type_id ) <EOL> if not metadata : <EOL> return None <EOL> return vol_type . set_keys ( metadata ) <EOL> def volume_type_extra_delete ( request , type_id , keys ) : <EOL> vol_type = volume_type_get ( request , type_id ) <EOL> return vol_type . unset_keys ( [ keys ] ) <EOL> def qos_spec_list ( request ) : <EOL> return cinderclient ( request ) . qos_specs . list ( ) <EOL> def qos_spec_get ( request , qos_spec_id ) : <EOL> return cinderclient ( request ) . qos_specs . get ( qos_spec_id ) <EOL> def qos_spec_delete ( request , qos_spec_id ) : <EOL> return cinderclient ( request ) . qos_specs . delete ( qos_spec_id , force = True ) <EOL> def qos_spec_create ( request , name , specs ) : <EOL> return cinderclient ( request ) . qos_specs . create ( name , specs ) <EOL> def qos_spec_get_keys ( request , qos_spec_id , raw = False ) : <EOL> spec = qos_spec_get ( request , qos_spec_id ) <EOL> qos_specs = spec . specs <EOL> if raw : <EOL> return spec <EOL> return [ QosSpec ( qos_spec_id , key , value ) for <EOL> key , value in qos_specs . items ( ) ] <EOL> def qos_spec_set_keys ( request , qos_spec_id , specs ) : <EOL> return cinderclient ( request ) . qos_specs . set_keys ( qos_spec_id , specs ) <EOL> def qos_spec_unset_keys ( request , qos_spec_id , specs ) : <EOL> return cinderclient ( request ) . qos_specs . unset_keys ( qos_spec_id , specs ) <EOL> def qos_spec_associate ( request , qos_specs , vol_type_id ) : <EOL> return cinderclient ( request ) . qos_specs . associate ( qos_specs , vol_type_id ) <EOL> def qos_spec_disassociate ( request , qos_specs , vol_type_id ) : <EOL> return cinderclient ( request ) . qos_specs . disassociate ( qos_specs , vol_type_id ) <EOL> def qos_spec_get_associations ( request , qos_spec_id ) : <EOL> return cinderclient ( request ) . qos_specs . get_associations ( qos_spec_id ) <EOL> @ memoized <EOL> def tenant_absolute_limits ( request ) : <EOL> limits = cinderclient ( request ) . limits . get ( ) . absolute <EOL> limits_dict = { } <EOL> for limit in limits : <EOL> if limit . value < <NUM_LIT:0> : <EOL> if limit . name . startswith ( '<STR_LIT>' ) and limit . name . endswith ( '<STR_LIT>' ) : <EOL> limits_dict [ limit . name ] = <NUM_LIT:0> <EOL> else : <EOL> limits_dict [ limit . name ] = float ( "<STR_LIT>" ) <EOL> else : <EOL> limits_dict [ limit . name ] = limit . value <EOL> return limits_dict <EOL> def service_list ( request ) : <EOL> return cinderclient ( request ) . services . list ( ) <EOL> def availability_zone_list ( request , detailed = False ) : <EOL> return cinderclient ( request ) . availability_zones . list ( detailed = detailed ) <EOL> @ memoized <EOL> def list_extensions ( request ) : <EOL> return cinder_list_extensions . ListExtManager ( cinderclient ( request ) ) . show_all ( ) <EOL> @ memoized <EOL> def extension_supported ( request , extension_name ) : <EOL> """<STR_LIT>""" <EOL> extensions = list_extensions ( request ) <EOL> for extension in extensions : <EOL> if extension . name == extension_name : <EOL> return True <EOL> return False </s>

<s> from django . utils . translation import ugettext_lazy as _ <EOL> import horizon <EOL> class SystemPanels ( horizon . PanelGroup ) : <EOL> slug = "<STR_LIT>" <EOL> name = _ ( "<STR_LIT>" ) <EOL> panels = ( '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , <EOL> '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , <EOL> '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT:info>' , '<STR_LIT>' ) <EOL> class Admin ( horizon . Dashboard ) : <EOL> name = _ ( "<STR_LIT>" ) <EOL> slug = "<STR_LIT>" <EOL> panels = ( SystemPanels , ) <EOL> default_panel = '<STR_LIT>' <EOL> permissions = ( '<STR_LIT>' , ) <EOL> horizon . register ( Admin ) </s>

<s> import json <EOL> from django . utils . translation import ugettext_lazy as _ <EOL> from horizon import exceptions <EOL> from horizon import forms <EOL> from horizon import messages <EOL> from openstack_dashboard import api <EOL> from openstack_dashboard . dashboards . project . images . images import forms as images_forms <EOL> class AdminCreateImageForm ( images_forms . CreateImageForm ) : <EOL> pass <EOL> class AdminUpdateImageForm ( images_forms . UpdateImageForm ) : <EOL> pass <EOL> class UpdateMetadataForm ( forms . SelfHandlingForm ) : <EOL> def handle ( self , request , data ) : <EOL> id = self . initial [ '<STR_LIT:id>' ] <EOL> old_metadata = self . initial [ '<STR_LIT>' ] <EOL> try : <EOL> new_metadata = json . loads ( self . data [ '<STR_LIT>' ] ) <EOL> metadata = dict ( <EOL> ( item [ '<STR_LIT:key>' ] , str ( item [ '<STR_LIT:value>' ] ) ) <EOL> for item in new_metadata <EOL> ) <EOL> remove_props = [ key for key in old_metadata if key not in metadata ] <EOL> api . glance . image_update_properties ( request , <EOL> id , <EOL> remove_props , <EOL> ** metadata ) <EOL> message = _ ( '<STR_LIT>' ) <EOL> messages . success ( request , message ) <EOL> except Exception : <EOL> exceptions . handle ( request , <EOL> _ ( '<STR_LIT>' ) ) <EOL> return False <EOL> return True </s>

<s> import datetime <EOL> from django . forms import ValidationError <EOL> from django . utils . translation import ugettext_lazy as _ <EOL> from horizon import forms <EOL> class UsageReportForm ( forms . SelfHandlingForm ) : <EOL> PERIOD_CHOICES = ( ( "<STR_LIT:1>" , _ ( "<STR_LIT>" ) ) , <EOL> ( "<STR_LIT>" , _ ( "<STR_LIT>" ) ) , <EOL> ( str ( datetime . date . today ( ) . day ) , _ ( "<STR_LIT>" ) ) , <EOL> ( "<STR_LIT>" , _ ( "<STR_LIT>" ) ) , <EOL> ( "<STR_LIT>" , _ ( "<STR_LIT>" ) ) , <EOL> ( "<STR_LIT>" , _ ( "<STR_LIT>" ) ) , <EOL> ( "<STR_LIT>" , _ ( "<STR_LIT>" ) ) , <EOL> ) <EOL> period = forms . ChoiceField ( label = _ ( "<STR_LIT>" ) , <EOL> required = True , <EOL> choices = PERIOD_CHOICES ) <EOL> date_from = forms . DateField ( label = _ ( "<STR_LIT>" ) , required = False , <EOL> widget = forms . TextInput ( <EOL> attrs = { '<STR_LIT>' : <EOL> '<STR_LIT>' } ) ) <EOL> date_to = forms . DateField ( label = _ ( "<STR_LIT>" ) , required = False , <EOL> widget = forms . TextInput ( <EOL> attrs = { '<STR_LIT>' : <EOL> '<STR_LIT>' } ) ) <EOL> def clean_date_from ( self ) : <EOL> period = self . cleaned_data [ '<STR_LIT>' ] <EOL> date_from = self . cleaned_data [ '<STR_LIT>' ] <EOL> if period == '<STR_LIT>' and date_from is None : <EOL> raise ValidationError ( _ ( '<STR_LIT>' ) ) <EOL> return date_from <EOL> def clean_date_to ( self ) : <EOL> data = super ( UsageReportForm , self ) . clean ( ) <EOL> date_from = data . get ( '<STR_LIT>' ) <EOL> date_to = data . get ( '<STR_LIT>' ) <EOL> period = data . get ( '<STR_LIT>' ) <EOL> if ( period == '<STR_LIT>' and date_to is not None <EOL> and date_from is not None and date_to < date_from ) : <EOL> raise ValidationError ( _ ( "<STR_LIT>" <EOL> "<STR_LIT>" ) ) <EOL> else : <EOL> return date_to <EOL> def handle ( self , request , data ) : <EOL> if hasattr ( request , '<STR_LIT>' ) : <EOL> request . session [ '<STR_LIT>' ] = data [ '<STR_LIT>' ] <EOL> request . session [ '<STR_LIT>' ] = data [ '<STR_LIT>' ] <EOL> request . session [ '<STR_LIT>' ] = data [ '<STR_LIT>' ] <EOL> return data </s>

<s> from django . conf import settings <EOL> from django . template . defaultfilters import floatformat <EOL> from django . utils import translation <EOL> from django . utils . translation import ugettext_lazy as _ <EOL> from horizon import exceptions <EOL> from horizon . utils import csvbase <EOL> from openstack_dashboard import api <EOL> from openstack_dashboard import usage <EOL> class GlobalUsageCsvRenderer ( csvbase . BaseCsvResponse ) : <EOL> columns = [ _ ( "<STR_LIT>" ) , _ ( "<STR_LIT>" ) , _ ( "<STR_LIT>" ) , <EOL> _ ( "<STR_LIT>" ) , _ ( "<STR_LIT>" ) ] <EOL> def get_row_data ( self ) : <EOL> for u in self . context [ '<STR_LIT>' ] . usage_list : <EOL> yield ( u . project_name or u . tenant_id , <EOL> u . vcpus , <EOL> u . memory_mb , <EOL> u . local_gb , <EOL> floatformat ( u . vcpu_hours , <NUM_LIT:2> ) ) <EOL> class GlobalOverview ( usage . UsageView ) : <EOL> table_class = usage . GlobalUsageTable <EOL> usage_class = usage . GlobalUsage <EOL> template_name = '<STR_LIT>' <EOL> csv_response_class = GlobalUsageCsvRenderer <EOL> def get_context_data ( self , ** kwargs ) : <EOL> context = super ( GlobalOverview , self ) . get_context_data ( ** kwargs ) <EOL> context [ '<STR_LIT>' ] = getattr ( settings , '<STR_LIT>' , [ ] ) <EOL> return context <EOL> def get_data ( self ) : <EOL> data = super ( GlobalOverview , self ) . get_data ( ) <EOL> try : <EOL> projects , has_more = api . keystone . tenant_list ( self . request ) <EOL> except Exception : <EOL> projects = [ ] <EOL> exceptions . handle ( self . request , <EOL> _ ( '<STR_LIT>' ) ) <EOL> for instance in data : <EOL> project = filter ( lambda t : t . id == instance . tenant_id , projects ) <EOL> if project : <EOL> instance . project_name = getattr ( project [ <NUM_LIT:0> ] , "<STR_LIT:name>" , None ) <EOL> else : <EOL> deleted = _ ( "<STR_LIT>" ) <EOL> instance . project_name = translation . string_concat ( <EOL> instance . tenant_id , "<STR_LIT>" , deleted , "<STR_LIT:)>" ) <EOL> return data </s>

<s> from django . core . urlresolvers import reverse <EOL> from django import http <EOL> from mox import IsA <EOL> from openstack_dashboard import api <EOL> from openstack_dashboard . test import helpers as test <EOL> class VolTypeExtrasTests ( test . BaseAdminViewTests ) : <EOL> @ test . create_stubs ( { api . cinder : ( '<STR_LIT>' , <EOL> '<STR_LIT>' ) , } ) <EOL> def test_list_extras_when_none_exists ( self ) : <EOL> vol_type = self . cinder_volume_types . first ( ) <EOL> extras = [ api . cinder . VolTypeExtraSpec ( vol_type . id , '<STR_LIT>' , '<STR_LIT>' ) ] <EOL> api . cinder . volume_type_get ( IsA ( http . HttpRequest ) , <EOL> vol_type . id ) . AndReturn ( vol_type ) <EOL> api . cinder . volume_type_extra_get ( IsA ( http . HttpRequest ) , <EOL> vol_type . id ) . AndReturn ( extras ) <EOL> self . mox . ReplayAll ( ) <EOL> url = reverse ( '<STR_LIT>' , <EOL> args = [ vol_type . id ] ) <EOL> resp = self . client . get ( url ) <EOL> self . assertEqual ( resp . status_code , <NUM_LIT:200> ) <EOL> self . assertTemplateUsed ( resp , <EOL> "<STR_LIT>" ) <EOL> @ test . create_stubs ( { api . cinder : ( '<STR_LIT>' , <EOL> '<STR_LIT>' ) , } ) <EOL> def test_extras_view_with_exception ( self ) : <EOL> vol_type = self . cinder_volume_types . first ( ) <EOL> api . cinder . volume_type_get ( IsA ( http . HttpRequest ) , <EOL> vol_type . id ) . AndReturn ( vol_type ) <EOL> api . cinder . volume_type_extra_get ( IsA ( http . HttpRequest ) , <EOL> vol_type . id ) . AndRaise ( self . exceptions . cinder ) <EOL> self . mox . ReplayAll ( ) <EOL> url = reverse ( '<STR_LIT>' , <EOL> args = [ vol_type . id ] ) <EOL> resp = self . client . get ( url ) <EOL> self . assertEqual ( len ( resp . context [ '<STR_LIT>' ] . data ) , <NUM_LIT:0> ) <EOL> self . assertMessageCount ( resp , error = <NUM_LIT:1> ) <EOL> @ test . create_stubs ( { api . cinder : ( '<STR_LIT>' , ) , } ) <EOL> def test_extra_create_post ( self ) : <EOL> vol_type = self . cinder_volume_types . first ( ) <EOL> create_url = reverse ( <EOL> '<STR_LIT>' , <EOL> args = [ vol_type . id ] ) <EOL> index_url = reverse ( <EOL> '<STR_LIT>' , <EOL> args = [ vol_type . id ] ) <EOL> data = { '<STR_LIT:key>' : u'<STR_LIT>' , <EOL> '<STR_LIT:value>' : u'<STR_LIT>' } <EOL> api . cinder . volume_type_extra_set ( IsA ( http . HttpRequest ) , <EOL> vol_type . id , <EOL> { data [ '<STR_LIT:key>' ] : data [ '<STR_LIT:value>' ] } ) <EOL> self . mox . ReplayAll ( ) <EOL> resp = self . client . post ( create_url , data ) <EOL> self . assertNoFormErrors ( resp ) <EOL> self . assertMessageCount ( success = <NUM_LIT:1> ) <EOL> self . assertRedirectsNoFollow ( resp , index_url ) <EOL> @ test . create_stubs ( { api . cinder : ( '<STR_LIT>' , ) , } ) <EOL> def test_extra_create_get ( self ) : <EOL> vol_type = self . cinder_volume_types . first ( ) <EOL> create_url = reverse ( <EOL> '<STR_LIT>' , <EOL> args = [ vol_type . id ] ) <EOL> api . cinder . volume_type_get ( IsA ( http . HttpRequest ) , <EOL> vol_type . id ) . AndReturn ( vol_type ) <EOL> self . mox . ReplayAll ( ) <EOL> resp = self . client . get ( create_url ) <EOL> self . assertEqual ( resp . status_code , <NUM_LIT:200> ) <EOL> self . assertTemplateUsed ( <EOL> resp , '<STR_LIT>' ) <EOL> @ test . create_stubs ( { api . cinder : ( '<STR_LIT>' , <EOL> '<STR_LIT>' , ) , } ) <EOL> def test_extra_edit ( self ) : <EOL> vol_type = self . cinder_volume_types . first ( ) <EOL> key = '<STR_LIT:foo>' <EOL> edit_url = reverse ( '<STR_LIT>' , <EOL> args = [ vol_type . id , key ] ) <EOL> index_url = reverse ( '<STR_LIT>' , <EOL> args = [ vol_type . id ] ) <EOL> data = { '<STR_LIT:value>' : u'<STR_LIT>' } <EOL> extras = { key : data [ '<STR_LIT:value>' ] } <EOL> api . cinder . volume_type_extra_get ( IsA ( http . HttpRequest ) , <EOL> vol_type . id , <EOL> raw = True ) . AndReturn ( extras ) <EOL> api . cinder . volume_type_extra_set ( IsA ( http . HttpRequest ) , <EOL> vol_type . id , <EOL> extras ) <EOL> self . mox . ReplayAll ( ) <EOL> resp = self . client . post ( edit_url , data ) <EOL> self . assertNoFormErrors ( resp ) <EOL> self . assertMessageCount ( success = <NUM_LIT:1> ) <EOL> self . assertRedirectsNoFollow ( resp , index_url ) <EOL> @ test . create_stubs ( { api . cinder : ( '<STR_LIT>' , <EOL> '<STR_LIT>' ) , } ) <EOL> def test_extra_delete ( self ) : <EOL> vol_type = self . cinder_volume_types . first ( ) <EOL> extras = [ api . cinder . VolTypeExtraSpec ( vol_type . id , '<STR_LIT>' , '<STR_LIT>' ) ] <EOL> formData = { '<STR_LIT:action>' : '<STR_LIT>' } <EOL> index_url = reverse ( '<STR_LIT>' , <EOL> args = [ vol_type . id ] ) <EOL> api . cinder . volume_type_extra_get ( IsA ( http . HttpRequest ) , <EOL> vol_type . id ) . AndReturn ( extras ) <EOL> api . cinder . volume_type_extra_delete ( IsA ( http . HttpRequest ) , <EOL> vol_type . id , <EOL> '<STR_LIT>' ) . AndReturn ( vol_type ) <EOL> self . mox . ReplayAll ( ) <EOL> res = self . client . post ( index_url , formData ) <EOL> self . assertNoFormErrors ( res ) <EOL> self . assertRedirectsNoFollow ( res , index_url ) </s>

<s> import logging <EOL> from django . core . urlresolvers import reverse <EOL> from django . template import defaultfilters <EOL> from django . utils . translation import ugettext_lazy as _ <EOL> from django . utils . translation import ungettext_lazy <EOL> from horizon import tables <EOL> from openstack_dashboard import api <EOL> from openstack_dashboard . dashboards . identity . groups import constants <EOL> LOG = logging . getLogger ( __name__ ) <EOL> LOGOUT_URL = '<STR_LIT>' <EOL> STATUS_CHOICES = ( <EOL> ( "<STR_LIT:true>" , True ) , <EOL> ( "<STR_LIT:false>" , False ) <EOL> ) <EOL> class CreateGroupLink ( tables . LinkAction ) : <EOL> name = "<STR_LIT>" <EOL> verbose_name = _ ( "<STR_LIT>" ) <EOL> url = constants . GROUPS_CREATE_URL <EOL> classes = ( "<STR_LIT>" , ) <EOL> icon = "<STR_LIT>" <EOL> policy_rules = ( ( "<STR_LIT>" , "<STR_LIT>" ) , ) <EOL> def allowed ( self , request , group ) : <EOL> return api . keystone . keystone_can_edit_group ( ) <EOL> class EditGroupLink ( tables . LinkAction ) : <EOL> name = "<STR_LIT>" <EOL> verbose_name = _ ( "<STR_LIT>" ) <EOL> url = constants . GROUPS_UPDATE_URL <EOL> classes = ( "<STR_LIT>" , ) <EOL> icon = "<STR_LIT>" <EOL> policy_rules = ( ( "<STR_LIT>" , "<STR_LIT>" ) , ) <EOL> def allowed ( self , request , group ) : <EOL> return api . keystone . keystone_can_edit_group ( ) <EOL> class DeleteGroupsAction ( tables . DeleteAction ) : <EOL> @ staticmethod <EOL> def action_present ( count ) : <EOL> return ungettext_lazy ( <EOL> u"<STR_LIT>" , <EOL> u"<STR_LIT>" , <EOL> count <EOL> ) <EOL> @ staticmethod <EOL> def action_past ( count ) : <EOL> return ungettext_lazy ( <EOL> u"<STR_LIT>" , <EOL> u"<STR_LIT>" , <EOL> count <EOL> ) <EOL> name = "<STR_LIT>" <EOL> policy_rules = ( ( "<STR_LIT>" , "<STR_LIT>" ) , ) <EOL> def allowed ( self , request , datum ) : <EOL> return api . keystone . keystone_can_edit_group ( ) <EOL> def delete ( self , request , obj_id ) : <EOL> LOG . info ( '<STR_LIT>' % obj_id ) <EOL> api . keystone . group_delete ( request , obj_id ) <EOL> class ManageUsersLink ( tables . LinkAction ) : <EOL> name = "<STR_LIT>" <EOL> verbose_name = _ ( "<STR_LIT>" ) <EOL> url = constants . GROUPS_MANAGE_URL <EOL> icon = "<STR_LIT>" <EOL> policy_rules = ( ( "<STR_LIT>" , "<STR_LIT>" ) , <EOL> ( "<STR_LIT>" , "<STR_LIT>" ) , ) <EOL> def allowed ( self , request , datum ) : <EOL> return api . keystone . keystone_can_edit_group ( ) <EOL> class GroupFilterAction ( tables . FilterAction ) : <EOL> def filter ( self , table , groups , filter_string ) : <EOL> """<STR_LIT>""" <EOL> q = filter_string . lower ( ) <EOL> def comp ( group ) : <EOL> if q in group . name . lower ( ) : <EOL> return True <EOL> return False <EOL> return filter ( comp , groups ) <EOL> class GroupsTable ( tables . DataTable ) : <EOL> name = tables . Column ( '<STR_LIT:name>' , verbose_name = _ ( '<STR_LIT:Name>' ) ) <EOL> description = tables . Column ( lambda obj : getattr ( obj , '<STR_LIT:description>' , None ) , <EOL> verbose_name = _ ( '<STR_LIT>' ) ) <EOL> id = tables . Column ( '<STR_LIT:id>' , verbose_name = _ ( '<STR_LIT>' ) ) <EOL> class Meta : <EOL> name = "<STR_LIT>" <EOL> verbose_name = _ ( "<STR_LIT>" ) <EOL> row_actions = ( ManageUsersLink , EditGroupLink , DeleteGroupsAction ) <EOL> table_actions = ( GroupFilterAction , CreateGroupLink , <EOL> DeleteGroupsAction ) <EOL> class UserFilterAction ( tables . FilterAction ) : <EOL> def filter ( self , table , users , filter_string ) : <EOL> """<STR_LIT>""" <EOL> q = filter_string . lower ( ) <EOL> return [ user for user in users <EOL> if q in user . name . lower ( ) <EOL> or q in ( getattr ( user , '<STR_LIT:email>' , None ) or '<STR_LIT>' ) . lower ( ) ] <EOL> class RemoveMembers ( tables . DeleteAction ) : <EOL> @ staticmethod <EOL> def action_present ( count ) : <EOL> return ungettext_lazy ( <EOL> u"<STR_LIT>" , <EOL> u"<STR_LIT>" , <EOL> count <EOL> ) <EOL> @ staticmethod <EOL> def action_past ( count ) : <EOL> return ungettext_lazy ( <EOL> u"<STR_LIT>" , <EOL> u"<STR_LIT>" , <EOL> count <EOL> ) <EOL> name = "<STR_LIT>" <EOL> policy_rules = ( ( "<STR_LIT>" , "<STR_LIT>" ) , ) <EOL> def allowed ( self , request , user = None ) : <EOL> return api . keystone . keystone_can_edit_group ( ) <EOL> def action ( self , request , obj_id ) : <EOL> user_obj = self . table . get_object_by_id ( obj_id ) <EOL> group_id = self . table . kwargs [ '<STR_LIT>' ] <EOL> LOG . info ( '<STR_LIT>' % ( user_obj . id , <EOL> group_id ) ) <EOL> api . keystone . remove_group_user ( request , <EOL> group_id = group_id , <EOL> user_id = user_obj . id ) <EOL> class AddMembersLink ( tables . LinkAction ) : <EOL> name = "<STR_LIT>" <EOL> verbose_name = _ ( "<STR_LIT>" ) <EOL> classes = ( "<STR_LIT>" , ) <EOL> icon = "<STR_LIT>" <EOL> url = constants . GROUPS_ADD_MEMBER_URL <EOL> policy_rules = ( ( "<STR_LIT>" , "<STR_LIT>" ) , <EOL> ( "<STR_LIT>" , "<STR_LIT>" ) , ) <EOL> def allowed ( self , request , user = None ) : <EOL> return api . keystone . keystone_can_edit_group ( ) <EOL> def get_link_url ( self , datum = None ) : <EOL> return reverse ( self . url , kwargs = self . table . kwargs ) <EOL> class UsersTable ( tables . DataTable ) : <EOL> name = tables . Column ( '<STR_LIT:name>' , verbose_name = _ ( '<STR_LIT>' ) ) <EOL> email = tables . Column ( '<STR_LIT:email>' , verbose_name = _ ( '<STR_LIT>' ) , <EOL> filters = [ defaultfilters . escape , <EOL> defaultfilters . urlize ] ) <EOL> id = tables . Column ( '<STR_LIT:id>' , verbose_name = _ ( '<STR_LIT>' ) ) <EOL> enabled = tables . Column ( '<STR_LIT>' , verbose_name = _ ( '<STR_LIT>' ) , <EOL> status = True , <EOL> status_choices = STATUS_CHOICES , <EOL> empty_value = "<STR_LIT:False>" ) <EOL> class GroupMembersTable ( UsersTable ) : <EOL> class Meta : <EOL> name = "<STR_LIT>" <EOL> verbose_name = _ ( "<STR_LIT>" ) <EOL> table_actions = ( UserFilterAction , AddMembersLink , RemoveMembers ) <EOL> class AddMembers ( tables . BatchAction ) : <EOL> @ staticmethod <EOL> def action_present ( count ) : <EOL> return ungettext_lazy ( <EOL> u"<STR_LIT>" , <EOL> u"<STR_LIT>" , <EOL> count <EOL> ) <EOL> @ staticmethod <EOL> def action_past ( count ) : <EOL> return ungettext_lazy ( <EOL> u"<STR_LIT>" , <EOL> u"<STR_LIT>" , <EOL> count <EOL> ) <EOL> name = "<STR_LIT>" <EOL> icon = "<STR_LIT>" <EOL> requires_input = True <EOL> success_url = constants . GROUPS_MANAGE_URL <EOL> policy_rules = ( ( "<STR_LIT>" , "<STR_LIT>" ) , ) <EOL> def allowed ( self , request , user = None ) : <EOL> return api . keystone . keystone_can_edit_group ( ) <EOL> def action ( self , request , obj_id ) : <EOL> user_obj = self . table . get_object_by_id ( obj_id ) <EOL> group_id = self . table . kwargs [ '<STR_LIT>' ] <EOL> LOG . info ( '<STR_LIT>' % ( user_obj . id , <EOL> group_id ) ) <EOL> api . keystone . add_group_user ( request , <EOL> group_id = group_id , <EOL> user_id = user_obj . id ) <EOL> def get_success_url ( self , request = None ) : <EOL> group_id = self . table . kwargs . get ( '<STR_LIT>' , None ) <EOL> return reverse ( self . success_url , args = [ group_id ] ) <EOL> class GroupNonMembersTable ( UsersTable ) : <EOL> class Meta : <EOL> name = "<STR_LIT>" <EOL> verbose_name = _ ( "<STR_LIT>" ) <EOL> table_actions = ( UserFilterAction , AddMembers ) </s>

<s> from django . core . urlresolvers import reverse <EOL> from django import http <EOL> from django . utils . http import urlencode <EOL> from mox import IsA <EOL> from openstack_dashboard import api <EOL> from openstack_dashboard . dashboards . project . access_and_security . floating_ips import tables <EOL> from openstack_dashboard . test import helpers as test <EOL> from openstack_dashboard . usage import quotas <EOL> from horizon . workflows import views <EOL> INDEX_URL = reverse ( '<STR_LIT>' ) <EOL> NAMESPACE = "<STR_LIT>" <EOL> class FloatingIpViewTests ( test . TestCase ) : <EOL> @ test . create_stubs ( { api . network : ( '<STR_LIT>' , <EOL> '<STR_LIT>' , ) } ) <EOL> def test_associate ( self ) : <EOL> api . network . floating_ip_target_list ( IsA ( http . HttpRequest ) ) . AndReturn ( self . servers . list ( ) ) <EOL> api . network . tenant_floating_ip_list ( IsA ( http . HttpRequest ) ) . AndReturn ( self . floating_ips . list ( ) ) <EOL> self . mox . ReplayAll ( ) <EOL> url = reverse ( '<STR_LIT>' % NAMESPACE ) <EOL> res = self . client . get ( url ) <EOL> self . assertTemplateUsed ( res , views . WorkflowView . template_name ) <EOL> workflow = res . context [ '<STR_LIT>' ] <EOL> choices = dict ( workflow . steps [ <NUM_LIT:0> ] . action . fields [ '<STR_LIT>' ] . choices ) <EOL> self . assertTrue ( self . floating_ips . first ( ) not in choices ) <EOL> @ test . create_stubs ( { api . network : ( '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , ) } ) <EOL> def test_associate_with_instance_id ( self ) : <EOL> api . network . floating_ip_target_list ( IsA ( http . HttpRequest ) ) . AndReturn ( self . servers . list ( ) ) <EOL> api . network . floating_ip_target_get_by_instance ( <EOL> IsA ( http . HttpRequest ) , '<STR_LIT>' , self . servers . list ( ) ) . AndReturn ( '<STR_LIT>' ) <EOL> api . network . tenant_floating_ip_list ( IsA ( http . HttpRequest ) ) . AndReturn ( self . floating_ips . list ( ) ) <EOL> self . mox . ReplayAll ( ) <EOL> base_url = reverse ( '<STR_LIT>' % NAMESPACE ) <EOL> params = urlencode ( { '<STR_LIT>' : '<STR_LIT>' } ) <EOL> url = '<STR_LIT:?>' . join ( [ base_url , params ] ) <EOL> res = self . client . get ( url ) <EOL> self . assertTemplateUsed ( res , views . WorkflowView . template_name ) <EOL> workflow = res . context [ '<STR_LIT>' ] <EOL> choices = dict ( workflow . steps [ <NUM_LIT:0> ] . action . fields [ '<STR_LIT>' ] . choices ) <EOL> self . assertTrue ( self . floating_ips . first ( ) not in choices ) <EOL> @ test . create_stubs ( { api . network : ( '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , ) } ) <EOL> def test_associate_post ( self ) : <EOL> floating_ip = self . floating_ips . list ( ) [ <NUM_LIT:1> ] <EOL> server = self . servers . first ( ) <EOL> api . network . tenant_floating_ip_list ( IsA ( http . HttpRequest ) ) . AndReturn ( self . floating_ips . list ( ) ) <EOL> api . network . floating_ip_target_list ( IsA ( http . HttpRequest ) ) . AndReturn ( self . servers . list ( ) ) <EOL> api . network . floating_ip_associate ( IsA ( http . HttpRequest ) , <EOL> floating_ip . id , <EOL> server . id ) <EOL> self . mox . ReplayAll ( ) <EOL> form_data = { '<STR_LIT>' : server . id , <EOL> '<STR_LIT>' : floating_ip . id } <EOL> url = reverse ( '<STR_LIT>' % NAMESPACE ) <EOL> res = self . client . post ( url , form_data ) <EOL> self . assertRedirectsNoFollow ( res , INDEX_URL ) <EOL> @ test . create_stubs ( { api . network : ( '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , ) } ) <EOL> def test_associate_post_with_redirect ( self ) : <EOL> floating_ip = self . floating_ips . list ( ) [ <NUM_LIT:1> ] <EOL> server = self . servers . first ( ) <EOL> api . network . tenant_floating_ip_list ( IsA ( http . HttpRequest ) ) . AndReturn ( self . floating_ips . list ( ) ) <EOL> api . network . floating_ip_target_list ( IsA ( http . HttpRequest ) ) . AndReturn ( self . servers . list ( ) ) <EOL> api . network . floating_ip_associate ( IsA ( http . HttpRequest ) , <EOL> floating_ip . id , <EOL> server . id ) <EOL> self . mox . ReplayAll ( ) <EOL> form_data = { '<STR_LIT>' : server . id , <EOL> '<STR_LIT>' : floating_ip . id } <EOL> url = reverse ( '<STR_LIT>' % NAMESPACE ) <EOL> next = reverse ( "<STR_LIT>" ) <EOL> res = self . client . post ( "<STR_LIT>" % ( url , next ) , form_data ) <EOL> self . assertRedirectsNoFollow ( res , next ) <EOL> @ test . create_stubs ( { api . network : ( '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , ) } ) <EOL> def test_associate_post_with_exception ( self ) : <EOL> floating_ip = self . floating_ips . list ( ) [ <NUM_LIT:1> ] <EOL> server = self . servers . first ( ) <EOL> api . network . tenant_floating_ip_list ( IsA ( http . HttpRequest ) ) . AndReturn ( self . floating_ips . list ( ) ) <EOL> api . network . floating_ip_target_list ( IsA ( http . HttpRequest ) ) . AndReturn ( self . servers . list ( ) ) <EOL> api . network . floating_ip_associate ( IsA ( http . HttpRequest ) , <EOL> floating_ip . id , <EOL> server . id ) . AndRaise ( self . exceptions . nova ) <EOL> self . mox . ReplayAll ( ) <EOL> form_data = { '<STR_LIT>' : server . id , <EOL> '<STR_LIT>' : floating_ip . id } <EOL> url = reverse ( '<STR_LIT>' % NAMESPACE ) <EOL> res = self . client . post ( url , form_data ) <EOL> self . assertRedirectsNoFollow ( res , INDEX_URL ) <EOL> @ test . create_stubs ( { api . nova : ( '<STR_LIT>' , ) , <EOL> api . network : ( '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , ) } ) <EOL> def test_disassociate_post ( self ) : <EOL> floating_ip = self . floating_ips . first ( ) <EOL> api . nova . server_list ( IsA ( http . HttpRequest ) ) . AndReturn ( [ self . servers . list ( ) , False ] ) <EOL> api . network . floating_ip_supported ( IsA ( http . HttpRequest ) ) . AndReturn ( True ) <EOL> api . network . tenant_floating_ip_list ( IsA ( http . HttpRequest ) ) . AndReturn ( self . floating_ips . list ( ) ) <EOL> api . network . floating_ip_disassociate ( IsA ( http . HttpRequest ) , <EOL> floating_ip . id ) <EOL> self . mox . ReplayAll ( ) <EOL> action = "<STR_LIT>" % floating_ip . id <EOL> res = self . client . post ( INDEX_URL , { "<STR_LIT:action>" : action } ) <EOL> self . assertMessageCount ( success = <NUM_LIT:1> ) <EOL> self . assertRedirectsNoFollow ( res , INDEX_URL ) <EOL> @ test . create_stubs ( { api . nova : ( '<STR_LIT>' , ) , <EOL> api . network : ( '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , ) } ) <EOL> def test_disassociate_post_with_exception ( self ) : <EOL> floating_ip = self . floating_ips . first ( ) <EOL> api . nova . server_list ( IsA ( http . HttpRequest ) ) . AndReturn ( [ self . servers . list ( ) , False ] ) <EOL> api . network . floating_ip_supported ( IsA ( http . HttpRequest ) ) . AndReturn ( True ) <EOL> api . network . tenant_floating_ip_list ( IsA ( http . HttpRequest ) ) . AndReturn ( self . floating_ips . list ( ) ) <EOL> api . network . floating_ip_disassociate ( IsA ( http . HttpRequest ) , <EOL> floating_ip . id ) . AndRaise ( self . exceptions . nova ) <EOL> self . mox . ReplayAll ( ) <EOL> action = "<STR_LIT>" % floating_ip . id <EOL> res = self . client . post ( INDEX_URL , { "<STR_LIT:action>" : action } ) <EOL> self . assertRedirectsNoFollow ( res , INDEX_URL ) <EOL> @ test . create_stubs ( { api . network : ( '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , ) , <EOL> api . nova : ( '<STR_LIT>' , <EOL> '<STR_LIT>' , ) , <EOL> quotas : ( '<STR_LIT>' , ) , <EOL> api . base : ( '<STR_LIT>' , ) } ) <EOL> def test_allocate_button_disabled_when_quota_exceeded ( self ) : <EOL> keypairs = self . keypairs . list ( ) <EOL> floating_ips = self . floating_ips . list ( ) <EOL> floating_pools = self . pools . list ( ) <EOL> quota_data = self . quota_usages . first ( ) <EOL> quota_data [ '<STR_LIT>' ] [ '<STR_LIT>' ] = <NUM_LIT:0> <EOL> sec_groups = self . security_groups . list ( ) <EOL> api . network . floating_ip_supported ( <EOL> IsA ( http . HttpRequest ) ) . AndReturn ( True ) <EOL> api . network . tenant_floating_ip_list ( <EOL> IsA ( http . HttpRequest ) ) . AndReturn ( floating_ips ) <EOL> api . network . security_group_list ( <EOL> IsA ( http . HttpRequest ) ) . MultipleTimes ( ) . AndReturn ( sec_groups ) <EOL> api . network . floating_ip_pools_list ( <EOL> IsA ( http . HttpRequest ) ) . AndReturn ( floating_pools ) <EOL> api . nova . keypair_list ( <EOL> IsA ( http . HttpRequest ) ) . AndReturn ( keypairs ) <EOL> api . nova . server_list ( <EOL> IsA ( http . HttpRequest ) ) . AndReturn ( [ self . servers . list ( ) , False ] ) <EOL> quotas . tenant_quota_usages ( <EOL> IsA ( http . HttpRequest ) ) . MultipleTimes ( ) . AndReturn ( quota_data ) <EOL> api . base . is_service_enabled ( <EOL> IsA ( http . HttpRequest ) , <EOL> '<STR_LIT>' ) . MultipleTimes ( ) . AndReturn ( True ) <EOL> api . base . is_service_enabled ( <EOL> IsA ( http . HttpRequest ) , <EOL> '<STR_LIT>' ) . MultipleTimes ( ) . AndReturn ( False ) <EOL> self . mox . ReplayAll ( ) <EOL> res = self . client . get ( INDEX_URL + <EOL> "<STR_LIT>" ) <EOL> allocate_link = tables . AllocateIP ( ) <EOL> url = allocate_link . get_link_url ( ) <EOL> classes = ( list ( allocate_link . get_default_classes ( ) ) <EOL> + list ( allocate_link . classes ) ) <EOL> link_name = "<STR_LIT>" % ( unicode ( allocate_link . verbose_name ) , <EOL> "<STR_LIT>" ) <EOL> expected_string = ( "<STR_LIT>" <EOL> "<STR_LIT>" <EOL> "<STR_LIT>" <EOL> "<STR_LIT>" <EOL> % ( url , link_name , "<STR_LIT:U+0020>" . join ( classes ) , link_name ) ) <EOL> self . assertContains ( res , expected_string , html = True , <EOL> msg_prefix = "<STR_LIT>" ) <EOL> class FloatingIpNeutronViewTests ( FloatingIpViewTests ) : <EOL> def setUp ( self ) : <EOL> super ( FloatingIpViewTests , self ) . setUp ( ) <EOL> self . _floating_ips_orig = self . floating_ips <EOL> self . floating_ips = self . floating_ips_uuid <EOL> def tearDown ( self ) : <EOL> self . floating_ips = self . _floating_ips_orig <EOL> super ( FloatingIpViewTests , self ) . tearDown ( ) <EOL> @ test . create_stubs ( { api . nova : ( '<STR_LIT>' , '<STR_LIT>' , <EOL> '<STR_LIT>' ) , <EOL> api . network : ( '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' ) , <EOL> api . neutron : ( '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' ) , <EOL> api . base : ( '<STR_LIT>' , ) } ) <EOL> @ test . update_settings ( OPENSTACK_NEUTRON_NETWORK = { '<STR_LIT>' : True } ) <EOL> def test_correct_quotas_displayed ( self ) : <EOL> servers = [ s for s in self . servers . list ( ) <EOL> if s . tenant_id == self . request . user . tenant_id ] <EOL> api . base . is_service_enabled ( IsA ( http . HttpRequest ) , '<STR_LIT>' ) . AndReturn ( False ) <EOL> api . base . is_service_enabled ( IsA ( http . HttpRequest ) , '<STR_LIT>' ) . MultipleTimes ( ) . AndReturn ( True ) <EOL> api . nova . tenant_quota_get ( IsA ( http . HttpRequest ) , '<STR_LIT:1>' ) . AndReturn ( self . quotas . first ( ) ) <EOL> api . nova . flavor_list ( IsA ( http . HttpRequest ) ) . AndReturn ( self . flavors . list ( ) ) <EOL> search_opts = { '<STR_LIT>' : self . request . user . tenant_id } <EOL> api . nova . server_list ( IsA ( http . HttpRequest ) , search_opts = search_opts , <EOL> all_tenants = True ) . AndReturn ( [ servers , False ] ) <EOL> api . neutron . is_extension_supported ( <EOL> IsA ( http . HttpRequest ) , '<STR_LIT>' ) . AndReturn ( True ) <EOL> api . neutron . is_extension_supported ( IsA ( http . HttpRequest ) , '<STR_LIT>' ) . AndReturn ( True ) <EOL> api . neutron . tenant_quota_get ( IsA ( http . HttpRequest ) , self . tenant . id ) . AndReturn ( self . neutron_quotas . first ( ) ) <EOL> api . neutron . router_list ( IsA ( http . HttpRequest ) ) . AndReturn ( self . routers . list ( ) ) <EOL> api . neutron . subnet_list ( IsA ( http . HttpRequest ) ) . AndReturn ( self . subnets . list ( ) ) <EOL> api . neutron . network_list ( IsA ( http . HttpRequest ) , shared = False ) . AndReturn ( self . networks . list ( ) ) <EOL> api . network . floating_ip_supported ( IsA ( http . HttpRequest ) ) . AndReturn ( True ) <EOL> api . network . tenant_floating_ip_list ( IsA ( http . HttpRequest ) ) . MultipleTimes ( ) . AndReturn ( self . floating_ips . list ( ) ) <EOL> api . network . floating_ip_pools_list ( IsA ( http . HttpRequest ) ) . AndReturn ( self . pools . list ( ) ) <EOL> api . network . security_group_list ( IsA ( http . HttpRequest ) ) . AndReturn ( self . security_groups . list ( ) ) <EOL> self . mox . ReplayAll ( ) <EOL> url = reverse ( '<STR_LIT>' % NAMESPACE ) <EOL> res = self . client . get ( url ) <EOL> self . assertEqual ( res . context [ '<STR_LIT>' ] [ '<STR_LIT>' ] [ '<STR_LIT>' ] , <EOL> self . neutron_quotas . first ( ) . get ( '<STR_LIT>' ) . limit ) </s>

<s> import logging <EOL> from django . utils . translation import ugettext_lazy as _ <EOL> from horizon import exceptions <EOL> from horizon import forms <EOL> from openstack_dashboard . api import sahara as saharaclient <EOL> from openstack_dashboard . dashboards . project . data_processing . utils import workflow_helpers <EOL> LOG = logging . getLogger ( __name__ ) <EOL> class UploadFileForm ( forms . SelfHandlingForm , <EOL> workflow_helpers . PluginAndVersionMixin ) : <EOL> template_name = forms . CharField ( max_length = <NUM_LIT> , <EOL> label = _ ( "<STR_LIT>" ) ) <EOL> def __init__ ( self , request , * args , ** kwargs ) : <EOL> super ( UploadFileForm , self ) . __init__ ( request , * args , ** kwargs ) <EOL> sahara = saharaclient . client ( request ) <EOL> self . _generate_plugin_version_fields ( sahara ) <EOL> self . fields [ '<STR_LIT>' ] = forms . FileField ( label = _ ( "<STR_LIT>" ) ) <EOL> def handle ( self , request , data ) : <EOL> try : <EOL> filecontent = self . files [ '<STR_LIT>' ] . read ( ) <EOL> plugin_name = data [ '<STR_LIT>' ] <EOL> hadoop_version = data . get ( plugin_name + "<STR_LIT>" ) <EOL> saharaclient . plugin_convert_to_template ( request , <EOL> plugin_name , <EOL> hadoop_version , <EOL> data [ '<STR_LIT>' ] , <EOL> filecontent ) <EOL> return True <EOL> except Exception : <EOL> exceptions . handle ( request , <EOL> _ ( "<STR_LIT>" ) ) <EOL> return False </s>

<s> import logging <EOL> from django . utils . translation import ugettext_lazy as _ <EOL> from horizon import exceptions <EOL> from horizon import tables <EOL> from horizon import tabs <EOL> from openstack_dashboard . api import sahara as saharaclient <EOL> import openstack_dashboard . dashboards . project . data_processing . data_plugins . tables as p_tables <EOL> import openstack_dashboard . dashboards . project . data_processing . data_plugins . tabs as p_tabs <EOL> LOG = logging . getLogger ( __name__ ) <EOL> class PluginsView ( tables . DataTableView ) : <EOL> table_class = p_tables . PluginsTable <EOL> template_name = '<STR_LIT>' <EOL> def get_data ( self ) : <EOL> try : <EOL> plugins = saharaclient . plugin_list ( self . request ) <EOL> except Exception : <EOL> plugins = [ ] <EOL> msg = _ ( '<STR_LIT>' ) <EOL> exceptions . handle ( self . request , msg ) <EOL> return plugins <EOL> class PluginDetailsView ( tabs . TabView ) : <EOL> tab_group_class = p_tabs . PluginDetailsTabs <EOL> template_name = '<STR_LIT>' </s>

<s> import json <EOL> import logging <EOL> from django . utils . translation import ugettext_lazy as _ <EOL> from horizon import exceptions <EOL> from horizon import forms <EOL> from horizon import workflows <EOL> from openstack_dashboard . api import sahara as saharaclient <EOL> import openstack_dashboard . dashboards . project . data_processing . cluster_templates . workflows . create as t_flows <EOL> import openstack_dashboard . dashboards . project . data_processing . clusters . workflows . create as c_flow <EOL> import openstack_dashboard . dashboards . project . data_processing . utils . workflow_helpers as whelpers <EOL> LOG = logging . getLogger ( __name__ ) <EOL> DATA_SOURCE_CREATE_URL = ( "<STR_LIT>" <EOL> "<STR_LIT>" ) <EOL> class JobExecutionGeneralConfigAction ( workflows . Action ) : <EOL> job_input = forms . DynamicChoiceField ( <EOL> label = _ ( "<STR_LIT>" ) , <EOL> initial = ( None , "<STR_LIT:None>" ) , <EOL> add_item_link = DATA_SOURCE_CREATE_URL ) <EOL> job_output = forms . DynamicChoiceField ( <EOL> label = _ ( "<STR_LIT>" ) , <EOL> initial = ( None , "<STR_LIT:None>" ) , <EOL> add_item_link = DATA_SOURCE_CREATE_URL ) <EOL> def __init__ ( self , request , * args , ** kwargs ) : <EOL> super ( JobExecutionGeneralConfigAction , self ) . __init__ ( request , <EOL> * args , <EOL> ** kwargs ) <EOL> if request . REQUEST . get ( "<STR_LIT>" , None ) is None : <EOL> self . fields [ "<STR_LIT>" ] = forms . ChoiceField ( <EOL> label = _ ( "<STR_LIT>" ) ) <EOL> self . fields [ "<STR_LIT>" ] . choices = self . populate_job_choices ( request ) <EOL> else : <EOL> self . fields [ "<STR_LIT>" ] = forms . CharField ( <EOL> widget = forms . HiddenInput ( ) , <EOL> initial = request . REQUEST . get ( "<STR_LIT>" , None ) ) <EOL> def populate_job_input_choices ( self , request , context ) : <EOL> return self . get_data_source_choices ( request , context ) <EOL> def populate_job_output_choices ( self , request , context ) : <EOL> return self . get_data_source_choices ( request , context ) <EOL> def get_data_source_choices ( self , request , context ) : <EOL> try : <EOL> data_sources = saharaclient . data_source_list ( request ) <EOL> except Exception : <EOL> data_sources = [ ] <EOL> exceptions . handle ( request , <EOL> _ ( "<STR_LIT>" ) ) <EOL> choices = [ ( data_source . id , data_source . name ) <EOL> for data_source in data_sources ] <EOL> choices . insert ( <NUM_LIT:0> , ( None , '<STR_LIT:None>' ) ) <EOL> return choices <EOL> def populate_job_choices ( self , request ) : <EOL> try : <EOL> jobs = saharaclient . job_list ( request ) <EOL> except Exception : <EOL> jobs = [ ] <EOL> exceptions . handle ( request , <EOL> _ ( "<STR_LIT>" ) ) <EOL> choices = [ ( job . id , job . name ) <EOL> for job in jobs ] <EOL> return choices <EOL> class Meta : <EOL> name = _ ( "<STR_LIT>" ) <EOL> help_text_template = ( <EOL> "<STR_LIT>" ) <EOL> class JobExecutionExistingGeneralConfigAction ( JobExecutionGeneralConfigAction ) : <EOL> cluster = forms . ChoiceField ( <EOL> label = _ ( "<STR_LIT>" ) , <EOL> initial = ( None , "<STR_LIT:None>" ) , <EOL> widget = forms . Select ( attrs = { "<STR_LIT:class>" : "<STR_LIT>" } ) ) <EOL> def populate_cluster_choices ( self , request , context ) : <EOL> try : <EOL> clusters = saharaclient . cluster_list ( request ) <EOL> except Exception : <EOL> clusters = [ ] <EOL> exceptions . handle ( request , <EOL> _ ( "<STR_LIT>" ) ) <EOL> choices = [ ( cluster . id , cluster . name ) <EOL> for cluster in clusters ] <EOL> return choices <EOL> class Meta : <EOL> name = _ ( "<STR_LIT>" ) <EOL> help_text_template = ( <EOL> "<STR_LIT>" ) <EOL> class JobConfigAction ( workflows . Action ) : <EOL> MAIN_CLASS = "<STR_LIT>" <EOL> JAVA_OPTS = "<STR_LIT>" <EOL> EDP_MAPPER = "<STR_LIT>" <EOL> EDP_REDUCER = "<STR_LIT>" <EOL> EDP_PREFIX = "<STR_LIT>" <EOL> property_name = forms . ChoiceField ( <EOL> required = False , <EOL> ) <EOL> job_configs = forms . CharField ( <EOL> required = False , <EOL> widget = forms . HiddenInput ( ) ) <EOL> job_params = forms . CharField ( <EOL> required = False , <EOL> widget = forms . HiddenInput ( ) ) <EOL> job_args_array = forms . CharField ( <EOL> required = False , <EOL> widget = forms . HiddenInput ( ) ) <EOL> job_type = forms . CharField ( <EOL> required = False , <EOL> widget = forms . HiddenInput ( ) ) <EOL> main_class = forms . CharField ( label = _ ( "<STR_LIT>" ) , <EOL> required = False ) <EOL> java_opts = forms . CharField ( label = _ ( "<STR_LIT>" ) , <EOL> required = False ) <EOL> streaming_mapper = forms . CharField ( label = _ ( "<STR_LIT>" ) ) <EOL> streaming_reducer = forms . CharField ( label = _ ( "<STR_LIT>" ) ) <EOL> def __init__ ( self , request , * args , ** kwargs ) : <EOL> super ( JobConfigAction , self ) . __init__ ( request , * args , ** kwargs ) <EOL> job_ex_id = request . REQUEST . get ( "<STR_LIT>" ) <EOL> if job_ex_id is not None : <EOL> job_ex_id = request . REQUEST . get ( "<STR_LIT>" ) <EOL> job_ex = saharaclient . job_execution_get ( request , job_ex_id ) <EOL> job_configs = job_ex . job_configs <EOL> edp_configs = { } <EOL> if '<STR_LIT>' in job_configs : <EOL> configs , edp_configs = ( <EOL> self . clean_edp_configs ( job_configs [ '<STR_LIT>' ] ) ) <EOL> self . fields [ '<STR_LIT>' ] . initial = ( <EOL> json . dumps ( configs ) ) <EOL> if '<STR_LIT>' in job_configs : <EOL> self . fields [ '<STR_LIT>' ] . initial = ( <EOL> json . dumps ( job_configs [ '<STR_LIT>' ] ) ) <EOL> job_args = json . dumps ( job_configs [ '<STR_LIT:args>' ] ) <EOL> self . fields [ '<STR_LIT>' ] . initial = job_args <EOL> if self . MAIN_CLASS in edp_configs : <EOL> self . fields [ '<STR_LIT>' ] . initial = ( <EOL> edp_configs [ self . MAIN_CLASS ] ) <EOL> if self . JAVA_OPTS in edp_configs : <EOL> self . fields [ '<STR_LIT>' ] . initial = ( <EOL> edp_configs [ self . JAVA_OPTS ] ) <EOL> if self . EDP_MAPPER in edp_configs : <EOL> self . fields [ '<STR_LIT>' ] . initial = ( <EOL> edp_configs [ self . EDP_MAPPER ] ) <EOL> if self . EDP_REDUCER in edp_configs : <EOL> self . fields [ '<STR_LIT>' ] . initial = ( <EOL> edp_configs [ self . EDP_REDUCER ] ) <EOL> def clean ( self ) : <EOL> cleaned_data = super ( workflows . Action , self ) . clean ( ) <EOL> job_type = cleaned_data . get ( "<STR_LIT>" , None ) <EOL> if job_type != "<STR_LIT>" : <EOL> if "<STR_LIT>" in self . _errors : <EOL> del self . _errors [ "<STR_LIT>" ] <EOL> if "<STR_LIT>" in self . _errors : <EOL> del self . _errors [ "<STR_LIT>" ] <EOL> return cleaned_data <EOL> def populate_property_name_choices ( self , request , context ) : <EOL> job_id = request . REQUEST . get ( "<STR_LIT>" ) or request . REQUEST . get ( "<STR_LIT>" ) <EOL> job_type = saharaclient . job_get ( request , job_id ) . type <EOL> job_configs = ( <EOL> saharaclient . job_get_configs ( request , job_type ) . job_config ) <EOL> choices = [ ( param [ '<STR_LIT:value>' ] , param [ '<STR_LIT:name>' ] ) <EOL> for param in job_configs [ '<STR_LIT>' ] ] <EOL> return choices <EOL> def clean_edp_configs ( self , configs ) : <EOL> edp_configs = { } <EOL> for key , value in configs . iteritems ( ) : <EOL> if key . startswith ( self . EDP_PREFIX ) : <EOL> edp_configs [ key ] = value <EOL> for rmkey in edp_configs . keys ( ) : <EOL> del configs [ rmkey ] <EOL> return ( configs , edp_configs ) <EOL> class Meta : <EOL> name = _ ( "<STR_LIT>" ) <EOL> help_text_template = ( <EOL> "<STR_LIT>" ) <EOL> class JobExecutionGeneralConfig ( workflows . Step ) : <EOL> action_class = JobExecutionGeneralConfigAction <EOL> def contribute ( self , data , context ) : <EOL> for k , v in data . items ( ) : <EOL> if k in [ "<STR_LIT>" , "<STR_LIT>" ] : <EOL> context [ "<STR_LIT>" + k ] = None if v == "<STR_LIT:None>" else v <EOL> else : <EOL> context [ "<STR_LIT>" + k ] = v <EOL> return context <EOL> class JobExecutionExistingGeneralConfig ( workflows . Step ) : <EOL> action_class = JobExecutionExistingGeneralConfigAction <EOL> def contribute ( self , data , context ) : <EOL> for k , v in data . items ( ) : <EOL> if k in [ "<STR_LIT>" , "<STR_LIT>" ] : <EOL> context [ "<STR_LIT>" + k ] = None if v == "<STR_LIT:None>" else v <EOL> else : <EOL> context [ "<STR_LIT>" + k ] = v <EOL> return context <EOL> class JobConfig ( workflows . Step ) : <EOL> action_class = JobConfigAction <EOL> template_name = '<STR_LIT>' <EOL> def contribute ( self , data , context ) : <EOL> job_config = self . clean_configs ( <EOL> json . loads ( data . get ( "<STR_LIT>" , '<STR_LIT:{}>' ) ) ) <EOL> job_params = self . clean_configs ( <EOL> json . loads ( data . get ( "<STR_LIT>" , '<STR_LIT:{}>' ) ) ) <EOL> job_args_array = self . clean_configs ( <EOL> json . loads ( data . get ( "<STR_LIT>" , '<STR_LIT>' ) ) ) <EOL> job_type = data . get ( "<STR_LIT>" , '<STR_LIT>' ) <EOL> context [ "<STR_LIT>" ] = job_type <EOL> context [ "<STR_LIT>" ] = { "<STR_LIT>" : job_config } <EOL> context [ "<STR_LIT>" ] [ "<STR_LIT:args>" ] = job_args_array <EOL> if job_type in [ "<STR_LIT>" , "<STR_LIT>" ] : <EOL> context [ "<STR_LIT>" ] [ "<STR_LIT>" ] [ JobConfigAction . MAIN_CLASS ] = ( <EOL> data . get ( "<STR_LIT>" , "<STR_LIT>" ) ) <EOL> context [ "<STR_LIT>" ] [ "<STR_LIT>" ] [ JobConfigAction . JAVA_OPTS ] = ( <EOL> data . get ( "<STR_LIT>" , "<STR_LIT>" ) ) <EOL> elif job_type == "<STR_LIT>" : <EOL> context [ "<STR_LIT>" ] [ "<STR_LIT>" ] [ JobConfigAction . EDP_MAPPER ] = ( <EOL> data . get ( "<STR_LIT>" , "<STR_LIT>" ) ) <EOL> context [ "<STR_LIT>" ] [ "<STR_LIT>" ] [ JobConfigAction . EDP_REDUCER ] = ( <EOL> data . get ( "<STR_LIT>" , "<STR_LIT>" ) ) <EOL> else : <EOL> context [ "<STR_LIT>" ] [ "<STR_LIT>" ] = job_params <EOL> return context <EOL> @ staticmethod <EOL> def clean_configs ( configs ) : <EOL> cleaned_conf = None <EOL> if isinstance ( configs , dict ) : <EOL> cleaned_conf = dict ( [ ( k . strip ( ) , v . strip ( ) ) <EOL> for k , v in configs . items ( ) <EOL> if len ( v . strip ( ) ) > <NUM_LIT:0> and len ( k . strip ( ) ) > <NUM_LIT:0> ] ) <EOL> elif isinstance ( configs , list ) : <EOL> cleaned_conf = list ( [ v . strip ( ) for v in configs <EOL> if len ( v . strip ( ) ) > <NUM_LIT:0> ] ) <EOL> return cleaned_conf <EOL> class NewClusterConfigAction ( c_flow . GeneralConfigAction ) : <EOL> persist_cluster = forms . BooleanField ( <EOL> label = _ ( "<STR_LIT>" ) , <EOL> required = False ) <EOL> class Meta : <EOL> name = _ ( "<STR_LIT>" ) <EOL> help_text_template = ( <EOL> "<STR_LIT>" ) <EOL> class ClusterGeneralConfig ( workflows . Step ) : <EOL> action_class = NewClusterConfigAction <EOL> contributes = ( "<STR_LIT>" , ) <EOL> def contribute ( self , data , context ) : <EOL> for k , v in data . items ( ) : <EOL> context [ "<STR_LIT>" + k ] = v <EOL> return context <EOL> class LaunchJob ( workflows . Workflow ) : <EOL> slug = "<STR_LIT>" <EOL> name = _ ( "<STR_LIT>" ) <EOL> finalize_button_name = _ ( "<STR_LIT>" ) <EOL> success_message = _ ( "<STR_LIT>" ) <EOL> failure_message = _ ( "<STR_LIT>" ) <EOL> success_url = "<STR_LIT>" <EOL> default_steps = ( JobExecutionExistingGeneralConfig , JobConfig ) <EOL> def handle ( self , request , context ) : <EOL> saharaclient . job_execution_create ( <EOL> request , <EOL> context [ "<STR_LIT>" ] , <EOL> context [ "<STR_LIT>" ] , <EOL> context [ "<STR_LIT>" ] , <EOL> context [ "<STR_LIT>" ] , <EOL> context [ "<STR_LIT>" ] ) <EOL> return True <EOL> class SelectHadoopPluginAction ( t_flows . SelectPluginAction ) : <EOL> def __init__ ( self , request , * args , ** kwargs ) : <EOL> super ( SelectHadoopPluginAction , self ) . __init__ ( request , <EOL> * args , <EOL> ** kwargs ) <EOL> self . fields [ "<STR_LIT>" ] = forms . ChoiceField ( <EOL> label = _ ( "<STR_LIT>" ) , <EOL> initial = request . GET . get ( "<STR_LIT>" ) or request . POST . get ( "<STR_LIT>" ) , <EOL> widget = forms . HiddenInput ( attrs = { "<STR_LIT:class>" : "<STR_LIT>" } ) ) <EOL> self . fields [ "<STR_LIT>" ] = forms . ChoiceField ( <EOL> label = _ ( "<STR_LIT>" ) , <EOL> widget = forms . HiddenInput ( attrs = { "<STR_LIT:class>" : "<STR_LIT>" } ) ) <EOL> self . fields [ "<STR_LIT>" ] = forms . ChoiceField ( <EOL> label = _ ( "<STR_LIT>" ) , <EOL> widget = forms . HiddenInput ( attrs = { "<STR_LIT:class>" : "<STR_LIT>" } ) ) <EOL> self . fields [ "<STR_LIT>" ] = forms . ChoiceField ( <EOL> label = _ ( "<STR_LIT>" ) , <EOL> widget = forms . HiddenInput ( attrs = { "<STR_LIT:class>" : "<STR_LIT>" } ) ) <EOL> job_ex_id = request . REQUEST . get ( "<STR_LIT>" ) <EOL> if job_ex_id is not None : <EOL> self . fields [ "<STR_LIT>" ] = forms . ChoiceField ( <EOL> label = _ ( "<STR_LIT>" ) , <EOL> initial = request . REQUEST . get ( "<STR_LIT>" ) , <EOL> widget = forms . HiddenInput ( <EOL> attrs = { "<STR_LIT:class>" : "<STR_LIT>" } ) ) <EOL> job_ex_id = request . REQUEST . get ( "<STR_LIT>" ) <EOL> job_configs = ( <EOL> saharaclient . job_execution_get ( request , <EOL> job_ex_id ) . job_configs ) <EOL> if "<STR_LIT>" in job_configs : <EOL> self . fields [ "<STR_LIT>" ] . initial = ( <EOL> json . dumps ( job_configs [ "<STR_LIT>" ] ) ) <EOL> if "<STR_LIT>" in job_configs : <EOL> self . fields [ "<STR_LIT>" ] . initial = ( <EOL> json . dumps ( job_configs [ "<STR_LIT>" ] ) ) <EOL> if "<STR_LIT:args>" in job_configs : <EOL> self . fields [ "<STR_LIT>" ] . initial = ( <EOL> json . dumps ( job_configs [ "<STR_LIT:args>" ] ) ) <EOL> class Meta : <EOL> name = _ ( "<STR_LIT>" ) <EOL> help_text_template = ( "<STR_LIT>" <EOL> "<STR_LIT>" ) <EOL> class SelectHadoopPlugin ( workflows . Step ) : <EOL> action_class = SelectHadoopPluginAction <EOL> class ChosePluginVersion ( workflows . Workflow ) : <EOL> slug = "<STR_LIT>" <EOL> name = _ ( "<STR_LIT>" ) <EOL> finalize_button_name = _ ( "<STR_LIT>" ) <EOL> success_message = _ ( "<STR_LIT>" ) <EOL> failure_message = _ ( "<STR_LIT>" ) <EOL> success_url = "<STR_LIT>" <EOL> default_steps = ( SelectHadoopPlugin , ) <EOL> class LaunchJobNewCluster ( workflows . Workflow ) : <EOL> slug = "<STR_LIT>" <EOL> name = _ ( "<STR_LIT>" ) <EOL> finalize_button_name = _ ( "<STR_LIT>" ) <EOL> success_message = _ ( "<STR_LIT>" ) <EOL> failure_message = _ ( "<STR_LIT>" ) <EOL> success_url = "<STR_LIT>" <EOL> default_steps = ( ClusterGeneralConfig , <EOL> JobExecutionGeneralConfig , <EOL> JobConfig ) <EOL> def handle ( self , request , context ) : <EOL> node_groups = None <EOL> plugin , hadoop_version = ( <EOL> whelpers . get_plugin_and_hadoop_version ( request ) ) <EOL> ct_id = context [ "<STR_LIT>" ] or None <EOL> user_keypair = context [ "<STR_LIT>" ] or None <EOL> try : <EOL> cluster = saharaclient . cluster_create ( <EOL> request , <EOL> context [ "<STR_LIT>" ] , <EOL> plugin , hadoop_version , <EOL> cluster_template_id = ct_id , <EOL> default_image_id = context [ "<STR_LIT>" ] , <EOL> description = context [ "<STR_LIT>" ] , <EOL> node_groups = node_groups , <EOL> user_keypair_id = user_keypair , <EOL> is_transient = not ( context [ "<STR_LIT>" ] ) , <EOL> net_id = context . get ( <EOL> "<STR_LIT>" , <EOL> None ) ) <EOL> except Exception : <EOL> exceptions . handle ( request , <EOL> _ ( "<STR_LIT>" ) ) <EOL> return False <EOL> try : <EOL> saharaclient . job_execution_create ( <EOL> request , <EOL> context [ "<STR_LIT>" ] , <EOL> cluster . id , <EOL> context [ "<STR_LIT>" ] , <EOL> context [ "<STR_LIT>" ] , <EOL> context [ "<STR_LIT>" ] ) <EOL> except Exception : <EOL> exceptions . handle ( request , <EOL> _ ( "<STR_LIT>" ) ) <EOL> return False <EOL> return True </s>

<s> import logging <EOL> from django . conf import settings <EOL> from django . core . urlresolvers import reverse <EOL> from django . utils . translation import ugettext_lazy as _ <EOL> from horizon import exceptions <EOL> from horizon import forms <EOL> from horizon . utils import memoized <EOL> from horizon import workflows <EOL> from openstack_dashboard import api <EOL> from openstack_dashboard . dashboards . project . instances import utils as instance_utils <EOL> LOG = logging . getLogger ( __name__ ) <EOL> class SetInstanceDetailsAction ( workflows . Action ) : <EOL> name = forms . CharField ( max_length = <NUM_LIT> , label = _ ( "<STR_LIT>" ) ) <EOL> flavor = forms . ChoiceField ( label = _ ( "<STR_LIT>" ) , <EOL> help_text = _ ( "<STR_LIT>" ) ) <EOL> volume = forms . IntegerField ( label = _ ( "<STR_LIT>" ) , <EOL> min_value = <NUM_LIT:0> , <EOL> initial = <NUM_LIT:1> , <EOL> help_text = _ ( "<STR_LIT>" ) ) <EOL> datastore = forms . ChoiceField ( label = _ ( "<STR_LIT>" ) , <EOL> help_text = _ ( <EOL> "<STR_LIT>" ) ) <EOL> class Meta : <EOL> name = _ ( "<STR_LIT>" ) <EOL> help_text_template = "<STR_LIT>" <EOL> def clean ( self ) : <EOL> if self . data . get ( "<STR_LIT>" , None ) == "<STR_LIT>" : <EOL> msg = _ ( "<STR_LIT>" ) <EOL> self . _errors [ "<STR_LIT>" ] = self . error_class ( [ msg ] ) <EOL> return self . cleaned_data <EOL> @ memoized . memoized_method <EOL> def flavors ( self , request ) : <EOL> try : <EOL> return api . trove . flavor_list ( request ) <EOL> except Exception : <EOL> LOG . exception ( "<STR_LIT>" ) <EOL> redirect = reverse ( "<STR_LIT>" ) <EOL> exceptions . handle ( request , <EOL> _ ( '<STR_LIT>' ) , <EOL> redirect = redirect ) <EOL> def populate_flavor_choices ( self , request , context ) : <EOL> flavors = self . flavors ( request ) <EOL> if flavors : <EOL> return instance_utils . sort_flavor_list ( request , flavors ) <EOL> return [ ] <EOL> @ memoized . memoized_method <EOL> def datastores ( self , request ) : <EOL> try : <EOL> return api . trove . datastore_list ( request ) <EOL> except Exception : <EOL> LOG . exception ( "<STR_LIT>" ) <EOL> self . _datastores = [ ] <EOL> @ memoized . memoized_method <EOL> def datastore_versions ( self , request , datastore ) : <EOL> try : <EOL> return api . trove . datastore_version_list ( request , datastore ) <EOL> except Exception : <EOL> LOG . exception ( "<STR_LIT>" ) <EOL> self . _datastore_versions = [ ] <EOL> def populate_datastore_choices ( self , request , context ) : <EOL> choices = ( ) <EOL> set_initial = False <EOL> datastores = self . datastores ( request ) <EOL> if datastores is not None : <EOL> num_datastores_with_one_version = <NUM_LIT:0> <EOL> for ds in datastores : <EOL> versions = self . datastore_versions ( request , ds . name ) <EOL> if not set_initial : <EOL> if len ( versions ) >= <NUM_LIT:2> : <EOL> set_initial = True <EOL> elif len ( versions ) == <NUM_LIT:1> : <EOL> num_datastores_with_one_version += <NUM_LIT:1> <EOL> if num_datastores_with_one_version > <NUM_LIT:1> : <EOL> set_initial = True <EOL> if len ( versions ) > <NUM_LIT:0> : <EOL> version_choices = ( ) <EOL> for v in versions : <EOL> version_choices = ( version_choices + <EOL> ( ( ds . name + '<STR_LIT:U+002C>' + v . name , v . name ) , ) ) <EOL> datastore_choices = ( ds . name , version_choices ) <EOL> choices = choices + ( datastore_choices , ) <EOL> if set_initial : <EOL> initial = ( ( '<STR_LIT>' , <EOL> _ ( '<STR_LIT>' ) ) ) <EOL> choices = ( initial , ) + choices <EOL> return choices <EOL> TROVE_ADD_USER_PERMS = getattr ( settings , '<STR_LIT>' , [ ] ) <EOL> TROVE_ADD_DATABASE_PERMS = getattr ( settings , '<STR_LIT>' , [ ] ) <EOL> TROVE_ADD_PERMS = TROVE_ADD_USER_PERMS + TROVE_ADD_DATABASE_PERMS <EOL> class SetInstanceDetails ( workflows . Step ) : <EOL> action_class = SetInstanceDetailsAction <EOL> contributes = ( "<STR_LIT:name>" , "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" ) <EOL> class SetNetworkAction ( workflows . Action ) : <EOL> network = forms . MultipleChoiceField ( label = _ ( "<STR_LIT>" ) , <EOL> widget = forms . CheckboxSelectMultiple ( ) , <EOL> error_messages = { <EOL> '<STR_LIT>' : _ ( <EOL> "<STR_LIT>" <EOL> "<STR_LIT>" ) } , <EOL> help_text = _ ( "<STR_LIT>" <EOL> "<STR_LIT>" ) ) <EOL> def __init__ ( self , request , * args , ** kwargs ) : <EOL> super ( SetNetworkAction , self ) . __init__ ( request , * args , ** kwargs ) <EOL> network_list = self . fields [ "<STR_LIT>" ] . choices <EOL> if len ( network_list ) == <NUM_LIT:1> : <EOL> self . fields [ '<STR_LIT>' ] . initial = [ network_list [ <NUM_LIT:0> ] [ <NUM_LIT:0> ] ] <EOL> class Meta : <EOL> name = _ ( "<STR_LIT>" ) <EOL> permissions = ( '<STR_LIT>' , ) <EOL> help_text = _ ( "<STR_LIT>" ) <EOL> def populate_network_choices ( self , request , context ) : <EOL> try : <EOL> tenant_id = self . request . user . tenant_id <EOL> networks = api . neutron . network_list_for_tenant ( request , tenant_id ) <EOL> network_list = [ ( network . id , network . name_or_id ) <EOL> for network in networks ] <EOL> except Exception : <EOL> network_list = [ ] <EOL> exceptions . handle ( request , <EOL> _ ( '<STR_LIT>' ) ) <EOL> return network_list <EOL> class SetNetwork ( workflows . Step ) : <EOL> action_class = SetNetworkAction <EOL> template_name = "<STR_LIT>" <EOL> contributes = ( "<STR_LIT>" , ) <EOL> def contribute ( self , data , context ) : <EOL> if data : <EOL> networks = self . workflow . request . POST . getlist ( "<STR_LIT>" ) <EOL> networks = [ n for n in networks if n != '<STR_LIT>' ] <EOL> if networks : <EOL> context [ '<STR_LIT>' ] = networks <EOL> return context <EOL> class AddDatabasesAction ( workflows . Action ) : <EOL> """<STR_LIT>""" <EOL> databases = forms . CharField ( label = _ ( '<STR_LIT>' ) , <EOL> required = False , <EOL> help_text = _ ( '<STR_LIT>' <EOL> '<STR_LIT>' ) ) <EOL> user = forms . CharField ( label = _ ( '<STR_LIT>' ) , <EOL> required = False , <EOL> help_text = _ ( "<STR_LIT>" ) ) <EOL> password = forms . CharField ( widget = forms . PasswordInput ( ) , <EOL> label = _ ( "<STR_LIT>" ) , <EOL> required = False ) <EOL> host = forms . CharField ( label = _ ( "<STR_LIT>" ) , <EOL> required = False , <EOL> help_text = _ ( "<STR_LIT>" <EOL> "<STR_LIT>" ) ) <EOL> class Meta : <EOL> name = _ ( "<STR_LIT>" ) <EOL> permissions = TROVE_ADD_PERMS <EOL> help_text_template = "<STR_LIT>" <EOL> def clean ( self ) : <EOL> cleaned_data = super ( AddDatabasesAction , self ) . clean ( ) <EOL> if cleaned_data . get ( '<STR_LIT:user>' ) : <EOL> if not cleaned_data . get ( '<STR_LIT:password>' ) : <EOL> msg = _ ( '<STR_LIT>' ) <EOL> self . _errors [ "<STR_LIT:password>" ] = self . error_class ( [ msg ] ) <EOL> if not cleaned_data . get ( '<STR_LIT>' ) : <EOL> msg = _ ( '<STR_LIT>' <EOL> '<STR_LIT>' ) <EOL> self . _errors [ "<STR_LIT>" ] = self . error_class ( [ msg ] ) <EOL> return cleaned_data <EOL> class InitializeDatabase ( workflows . Step ) : <EOL> action_class = AddDatabasesAction <EOL> contributes = [ "<STR_LIT>" , '<STR_LIT:user>' , '<STR_LIT:password>' , '<STR_LIT:host>' ] <EOL> class RestoreAction ( workflows . Action ) : <EOL> backup = forms . ChoiceField ( label = _ ( "<STR_LIT>" ) , <EOL> required = False , <EOL> help_text = _ ( '<STR_LIT>' ) ) <EOL> class Meta : <EOL> name = _ ( "<STR_LIT>" ) <EOL> permissions = ( '<STR_LIT>' , ) <EOL> help_text_template = "<STR_LIT>" <EOL> def populate_backup_choices ( self , request , context ) : <EOL> try : <EOL> backups = api . trove . backup_list ( request ) <EOL> choices = [ ( b . id , b . name ) for b in backups <EOL> if b . status == '<STR_LIT>' ] <EOL> except Exception : <EOL> choices = [ ] <EOL> if choices : <EOL> choices . insert ( <NUM_LIT:0> , ( "<STR_LIT>" , _ ( "<STR_LIT>" ) ) ) <EOL> else : <EOL> choices . insert ( <NUM_LIT:0> , ( "<STR_LIT>" , _ ( "<STR_LIT>" ) ) ) <EOL> return choices <EOL> def clean_backup ( self ) : <EOL> backup = self . cleaned_data [ '<STR_LIT>' ] <EOL> if backup : <EOL> try : <EOL> LOG . debug ( "<STR_LIT>" ) <EOL> bkup = api . trove . backup_get ( self . request , backup ) <EOL> self . cleaned_data [ '<STR_LIT>' ] = bkup . id <EOL> except Exception : <EOL> raise forms . ValidationError ( _ ( "<STR_LIT>" ) ) <EOL> return backup <EOL> class RestoreBackup ( workflows . Step ) : <EOL> action_class = RestoreAction <EOL> contributes = [ '<STR_LIT>' ] <EOL> class LaunchInstance ( workflows . Workflow ) : <EOL> slug = "<STR_LIT>" <EOL> name = _ ( "<STR_LIT>" ) <EOL> finalize_button_name = _ ( "<STR_LIT>" ) <EOL> success_message = _ ( '<STR_LIT>' ) <EOL> failure_message = _ ( '<STR_LIT>' ) <EOL> success_url = "<STR_LIT>" <EOL> default_steps = ( SetInstanceDetails , <EOL> SetNetwork , <EOL> InitializeDatabase , <EOL> RestoreBackup ) <EOL> def __init__ ( self , request = None , context_seed = None , entry_point = None , <EOL> * args , ** kwargs ) : <EOL> super ( LaunchInstance , self ) . __init__ ( request , context_seed , <EOL> entry_point , * args , ** kwargs ) <EOL> self . attrs [ '<STR_LIT>' ] = ( <EOL> settings . HORIZON_CONFIG . get ( '<STR_LIT>' ) ) <EOL> def format_status_message ( self , message ) : <EOL> name = self . context . get ( '<STR_LIT:name>' , '<STR_LIT>' ) <EOL> return message % { "<STR_LIT:count>" : _ ( "<STR_LIT>" ) , "<STR_LIT:name>" : name } <EOL> def _get_databases ( self , context ) : <EOL> """<STR_LIT>""" <EOL> databases = None <EOL> if context . get ( '<STR_LIT>' ) : <EOL> dbs = context [ '<STR_LIT>' ] <EOL> databases = [ { '<STR_LIT:name>' : d . strip ( ) } for d in dbs . split ( '<STR_LIT:U+002C>' ) ] <EOL> return databases <EOL> def _get_users ( self , context ) : <EOL> users = None <EOL> if context . get ( '<STR_LIT:user>' ) : <EOL> user = { <EOL> '<STR_LIT:name>' : context [ '<STR_LIT:user>' ] , <EOL> '<STR_LIT:password>' : context [ '<STR_LIT:password>' ] , <EOL> '<STR_LIT>' : self . _get_databases ( context ) , <EOL> } <EOL> if context [ '<STR_LIT:host>' ] : <EOL> user [ '<STR_LIT:host>' ] = context [ '<STR_LIT:host>' ] <EOL> users = [ user ] <EOL> return users <EOL> def _get_backup ( self , context ) : <EOL> backup = None <EOL> if context . get ( '<STR_LIT>' ) : <EOL> backup = { '<STR_LIT>' : context [ '<STR_LIT>' ] } <EOL> return backup <EOL> def _get_nics ( self , context ) : <EOL> netids = context . get ( '<STR_LIT>' , None ) <EOL> if netids : <EOL> return [ { "<STR_LIT>" : netid , "<STR_LIT>" : "<STR_LIT>" } <EOL> for netid in netids ] <EOL> else : <EOL> return None <EOL> def handle ( self , request , context ) : <EOL> try : <EOL> datastore = self . context [ '<STR_LIT>' ] . split ( '<STR_LIT:U+002C>' ) [ <NUM_LIT:0> ] <EOL> datastore_version = self . context [ '<STR_LIT>' ] . split ( '<STR_LIT:U+002C>' ) [ <NUM_LIT:1> ] <EOL> LOG . info ( "<STR_LIT>" <EOL> "<STR_LIT>" <EOL> "<STR_LIT>" <EOL> "<STR_LIT>" <EOL> "<STR_LIT>" , <EOL> context [ '<STR_LIT:name>' ] , context [ '<STR_LIT>' ] , context [ '<STR_LIT>' ] , <EOL> datastore , datastore_version , <EOL> self . _get_databases ( context ) , self . _get_users ( context ) , <EOL> self . _get_backup ( context ) , self . _get_nics ( context ) ) <EOL> api . trove . instance_create ( request , <EOL> context [ '<STR_LIT:name>' ] , <EOL> context [ '<STR_LIT>' ] , <EOL> context [ '<STR_LIT>' ] , <EOL> datastore = datastore , <EOL> datastore_version = datastore_version , <EOL> databases = self . _get_databases ( context ) , <EOL> users = self . _get_users ( context ) , <EOL> restore_point = self . _get_backup ( context ) , <EOL> nics = self . _get_nics ( context ) ) <EOL> return True <EOL> except Exception : <EOL> exceptions . handle ( request ) <EOL> return False </s>

<s> import logging <EOL> from django . conf import settings <EOL> from django . core import urlresolvers <EOL> from django . http import HttpResponse <EOL> from django import shortcuts <EOL> from django import template <EOL> from django . template . defaultfilters import title <EOL> from django . utils . http import urlencode <EOL> from django . utils . translation import npgettext_lazy <EOL> from django . utils . translation import pgettext_lazy <EOL> from django . utils . translation import string_concat <EOL> from django . utils . translation import ugettext_lazy as _ <EOL> from django . utils . translation import ungettext_lazy <EOL> from horizon import conf <EOL> from horizon import exceptions <EOL> from horizon import messages <EOL> from horizon import tables <EOL> from horizon . templatetags import sizeformat <EOL> from horizon . utils import filters <EOL> from openstack_dashboard import api <EOL> from openstack_dashboard . dashboards . project . access_and_security . floating_ips import workflows <EOL> from openstack_dashboard . dashboards . project . instances import tabs <EOL> from openstack_dashboard . dashboards . project . instances . workflows import resize_instance <EOL> from openstack_dashboard . dashboards . project . instances . workflows import update_instance <EOL> from openstack_dashboard import policy <EOL> LOG = logging . getLogger ( __name__ ) <EOL> ACTIVE_STATES = ( "<STR_LIT>" , ) <EOL> VOLUME_ATTACH_READY_STATES = ( "<STR_LIT>" , "<STR_LIT>" ) <EOL> SNAPSHOT_READY_STATES = ( "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" ) <EOL> POWER_STATES = { <EOL> <NUM_LIT:0> : "<STR_LIT>" , <EOL> <NUM_LIT:1> : "<STR_LIT>" , <EOL> <NUM_LIT:2> : "<STR_LIT>" , <EOL> <NUM_LIT:3> : "<STR_LIT>" , <EOL> <NUM_LIT:4> : "<STR_LIT>" , <EOL> <NUM_LIT:5> : "<STR_LIT>" , <EOL> <NUM_LIT:6> : "<STR_LIT>" , <EOL> <NUM_LIT:7> : "<STR_LIT>" , <EOL> <NUM_LIT:8> : "<STR_LIT>" , <EOL> <NUM_LIT:9> : "<STR_LIT>" , <EOL> } <EOL> PAUSE = <NUM_LIT:0> <EOL> UNPAUSE = <NUM_LIT:1> <EOL> SUSPEND = <NUM_LIT:0> <EOL> RESUME = <NUM_LIT:1> <EOL> def is_deleting ( instance ) : <EOL> task_state = getattr ( instance , "<STR_LIT>" , None ) <EOL> if not task_state : <EOL> return False <EOL> return task_state . lower ( ) == "<STR_LIT>" <EOL> class TerminateInstance ( policy . PolicyTargetMixin , tables . BatchAction ) : <EOL> name = "<STR_LIT>" <EOL> classes = ( "<STR_LIT>" , ) <EOL> icon = "<STR_LIT>" <EOL> policy_rules = ( ( "<STR_LIT>" , "<STR_LIT>" ) , ) <EOL> @ staticmethod <EOL> def action_present ( count ) : <EOL> return ungettext_lazy ( <EOL> u"<STR_LIT>" , <EOL> u"<STR_LIT>" , <EOL> count <EOL> ) <EOL> @ staticmethod <EOL> def action_past ( count ) : <EOL> return ungettext_lazy ( <EOL> u"<STR_LIT>" , <EOL> u"<STR_LIT>" , <EOL> count <EOL> ) <EOL> def allowed ( self , request , instance = None ) : <EOL> """<STR_LIT>""" <EOL> return not is_deleting ( instance ) <EOL> def action ( self , request , obj_id ) : <EOL> api . nova . server_delete ( request , obj_id ) <EOL> class RebootInstance ( policy . PolicyTargetMixin , tables . BatchAction ) : <EOL> name = "<STR_LIT>" <EOL> classes = ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> policy_rules = ( ( "<STR_LIT>" , "<STR_LIT>" ) , ) <EOL> @ staticmethod <EOL> def action_present ( count ) : <EOL> return ungettext_lazy ( <EOL> u"<STR_LIT>" , <EOL> u"<STR_LIT>" , <EOL> count <EOL> ) <EOL> @ staticmethod <EOL> def action_past ( count ) : <EOL> return ungettext_lazy ( <EOL> u"<STR_LIT>" , <EOL> u"<STR_LIT>" , <EOL> count <EOL> ) <EOL> def allowed ( self , request , instance = None ) : <EOL> if instance is not None : <EOL> return ( ( instance . status in ACTIVE_STATES <EOL> or instance . status == '<STR_LIT>' ) <EOL> and not is_deleting ( instance ) ) <EOL> else : <EOL> return True <EOL> def action ( self , request , obj_id ) : <EOL> api . nova . server_reboot ( request , obj_id , soft_reboot = False ) <EOL> class SoftRebootInstance ( RebootInstance ) : <EOL> name = "<STR_LIT>" <EOL> @ staticmethod <EOL> def action_present ( count ) : <EOL> return ungettext_lazy ( <EOL> u"<STR_LIT>" , <EOL> u"<STR_LIT>" , <EOL> count <EOL> ) <EOL> @ staticmethod <EOL> def action_past ( count ) : <EOL> return ungettext_lazy ( <EOL> u"<STR_LIT>" , <EOL> u"<STR_LIT>" , <EOL> count <EOL> ) <EOL> def action ( self , request , obj_id ) : <EOL> api . nova . server_reboot ( request , obj_id , soft_reboot = True ) <EOL> class TogglePause ( tables . BatchAction ) : <EOL> name = "<STR_LIT>" <EOL> icon = "<STR_LIT>" <EOL> @ staticmethod <EOL> def action_present ( count ) : <EOL> return ( <EOL> ungettext_lazy ( <EOL> u"<STR_LIT>" , <EOL> u"<STR_LIT>" , <EOL> count <EOL> ) , <EOL> ungettext_lazy ( <EOL> u"<STR_LIT>" , <EOL> u"<STR_LIT>" , <EOL> count <EOL> ) , <EOL> ) <EOL> @ staticmethod <EOL> def action_past ( count ) : <EOL> return ( <EOL> ungettext_lazy ( <EOL> u"<STR_LIT>" , <EOL> u"<STR_LIT>" , <EOL> count <EOL> ) , <EOL> ungettext_lazy ( <EOL> u"<STR_LIT>" , <EOL> u"<STR_LIT>" , <EOL> count <EOL> ) , <EOL> ) <EOL> def allowed ( self , request , instance = None ) : <EOL> if not api . nova . extension_supported ( '<STR_LIT>' , <EOL> request ) : <EOL> return False <EOL> if not instance : <EOL> return False <EOL> self . paused = instance . status == "<STR_LIT>" <EOL> if self . paused : <EOL> self . current_present_action = UNPAUSE <EOL> policy = ( ( "<STR_LIT>" , "<STR_LIT>" ) , ) <EOL> else : <EOL> self . current_present_action = PAUSE <EOL> policy = ( ( "<STR_LIT>" , "<STR_LIT>" ) , ) <EOL> has_permission = True <EOL> policy_check = getattr ( settings , "<STR_LIT>" , None ) <EOL> if policy_check : <EOL> has_permission = policy_check ( <EOL> policy , request , <EOL> target = { '<STR_LIT>' : getattr ( instance , '<STR_LIT>' , None ) } ) <EOL> return ( has_permission <EOL> and ( instance . status in ACTIVE_STATES or self . paused ) <EOL> and not is_deleting ( instance ) ) <EOL> def action ( self , request , obj_id ) : <EOL> if self . paused : <EOL> api . nova . server_unpause ( request , obj_id ) <EOL> self . current_past_action = UNPAUSE <EOL> else : <EOL> api . nova . server_pause ( request , obj_id ) <EOL> self . current_past_action = PAUSE <EOL> class ToggleSuspend ( tables . BatchAction ) : <EOL> name = "<STR_LIT>" <EOL> classes = ( "<STR_LIT>" , ) <EOL> @ staticmethod <EOL> def action_present ( count ) : <EOL> return ( <EOL> ungettext_lazy ( <EOL> u"<STR_LIT>" , <EOL> u"<STR_LIT>" , <EOL> count <EOL> ) , <EOL> ungettext_lazy ( <EOL> u"<STR_LIT>" , <EOL> u"<STR_LIT>" , <EOL> count <EOL> ) , <EOL> ) <EOL> @ staticmethod <EOL> def action_past ( count ) : <EOL> return ( <EOL> ungettext_lazy ( <EOL> u"<STR_LIT>" , <EOL> u"<STR_LIT>" , <EOL> count <EOL> ) , <EOL> ungettext_lazy ( <EOL> u"<STR_LIT>" , <EOL> u"<STR_LIT>" , <EOL> count <EOL> ) , <EOL> ) <EOL> def allowed ( self , request , instance = None ) : <EOL> if not api . nova . extension_supported ( '<STR_LIT>' , <EOL> request ) : <EOL> return False <EOL> if not instance : <EOL> return False <EOL> self . suspended = instance . status == "<STR_LIT>" <EOL> if self . suspended : <EOL> self . current_present_action = RESUME <EOL> policy = ( ( "<STR_LIT>" , "<STR_LIT>" ) , ) <EOL> else : <EOL> self . current_present_action = SUSPEND <EOL> policy = ( ( "<STR_LIT>" , "<STR_LIT>" ) , ) <EOL> has_permission = True <EOL> policy_check = getattr ( settings , "<STR_LIT>" , None ) <EOL> if policy_check : <EOL> has_permission = policy_check ( <EOL> policy , request , <EOL> target = { '<STR_LIT>' : getattr ( instance , '<STR_LIT>' , None ) } ) <EOL> return ( has_permission <EOL> and ( instance . status in ACTIVE_STATES or self . suspended ) <EOL> and not is_deleting ( instance ) ) <EOL> def action ( self , request , obj_id ) : <EOL> if self . suspended : <EOL> api . nova . server_resume ( request , obj_id ) <EOL> self . current_past_action = RESUME <EOL> else : <EOL> api . nova . server_suspend ( request , obj_id ) <EOL> self . current_past_action = SUSPEND <EOL> class LaunchLink ( tables . LinkAction ) : <EOL> name = "<STR_LIT>" <EOL> verbose_name = _ ( "<STR_LIT>" ) <EOL> url = "<STR_LIT>" <EOL> classes = ( "<STR_LIT>" , "<STR_LIT>" ) <EOL> icon = "<STR_LIT>" <EOL> policy_rules = ( ( "<STR_LIT>" , "<STR_LIT>" ) , ) <EOL> ajax = True <EOL> def __init__ ( self , attrs = None , ** kwargs ) : <EOL> kwargs [ '<STR_LIT>' ] = True <EOL> super ( LaunchLink , self ) . __init__ ( attrs , ** kwargs ) <EOL> def allowed ( self , request , datum ) : <EOL> try : <EOL> limits = api . nova . tenant_absolute_limits ( request , reserved = True ) <EOL> instances_available = limits [ '<STR_LIT>' ] - limits [ '<STR_LIT>' ] <EOL> cores_available = limits [ '<STR_LIT>' ] - limits [ '<STR_LIT>' ] <EOL> ram_available = limits [ '<STR_LIT>' ] - limits [ '<STR_LIT>' ] <EOL> if instances_available <= <NUM_LIT:0> or cores_available <= <NUM_LIT:0> or ram_available <= <NUM_LIT:0> : <EOL> if "<STR_LIT>" not in self . classes : <EOL> self . classes = [ c for c in self . classes ] + [ '<STR_LIT>' ] <EOL> self . verbose_name = string_concat ( self . verbose_name , '<STR_LIT:U+0020>' , <EOL> _ ( "<STR_LIT>" ) ) <EOL> else : <EOL> self . verbose_name = _ ( "<STR_LIT>" ) <EOL> classes = [ c for c in self . classes if c != "<STR_LIT>" ] <EOL> self . classes = classes <EOL> except Exception : <EOL> LOG . exception ( "<STR_LIT>" ) <EOL> return True <EOL> def single ( self , table , request , object_id = None ) : <EOL> self . allowed ( request , None ) <EOL> return HttpResponse ( self . render ( ) ) <EOL> class EditInstance ( policy . PolicyTargetMixin , tables . LinkAction ) : <EOL> name = "<STR_LIT>" <EOL> verbose_name = _ ( "<STR_LIT>" ) <EOL> url = "<STR_LIT>" <EOL> classes = ( "<STR_LIT>" , ) <EOL> icon = "<STR_LIT>" <EOL> policy_rules = ( ( "<STR_LIT>" , "<STR_LIT>" ) , ) <EOL> def get_link_url ( self , project ) : <EOL> return self . _get_link_url ( project , '<STR_LIT>' ) <EOL> def _get_link_url ( self , project , step_slug ) : <EOL> base_url = urlresolvers . reverse ( self . url , args = [ project . id ] ) <EOL> next_url = self . table . get_full_url ( ) <EOL> params = { "<STR_LIT>" : step_slug , <EOL> update_instance . UpdateInstance . redirect_param_name : next_url } <EOL> param = urlencode ( params ) <EOL> return "<STR_LIT:?>" . join ( [ base_url , param ] ) <EOL> def allowed ( self , request , instance ) : <EOL> return not is_deleting ( instance ) <EOL> class EditInstanceSecurityGroups ( EditInstance ) : <EOL> name = "<STR_LIT>" <EOL> verbose_name = _ ( "<STR_LIT>" ) <EOL> def get_link_url ( self , project ) : <EOL> return self . _get_link_url ( project , '<STR_LIT>' ) <EOL> def allowed ( self , request , instance = None ) : <EOL> return ( instance . status in ACTIVE_STATES and <EOL> not is_deleting ( instance ) and <EOL> request . user . tenant_id == instance . tenant_id ) <EOL> class CreateSnapshot ( policy . PolicyTargetMixin , tables . LinkAction ) : <EOL> name = "<STR_LIT>" <EOL> verbose_name = _ ( "<STR_LIT>" ) <EOL> url = "<STR_LIT>" <EOL> classes = ( "<STR_LIT>" , ) <EOL> icon = "<STR_LIT>" <EOL> policy_rules = ( ( "<STR_LIT>" , "<STR_LIT>" ) , ) <EOL> def allowed ( self , request , instance = None ) : <EOL> return instance . status in SNAPSHOT_READY_STATES and not is_deleting ( instance ) <EOL> class ConsoleLink ( policy . PolicyTargetMixin , tables . LinkAction ) : <EOL> name = "<STR_LIT>" <EOL> verbose_name = _ ( "<STR_LIT>" ) <EOL> url = "<STR_LIT>" <EOL> classes = ( "<STR_LIT>" , ) <EOL> policy_rules = ( ( "<STR_LIT>" , "<STR_LIT>" ) , ) <EOL> def allowed ( self , request , instance = None ) : <EOL> return bool ( getattr ( settings , '<STR_LIT>' , True ) ) and instance . status in ACTIVE_STATES and not is_deleting ( instance ) <EOL> def get_link_url ( self , datum ) : <EOL> base_url = super ( ConsoleLink , self ) . get_link_url ( datum ) <EOL> tab_query_string = tabs . ConsoleTab ( <EOL> tabs . InstanceDetailTabs ) . get_query_string ( ) <EOL> return "<STR_LIT:?>" . join ( [ base_url , tab_query_string ] ) <EOL> class LogLink ( policy . PolicyTargetMixin , tables . LinkAction ) : <EOL> name = "<STR_LIT>" <EOL> verbose_name = _ ( "<STR_LIT>" ) <EOL> url = "<STR_LIT>" <EOL> classes = ( "<STR_LIT>" , ) <EOL> policy_rules = ( ( "<STR_LIT>" , "<STR_LIT>" ) , ) <EOL> def allowed ( self , request , instance = None ) : <EOL> return instance . status in ACTIVE_STATES and not is_deleting ( instance ) <EOL> def get_link_url ( self , datum ) : <EOL> base_url = super ( LogLink , self ) . get_link_url ( datum ) <EOL> tab_query_string = tabs . LogTab ( <EOL> tabs . InstanceDetailTabs ) . get_query_string ( ) <EOL> return "<STR_LIT:?>" . join ( [ base_url , tab_query_string ] ) <EOL> class ResizeLink ( policy . PolicyTargetMixin , tables . LinkAction ) : <EOL> name = "<STR_LIT>" <EOL> verbose_name = _ ( "<STR_LIT>" ) <EOL> url = "<STR_LIT>" <EOL> classes = ( "<STR_LIT>" , "<STR_LIT>" ) <EOL> policy_rules = ( ( "<STR_LIT>" , "<STR_LIT>" ) , ) <EOL> def get_link_url ( self , project ) : <EOL> return self . _get_link_url ( project , '<STR_LIT>' ) <EOL> def _get_link_url ( self , project , step_slug ) : <EOL> base_url = urlresolvers . reverse ( self . url , args = [ project . id ] ) <EOL> next_url = self . table . get_full_url ( ) <EOL> params = { "<STR_LIT>" : step_slug , <EOL> resize_instance . ResizeInstance . redirect_param_name : next_url } <EOL> param = urlencode ( params ) <EOL> return "<STR_LIT:?>" . join ( [ base_url , param ] ) <EOL> def allowed ( self , request , instance ) : <EOL> return ( ( instance . status in ACTIVE_STATES <EOL> or instance . status == '<STR_LIT>' ) <EOL> and not is_deleting ( instance ) ) <EOL> class ConfirmResize ( policy . PolicyTargetMixin , tables . Action ) : <EOL> name = "<STR_LIT>" <EOL> verbose_name = _ ( "<STR_LIT>" ) <EOL> classes = ( "<STR_LIT>" , "<STR_LIT>" ) <EOL> policy_rules = ( ( "<STR_LIT>" , "<STR_LIT>" ) , ) <EOL> def allowed ( self , request , instance ) : <EOL> return instance . status == '<STR_LIT>' <EOL> def single ( self , table , request , instance ) : <EOL> api . nova . server_confirm_resize ( request , instance ) <EOL> class RevertResize ( policy . PolicyTargetMixin , tables . Action ) : <EOL> name = "<STR_LIT>" <EOL> verbose_name = _ ( "<STR_LIT>" ) <EOL> classes = ( "<STR_LIT>" , "<STR_LIT>" ) <EOL> policy_rules = ( ( "<STR_LIT>" , "<STR_LIT>" ) , ) <EOL> def allowed ( self , request , instance ) : <EOL> return instance . status == '<STR_LIT>' <EOL> def single ( self , table , request , instance ) : <EOL> api . nova . server_revert_resize ( request , instance ) <EOL> class RebuildInstance ( policy . PolicyTargetMixin , tables . LinkAction ) : <EOL> name = "<STR_LIT>" <EOL> verbose_name = _ ( "<STR_LIT>" ) <EOL> classes = ( "<STR_LIT>" , "<STR_LIT>" ) <EOL> url = "<STR_LIT>" <EOL> policy_rules = ( ( "<STR_LIT>" , "<STR_LIT>" ) , ) <EOL> def allowed ( self , request , instance ) : <EOL> return ( ( instance . status in ACTIVE_STATES <EOL> or instance . status == '<STR_LIT>' ) <EOL> and not is_deleting ( instance ) ) <EOL> def get_link_url ( self , datum ) : <EOL> instance_id = self . table . get_object_id ( datum ) <EOL> return urlresolvers . reverse ( self . url , args = [ instance_id ] ) <EOL> class DecryptInstancePassword ( tables . LinkAction ) : <EOL> name = "<STR_LIT>" <EOL> verbose_name = _ ( "<STR_LIT>" ) <EOL> classes = ( "<STR_LIT>" , "<STR_LIT>" ) <EOL> url = "<STR_LIT>" <EOL> def allowed ( self , request , instance ) : <EOL> enable = getattr ( settings , <EOL> '<STR_LIT>' , <EOL> False ) <EOL> return ( enable <EOL> and ( instance . status in ACTIVE_STATES <EOL> or instance . status == '<STR_LIT>' ) <EOL> and not is_deleting ( instance ) <EOL> and get_keyname ( instance ) is not None ) <EOL> def get_link_url ( self , datum ) : <EOL> instance_id = self . table . get_object_id ( datum ) <EOL> keypair_name = get_keyname ( datum ) <EOL> return urlresolvers . reverse ( self . url , args = [ instance_id , <EOL> keypair_name ] ) <EOL> class AssociateIP ( policy . PolicyTargetMixin , tables . LinkAction ) : <EOL> name = "<STR_LIT>" <EOL> verbose_name = _ ( "<STR_LIT>" ) <EOL> url = "<STR_LIT>" <EOL> classes = ( "<STR_LIT>" , ) <EOL> icon = "<STR_LIT>" <EOL> policy_rules = ( ( "<STR_LIT>" , "<STR_LIT>" ) , ) <EOL> def allowed ( self , request , instance ) : <EOL> if not api . network . floating_ip_supported ( request ) : <EOL> return False <EOL> if api . network . floating_ip_simple_associate_supported ( request ) : <EOL> return False <EOL> return not is_deleting ( instance ) <EOL> def get_link_url ( self , datum ) : <EOL> base_url = urlresolvers . reverse ( self . url ) <EOL> next_url = self . table . get_full_url ( ) <EOL> params = { <EOL> "<STR_LIT>" : self . table . get_object_id ( datum ) , <EOL> workflows . IPAssociationWorkflow . redirect_param_name : next_url } <EOL> params = urlencode ( params ) <EOL> return "<STR_LIT:?>" . join ( [ base_url , params ] ) <EOL> class SimpleAssociateIP ( policy . PolicyTargetMixin , tables . Action ) : <EOL> name = "<STR_LIT>" <EOL> verbose_name = _ ( "<STR_LIT>" ) <EOL> icon = "<STR_LIT>" <EOL> policy_rules = ( ( "<STR_LIT>" , "<STR_LIT>" ) , ) <EOL> def allowed ( self , request , instance ) : <EOL> if not api . network . floating_ip_simple_associate_supported ( request ) : <EOL> return False <EOL> return not is_deleting ( instance ) <EOL> def single ( self , table , request , instance_id ) : <EOL> try : <EOL> target_id = api . network . floating_ip_target_get_by_instance ( <EOL> request , instance_id ) . split ( '<STR_LIT:_>' ) [ <NUM_LIT:0> ] <EOL> fip = api . network . tenant_floating_ip_allocate ( request ) <EOL> api . network . floating_ip_associate ( request , fip . id , target_id ) <EOL> messages . success ( request , <EOL> _ ( "<STR_LIT>" ) <EOL> % fip . ip ) <EOL> except Exception : <EOL> exceptions . handle ( request , <EOL> _ ( "<STR_LIT>" ) ) <EOL> return shortcuts . redirect ( request . get_full_path ( ) ) <EOL> class SimpleDisassociateIP ( policy . PolicyTargetMixin , tables . Action ) : <EOL> name = "<STR_LIT>" <EOL> verbose_name = _ ( "<STR_LIT>" ) <EOL> classes = ( "<STR_LIT>" , "<STR_LIT>" , ) <EOL> policy_rules = ( ( "<STR_LIT>" , "<STR_LIT>" ) , ) <EOL> def allowed ( self , request , instance ) : <EOL> if not api . network . floating_ip_supported ( request ) : <EOL> return False <EOL> if not conf . HORIZON_CONFIG [ "<STR_LIT>" ] : <EOL> return False <EOL> return not is_deleting ( instance ) <EOL> def single ( self , table , request , instance_id ) : <EOL> try : <EOL> targets = api . network . floating_ip_target_list_by_instance ( <EOL> request , instance_id ) <EOL> target_ids = [ t . split ( '<STR_LIT:_>' ) [ <NUM_LIT:0> ] for t in targets ] <EOL> fips = [ fip for fip in api . network . tenant_floating_ip_list ( request ) <EOL> if fip . port_id in target_ids ] <EOL> if fips : <EOL> fip = fips . pop ( ) <EOL> api . network . floating_ip_disassociate ( request , fip . id ) <EOL> messages . success ( request , <EOL> _ ( "<STR_LIT>" <EOL> "<STR_LIT>" ) % fip . ip ) <EOL> else : <EOL> messages . info ( request , _ ( "<STR_LIT>" ) ) <EOL> except Exception : <EOL> exceptions . handle ( request , <EOL> _ ( "<STR_LIT>" ) ) <EOL> return shortcuts . redirect ( request . get_full_path ( ) ) <EOL> def instance_fault_to_friendly_message ( instance ) : <EOL> fault = getattr ( instance , '<STR_LIT>' , { } ) <EOL> message = fault . get ( '<STR_LIT:message>' , _ ( "<STR_LIT>" ) ) <EOL> default_message = _ ( "<STR_LIT>" ) % message <EOL> fault_map = { <EOL> '<STR_LIT>' : _ ( "<STR_LIT>" <EOL> "<STR_LIT>" <EOL> "<STR_LIT>" <EOL> "<STR_LIT>" ) <EOL> } <EOL> return fault_map . get ( message , default_message ) <EOL> def get_instance_error ( instance ) : <EOL> if instance . status . lower ( ) != '<STR_LIT:error>' : <EOL> return None <EOL> message = instance_fault_to_friendly_message ( instance ) <EOL> preamble = _ ( '<STR_LIT>' <EOL> ) % instance . name or instance . id <EOL> message = string_concat ( preamble , '<STR_LIT>' , message ) <EOL> return message <EOL> class UpdateRow ( tables . Row ) : <EOL> ajax = True <EOL> def get_data ( self , request , instance_id ) : <EOL> instance = api . nova . server_get ( request , instance_id ) <EOL> try : <EOL> instance . full_flavor = api . nova . flavor_get ( request , <EOL> instance . flavor [ "<STR_LIT:id>" ] ) <EOL> except Exception : <EOL> exceptions . handle ( request , <EOL> _ ( '<STR_LIT>' <EOL> '<STR_LIT>' ) % instance_id , <EOL> ignore = True ) <EOL> error = get_instance_error ( instance ) <EOL> if error : <EOL> messages . error ( request , error ) <EOL> return instance <EOL> class StartInstance ( policy . PolicyTargetMixin , tables . BatchAction ) : <EOL> name = "<STR_LIT:start>" <EOL> classes = ( '<STR_LIT>' , ) <EOL> policy_rules = ( ( "<STR_LIT>" , "<STR_LIT>" ) , ) <EOL> @ staticmethod <EOL> def action_present ( count ) : <EOL> return ungettext_lazy ( <EOL> u"<STR_LIT>" , <EOL> u"<STR_LIT>" , <EOL> count <EOL> ) <EOL> @ staticmethod <EOL> def action_past ( count ) : <EOL> return ungettext_lazy ( <EOL> u"<STR_LIT>" , <EOL> u"<STR_LIT>" , <EOL> count <EOL> ) <EOL> def allowed ( self , request , instance ) : <EOL> return ( ( instance is None ) or <EOL> ( instance . status in ( "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" ) ) ) <EOL> def action ( self , request , obj_id ) : <EOL> api . nova . server_start ( request , obj_id ) <EOL> class StopInstance ( policy . PolicyTargetMixin , tables . BatchAction ) : <EOL> name = "<STR_LIT>" <EOL> classes = ( '<STR_LIT>' , ) <EOL> policy_rules = ( ( "<STR_LIT>" , "<STR_LIT>" ) , ) <EOL> @ staticmethod <EOL> def action_present ( count ) : <EOL> return npgettext_lazy ( <EOL> "<STR_LIT>" , <EOL> u"<STR_LIT>" , <EOL> u"<STR_LIT>" , <EOL> count <EOL> ) <EOL> @ staticmethod <EOL> def action_past ( count ) : <EOL> return npgettext_lazy ( <EOL> "<STR_LIT>" , <EOL> u"<STR_LIT>" , <EOL> u"<STR_LIT>" , <EOL> count <EOL> ) <EOL> def allowed ( self , request , instance ) : <EOL> return ( ( instance is None ) <EOL> or ( ( get_power_state ( instance ) in ( "<STR_LIT>" , "<STR_LIT>" ) ) <EOL> and not is_deleting ( instance ) ) ) <EOL> def action ( self , request , obj_id ) : <EOL> api . nova . server_stop ( request , obj_id ) <EOL> class LockInstance ( policy . PolicyTargetMixin , tables . BatchAction ) : <EOL> name = "<STR_LIT>" <EOL> policy_rules = ( ( "<STR_LIT>" , "<STR_LIT>" ) , ) <EOL> @ staticmethod <EOL> def action_present ( count ) : <EOL> return ungettext_lazy ( <EOL> u"<STR_LIT>" , <EOL> u"<STR_LIT>" , <EOL> count <EOL> ) <EOL> @ staticmethod <EOL> def action_past ( count ) : <EOL> return ungettext_lazy ( <EOL> u"<STR_LIT>" , <EOL> u"<STR_LIT>" , <EOL> count <EOL> ) <EOL> def allowed ( self , request , instance ) : <EOL> if not api . nova . extension_supported ( '<STR_LIT>' , request ) : <EOL> return False <EOL> return True <EOL> def action ( self , request , obj_id ) : <EOL> api . nova . server_lock ( request , obj_id ) <EOL> class UnlockInstance ( policy . PolicyTargetMixin , tables . BatchAction ) : <EOL> name = "<STR_LIT>" <EOL> policy_rules = ( ( "<STR_LIT>" , "<STR_LIT>" ) , ) <EOL> @ staticmethod <EOL> def action_present ( count ) : <EOL> return ungettext_lazy ( <EOL> u"<STR_LIT>" , <EOL> u"<STR_LIT>" , <EOL> count <EOL> ) <EOL> @ staticmethod <EOL> def action_past ( count ) : <EOL> return ungettext_lazy ( <EOL> u"<STR_LIT>" , <EOL> u"<STR_LIT>" , <EOL> count <EOL> ) <EOL> def allowed ( self , request , instance ) : <EOL> if not api . nova . extension_supported ( '<STR_LIT>' , request ) : <EOL> return False <EOL> return True <EOL> def action ( self , request , obj_id ) : <EOL> api . nova . server_unlock ( request , obj_id ) <EOL> def get_ips ( instance ) : <EOL> template_name = '<STR_LIT>' <EOL> context = { "<STR_LIT>" : instance } <EOL> return template . loader . render_to_string ( template_name , context ) <EOL> def get_size ( instance ) : <EOL> if hasattr ( instance , "<STR_LIT>" ) : <EOL> template_name = '<STR_LIT>' <EOL> size_ram = sizeformat . mb_float_format ( instance . full_flavor . ram ) <EOL> if instance . full_flavor . disk > <NUM_LIT:0> : <EOL> size_disk = sizeformat . diskgbformat ( instance . full_flavor . disk ) <EOL> else : <EOL> size_disk = _ ( "<STR_LIT>" ) % "<STR_LIT:0>" <EOL> context = { <EOL> "<STR_LIT:name>" : instance . full_flavor . name , <EOL> "<STR_LIT:id>" : instance . id , <EOL> "<STR_LIT>" : size_disk , <EOL> "<STR_LIT>" : size_ram , <EOL> "<STR_LIT>" : instance . full_flavor . vcpus <EOL> } <EOL> return template . loader . render_to_string ( template_name , context ) <EOL> return _ ( "<STR_LIT>" ) <EOL> def get_keyname ( instance ) : <EOL> if hasattr ( instance , "<STR_LIT>" ) : <EOL> keyname = instance . key_name <EOL> return keyname <EOL> return _ ( "<STR_LIT>" ) <EOL> def get_power_state ( instance ) : <EOL> return POWER_STATES . get ( getattr ( instance , "<STR_LIT>" , <NUM_LIT:0> ) , '<STR_LIT>' ) <EOL> STATUS_DISPLAY_CHOICES = ( <EOL> ( "<STR_LIT>" , pgettext_lazy ( "<STR_LIT>" , u"<STR_LIT>" ) ) , <EOL> ( "<STR_LIT>" , pgettext_lazy ( "<STR_LIT>" , u"<STR_LIT>" ) ) , <EOL> ( "<STR_LIT>" , pgettext_lazy ( "<STR_LIT>" , u"<STR_LIT>" ) ) , <EOL> ( "<STR_LIT>" , pgettext_lazy ( "<STR_LIT>" , <EOL> u"<STR_LIT>" ) ) , <EOL> ( "<STR_LIT>" , pgettext_lazy ( "<STR_LIT>" , u"<STR_LIT>" ) ) , <EOL> ( "<STR_LIT:error>" , pgettext_lazy ( "<STR_LIT>" , u"<STR_LIT>" ) ) , <EOL> ( "<STR_LIT>" , pgettext_lazy ( "<STR_LIT>" , <EOL> u"<STR_LIT>" ) ) , <EOL> ( "<STR_LIT>" , pgettext_lazy ( "<STR_LIT>" , <EOL> u"<STR_LIT>" ) ) , <EOL> ( "<STR_LIT>" , pgettext_lazy ( <EOL> "<STR_LIT>" , u"<STR_LIT>" ) ) , <EOL> ( "<STR_LIT>" , pgettext_lazy ( "<STR_LIT>" , u"<STR_LIT>" ) ) , <EOL> ( "<STR_LIT>" , pgettext_lazy ( "<STR_LIT>" , <EOL> u"<STR_LIT>" ) ) , <EOL> ( "<STR_LIT:password>" , pgettext_lazy ( "<STR_LIT>" , u"<STR_LIT>" ) ) , <EOL> ( "<STR_LIT>" , pgettext_lazy ( "<STR_LIT>" , u"<STR_LIT>" ) ) , <EOL> ( "<STR_LIT>" , pgettext_lazy ( "<STR_LIT>" , <EOL> u"<STR_LIT>" ) ) , <EOL> ( "<STR_LIT>" , pgettext_lazy ( "<STR_LIT>" , u"<STR_LIT>" ) ) , <EOL> ( "<STR_LIT>" , pgettext_lazy ( "<STR_LIT>" , u"<STR_LIT>" ) ) , <EOL> ( "<STR_LIT>" , pgettext_lazy ( "<STR_LIT>" , u"<STR_LIT>" ) ) , <EOL> ( "<STR_LIT>" , pgettext_lazy ( "<STR_LIT>" , <EOL> u"<STR_LIT>" ) ) , <EOL> ( "<STR_LIT>" , pgettext_lazy ( "<STR_LIT>" , u"<STR_LIT>" ) ) , <EOL> ( "<STR_LIT>" , pgettext_lazy ( "<STR_LIT>" , <EOL> u"<STR_LIT>" ) ) , <EOL> ) <EOL> TASK_DISPLAY_NONE = pgettext_lazy ( "<STR_LIT>" , u"<STR_LIT:None>" ) <EOL> TASK_DISPLAY_CHOICES = ( <EOL> ( "<STR_LIT>" , pgettext_lazy ( "<STR_LIT>" , <EOL> u"<STR_LIT>" ) ) , <EOL> ( "<STR_LIT>" , pgettext_lazy ( "<STR_LIT>" , <EOL> u"<STR_LIT>" ) ) , <EOL> ( "<STR_LIT>" , pgettext_lazy ( "<STR_LIT>" , <EOL> u"<STR_LIT>" ) ) , <EOL> ( "<STR_LIT>" , pgettext_lazy ( "<STR_LIT>" , u"<STR_LIT>" ) ) , <EOL> ( "<STR_LIT>" , pgettext_lazy ( "<STR_LIT>" , <EOL> u"<STR_LIT>" ) ) , <EOL> ( "<STR_LIT>" , pgettext_lazy ( "<STR_LIT>" , <EOL> u"<STR_LIT>" ) ) , <EOL> ( "<STR_LIT>" , pgettext_lazy ( "<STR_LIT>" , <EOL> u"<STR_LIT>" ) ) , <EOL> ( "<STR_LIT>" , pgettext_lazy ( "<STR_LIT>" , <EOL> u"<STR_LIT>" ) ) , <EOL> ( "<STR_LIT>" , pgettext_lazy ( "<STR_LIT>" , <EOL> u"<STR_LIT>" ) ) , <EOL> ( "<STR_LIT>" , pgettext_lazy ( "<STR_LIT>" , <EOL> u"<STR_LIT>" ) ) , <EOL> ( "<STR_LIT>" , pgettext_lazy ( "<STR_LIT>" , <EOL> u"<STR_LIT>" ) ) , <EOL> ( "<STR_LIT>" , pgettext_lazy ( "<STR_LIT>" , <EOL> u"<STR_LIT>" ) ) , <EOL> ( "<STR_LIT>" , pgettext_lazy ( "<STR_LIT>" , <EOL> u"<STR_LIT>" ) ) , <EOL> ( "<STR_LIT>" , pgettext_lazy ( "<STR_LIT>" , <EOL> u"<STR_LIT>" ) ) , <EOL> ( "<STR_LIT>" , pgettext_lazy ( "<STR_LIT>" , <EOL> u"<STR_LIT>" ) ) , <EOL> ( "<STR_LIT>" , pgettext_lazy ( "<STR_LIT>" , <EOL> u"<STR_LIT>" ) ) , <EOL> ( "<STR_LIT>" , pgettext_lazy ( "<STR_LIT>" , u"<STR_LIT>" ) ) , <EOL> ( "<STR_LIT>" , pgettext_lazy ( "<STR_LIT>" , <EOL> u"<STR_LIT>" ) ) , <EOL> ( "<STR_LIT>" , pgettext_lazy ( "<STR_LIT>" , <EOL> u"<STR_LIT>" ) ) , <EOL> ( "<STR_LIT>" , pgettext_lazy ( "<STR_LIT>" , <EOL> u"<STR_LIT>" ) ) , <EOL> ( "<STR_LIT>" , pgettext_lazy ( "<STR_LIT>" , <EOL> u"<STR_LIT>" ) ) , <EOL> ( "<STR_LIT>" , pgettext_lazy ( "<STR_LIT>" , <EOL> u"<STR_LIT>" ) ) , <EOL> ( "<STR_LIT>" , pgettext_lazy ( "<STR_LIT>" , u"<STR_LIT>" ) ) , <EOL> ( "<STR_LIT>" , pgettext_lazy ( "<STR_LIT>" , u"<STR_LIT>" ) ) , <EOL> ( "<STR_LIT>" , pgettext_lazy ( "<STR_LIT>" , <EOL> u"<STR_LIT>" ) ) , <EOL> ( "<STR_LIT>" , pgettext_lazy ( "<STR_LIT>" , u"<STR_LIT>" ) ) , <EOL> ( "<STR_LIT>" , pgettext_lazy ( "<STR_LIT>" , <EOL> u"<STR_LIT>" ) ) , <EOL> ( "<STR_LIT>" , pgettext_lazy ( "<STR_LIT>" , <EOL> u"<STR_LIT>" ) ) , <EOL> ( "<STR_LIT>" , pgettext_lazy ( "<STR_LIT>" , u"<STR_LIT>" ) ) , <EOL> ( "<STR_LIT>" , pgettext_lazy ( "<STR_LIT>" , <EOL> u"<STR_LIT>" ) ) , <EOL> ( "<STR_LIT>" , pgettext_lazy ( "<STR_LIT>" , <EOL> u"<STR_LIT>" ) ) , <EOL> ( "<STR_LIT>" , pgettext_lazy ( <EOL> "<STR_LIT>" , u"<STR_LIT>" ) ) , <EOL> ( "<STR_LIT>" , pgettext_lazy ( "<STR_LIT>" , <EOL> u"<STR_LIT>" ) ) , <EOL> ( "<STR_LIT>" , pgettext_lazy ( "<STR_LIT>" , u"<STR_LIT>" ) ) , <EOL> ( "<STR_LIT>" , pgettext_lazy ( "<STR_LIT>" , u"<STR_LIT>" ) ) , <EOL> ( "<STR_LIT>" , pgettext_lazy ( "<STR_LIT>" , <EOL> u"<STR_LIT>" ) ) , <EOL> ( "<STR_LIT>" , pgettext_lazy ( "<STR_LIT>" , u"<STR_LIT>" ) ) , <EOL> ( "<STR_LIT>" , pgettext_lazy ( "<STR_LIT>" , u"<STR_LIT>" ) ) , <EOL> ( "<STR_LIT>" , pgettext_lazy ( <EOL> "<STR_LIT>" , u"<STR_LIT>" ) ) , <EOL> ( "<STR_LIT>" , pgettext_lazy ( "<STR_LIT>" , <EOL> u"<STR_LIT>" ) ) , <EOL> ( "<STR_LIT>" , pgettext_lazy ( "<STR_LIT>" , <EOL> u"<STR_LIT>" ) ) , <EOL> ( "<STR_LIT>" , pgettext_lazy ( "<STR_LIT>" , <EOL> u"<STR_LIT>" ) ) , <EOL> ) <EOL> POWER_DISPLAY_CHOICES = ( <EOL> ( "<STR_LIT>" , pgettext_lazy ( "<STR_LIT>" , u"<STR_LIT>" ) ) , <EOL> ( "<STR_LIT>" , pgettext_lazy ( "<STR_LIT>" , u"<STR_LIT>" ) ) , <EOL> ( "<STR_LIT>" , pgettext_lazy ( "<STR_LIT>" , u"<STR_LIT>" ) ) , <EOL> ( "<STR_LIT>" , pgettext_lazy ( "<STR_LIT>" , u"<STR_LIT>" ) ) , <EOL> ( "<STR_LIT>" , pgettext_lazy ( "<STR_LIT>" , u"<STR_LIT>" ) ) , <EOL> ( "<STR_LIT>" , pgettext_lazy ( "<STR_LIT>" , u"<STR_LIT>" ) ) , <EOL> ( "<STR_LIT>" , pgettext_lazy ( "<STR_LIT>" , u"<STR_LIT>" ) ) , <EOL> ( "<STR_LIT>" , pgettext_lazy ( "<STR_LIT>" , u"<STR_LIT>" ) ) , <EOL> ( "<STR_LIT>" , pgettext_lazy ( "<STR_LIT>" , u"<STR_LIT>" ) ) , <EOL> ( "<STR_LIT>" , pgettext_lazy ( "<STR_LIT>" , u"<STR_LIT>" ) ) , <EOL> ) <EOL> class InstancesFilterAction ( tables . FilterAction ) : <EOL> filter_type = "<STR_LIT>" <EOL> filter_choices = ( ( '<STR_LIT:name>' , _ ( "<STR_LIT>" ) , True ) , <EOL> ( '<STR_LIT:status>' , _ ( "<STR_LIT>" ) , True ) , <EOL> ( '<STR_LIT:image>' , _ ( "<STR_LIT>" ) , True ) , <EOL> ( '<STR_LIT>' , _ ( "<STR_LIT>" ) , True ) ) <EOL> class InstancesTable ( tables . DataTable ) : <EOL> TASK_STATUS_CHOICES = ( <EOL> ( None , True ) , <EOL> ( "<STR_LIT:none>" , True ) <EOL> ) <EOL> STATUS_CHOICES = ( <EOL> ( "<STR_LIT>" , True ) , <EOL> ( "<STR_LIT>" , True ) , <EOL> ( "<STR_LIT>" , True ) , <EOL> ( "<STR_LIT>" , True ) , <EOL> ( "<STR_LIT:error>" , False ) , <EOL> ( "<STR_LIT>" , True ) , <EOL> ( "<STR_LIT>" , True ) , <EOL> ) <EOL> name = tables . Column ( "<STR_LIT:name>" , <EOL> link = ( "<STR_LIT>" ) , <EOL> verbose_name = _ ( "<STR_LIT>" ) ) <EOL> image_name = tables . Column ( "<STR_LIT>" , <EOL> verbose_name = _ ( "<STR_LIT>" ) ) <EOL> ip = tables . Column ( get_ips , <EOL> verbose_name = _ ( "<STR_LIT>" ) , <EOL> attrs = { '<STR_LIT>' : "<STR_LIT>" } ) <EOL> size = tables . Column ( get_size , <EOL> verbose_name = _ ( "<STR_LIT>" ) , <EOL> attrs = { '<STR_LIT>' : '<STR_LIT:size>' } ) <EOL> keypair = tables . Column ( get_keyname , verbose_name = _ ( "<STR_LIT>" ) ) <EOL> status = tables . Column ( "<STR_LIT:status>" , <EOL> filters = ( title , filters . replace_underscores ) , <EOL> verbose_name = _ ( "<STR_LIT>" ) , <EOL> status = True , <EOL> status_choices = STATUS_CHOICES , <EOL> display_choices = STATUS_DISPLAY_CHOICES ) <EOL> az = tables . Column ( "<STR_LIT>" , <EOL> verbose_name = _ ( "<STR_LIT>" ) ) <EOL> task = tables . Column ( "<STR_LIT>" , <EOL> verbose_name = _ ( "<STR_LIT>" ) , <EOL> empty_value = TASK_DISPLAY_NONE , <EOL> status = True , <EOL> status_choices = TASK_STATUS_CHOICES , <EOL> display_choices = TASK_DISPLAY_CHOICES ) <EOL> state = tables . Column ( get_power_state , <EOL> filters = ( title , filters . replace_underscores ) , <EOL> verbose_name = _ ( "<STR_LIT>" ) , <EOL> display_choices = POWER_DISPLAY_CHOICES ) <EOL> created = tables . Column ( "<STR_LIT>" , <EOL> verbose_name = _ ( "<STR_LIT>" ) , <EOL> filters = ( filters . parse_isotime , <EOL> filters . timesince_sortable ) , <EOL> attrs = { '<STR_LIT>' : '<STR_LIT>' } ) <EOL> class Meta : <EOL> name = "<STR_LIT>" <EOL> verbose_name = _ ( "<STR_LIT>" ) <EOL> status_columns = [ "<STR_LIT:status>" , "<STR_LIT>" ] <EOL> row_class = UpdateRow <EOL> table_actions_menu = ( StartInstance , StopInstance , SoftRebootInstance ) <EOL> table_actions = ( LaunchLink , TerminateInstance , InstancesFilterAction ) <EOL> row_actions = ( StartInstance , ConfirmResize , RevertResize , <EOL> CreateSnapshot , SimpleAssociateIP , AssociateIP , <EOL> SimpleDisassociateIP , EditInstance , <EOL> DecryptInstancePassword , EditInstanceSecurityGroups , <EOL> ConsoleLink , LogLink , TogglePause , ToggleSuspend , <EOL> ResizeLink , LockInstance , UnlockInstance , <EOL> SoftRebootInstance , RebootInstance , <EOL> StopInstance , RebuildInstance , TerminateInstance ) </s>

<s> import logging <EOL> from django . core . urlresolvers import reverse <EOL> from django . utils . translation import ugettext_lazy as _ <EOL> from horizon import exceptions <EOL> from horizon import forms <EOL> from horizon import messages <EOL> from openstack_dashboard import api <EOL> LOG = logging . getLogger ( __name__ ) <EOL> class UpdatePort ( forms . SelfHandlingForm ) : <EOL> network_id = forms . CharField ( widget = forms . HiddenInput ( ) ) <EOL> port_id = forms . CharField ( widget = forms . HiddenInput ( ) ) <EOL> name = forms . CharField ( max_length = <NUM_LIT:255> , <EOL> label = _ ( "<STR_LIT:Name>" ) , <EOL> required = False ) <EOL> admin_state = forms . ChoiceField ( choices = [ ( True , _ ( '<STR_LIT>' ) ) , <EOL> ( False , _ ( '<STR_LIT>' ) ) ] , <EOL> label = _ ( "<STR_LIT>" ) ) <EOL> failure_url = '<STR_LIT>' <EOL> def __init__ ( self , request , * args , ** kwargs ) : <EOL> super ( UpdatePort , self ) . __init__ ( request , * args , ** kwargs ) <EOL> if api . neutron . is_extension_supported ( request , '<STR_LIT>' ) : <EOL> self . fields [ '<STR_LIT>' ] = forms . BooleanField ( <EOL> label = _ ( "<STR_LIT>" ) , required = False ) <EOL> def handle ( self , request , data ) : <EOL> data [ '<STR_LIT>' ] = ( data [ '<STR_LIT>' ] == '<STR_LIT:True>' ) <EOL> try : <EOL> LOG . debug ( '<STR_LIT>' % data ) <EOL> extension_kwargs = { } <EOL> if '<STR_LIT>' in data : <EOL> extension_kwargs [ '<STR_LIT>' ] = data [ '<STR_LIT>' ] <EOL> port = api . neutron . port_update ( request , data [ '<STR_LIT>' ] , <EOL> name = data [ '<STR_LIT:name>' ] , <EOL> admin_state_up = data [ '<STR_LIT>' ] , <EOL> ** extension_kwargs ) <EOL> msg = _ ( '<STR_LIT>' ) % data [ '<STR_LIT>' ] <EOL> LOG . debug ( msg ) <EOL> messages . success ( request , msg ) <EOL> return port <EOL> except Exception : <EOL> msg = _ ( '<STR_LIT>' ) % data [ '<STR_LIT>' ] <EOL> LOG . info ( msg ) <EOL> redirect = reverse ( self . failure_url , <EOL> args = [ data [ '<STR_LIT>' ] ] ) <EOL> exceptions . handle ( request , msg , redirect = redirect ) </s>

<s> import logging <EOL> from django . core . urlresolvers import reverse <EOL> from django . utils . translation import ugettext_lazy as _ <EOL> from horizon import exceptions <EOL> from horizon import forms <EOL> from horizon import messages <EOL> from openstack_dashboard import api <EOL> LOG = logging . getLogger ( __name__ ) <EOL> class AddInterface ( forms . SelfHandlingForm ) : <EOL> subnet_id = forms . ChoiceField ( label = _ ( "<STR_LIT>" ) ) <EOL> ip_address = forms . IPField ( <EOL> label = _ ( "<STR_LIT>" ) , required = False , initial = "<STR_LIT>" , <EOL> help_text = _ ( "<STR_LIT>" <EOL> "<STR_LIT>" ) , <EOL> version = forms . IPv4 | forms . IPv6 , mask = False ) <EOL> router_name = forms . CharField ( label = _ ( "<STR_LIT>" ) , <EOL> widget = forms . TextInput ( <EOL> attrs = { '<STR_LIT>' : '<STR_LIT>' } ) ) <EOL> router_id = forms . CharField ( label = _ ( "<STR_LIT>" ) , <EOL> widget = forms . TextInput ( <EOL> attrs = { '<STR_LIT>' : '<STR_LIT>' } ) ) <EOL> failure_url = '<STR_LIT>' <EOL> def __init__ ( self , request , * args , ** kwargs ) : <EOL> super ( AddInterface , self ) . __init__ ( request , * args , ** kwargs ) <EOL> c = self . populate_subnet_id_choices ( request ) <EOL> self . fields [ '<STR_LIT>' ] . choices = c <EOL> def populate_subnet_id_choices ( self , request ) : <EOL> tenant_id = self . request . user . tenant_id <EOL> networks = [ ] <EOL> try : <EOL> networks = api . neutron . network_list_for_tenant ( request , tenant_id ) <EOL> except Exception as e : <EOL> msg = _ ( '<STR_LIT>' ) % e <EOL> LOG . info ( msg ) <EOL> messages . error ( request , msg ) <EOL> router_id = request . REQUEST . get ( '<STR_LIT>' , <EOL> self . initial . get ( '<STR_LIT>' ) ) <EOL> if router_id : <EOL> redirect = reverse ( self . failure_url , args = [ router_id ] ) <EOL> else : <EOL> redirect = reverse ( '<STR_LIT>' ) <EOL> exceptions . handle ( request , msg , redirect = redirect ) <EOL> return <EOL> choices = [ ] <EOL> for n in networks : <EOL> net_name = n . name + '<STR_LIT>' if n . name else '<STR_LIT>' <EOL> choices += [ ( subnet . id , <EOL> '<STR_LIT>' % ( net_name , subnet . cidr , <EOL> subnet . name or subnet . id ) ) <EOL> for subnet in n [ '<STR_LIT>' ] ] <EOL> if choices : <EOL> choices . insert ( <NUM_LIT:0> , ( "<STR_LIT>" , _ ( "<STR_LIT>" ) ) ) <EOL> else : <EOL> choices . insert ( <NUM_LIT:0> , ( "<STR_LIT>" , _ ( "<STR_LIT>" ) ) ) <EOL> return choices <EOL> def handle ( self , request , data ) : <EOL> if data [ '<STR_LIT>' ] : <EOL> port = self . _add_interface_by_port ( request , data ) <EOL> else : <EOL> port = self . _add_interface_by_subnet ( request , data ) <EOL> msg = _ ( '<STR_LIT>' ) <EOL> if port : <EOL> msg += '<STR_LIT:U+0020>' + port . fixed_ips [ <NUM_LIT:0> ] [ '<STR_LIT>' ] <EOL> LOG . debug ( msg ) <EOL> messages . success ( request , msg ) <EOL> return True <EOL> def _add_interface_by_subnet ( self , request , data ) : <EOL> router_id = data [ '<STR_LIT>' ] <EOL> try : <EOL> router_inf = api . neutron . router_add_interface ( <EOL> request , router_id , subnet_id = data [ '<STR_LIT>' ] ) <EOL> except Exception as e : <EOL> self . _handle_error ( request , router_id , e ) <EOL> try : <EOL> port = api . neutron . port_get ( request , router_inf [ '<STR_LIT>' ] ) <EOL> except Exception : <EOL> port = None <EOL> return port <EOL> def _add_interface_by_port ( self , request , data ) : <EOL> router_id = data [ '<STR_LIT>' ] <EOL> subnet_id = data [ '<STR_LIT>' ] <EOL> try : <EOL> subnet = api . neutron . subnet_get ( request , subnet_id ) <EOL> except Exception : <EOL> msg = _ ( '<STR_LIT>' ) % subnet_id <EOL> self . _handle_error ( request , router_id , msg ) <EOL> try : <EOL> ip_address = data [ '<STR_LIT>' ] <EOL> body = { '<STR_LIT>' : subnet . network_id , <EOL> '<STR_LIT>' : [ { '<STR_LIT>' : subnet . id , <EOL> '<STR_LIT>' : ip_address } ] } <EOL> port = api . neutron . port_create ( request , ** body ) <EOL> except Exception as e : <EOL> self . _handle_error ( request , router_id , e ) <EOL> try : <EOL> api . neutron . router_add_interface ( request , router_id , <EOL> port_id = port . id ) <EOL> except Exception as e : <EOL> self . _delete_port ( request , port ) <EOL> self . _handle_error ( request , router_id , e ) <EOL> return port <EOL> def _handle_error ( self , request , router_id , reason ) : <EOL> msg = _ ( '<STR_LIT>' ) % reason <EOL> LOG . info ( msg ) <EOL> redirect = reverse ( self . failure_url , args = [ router_id ] ) <EOL> exceptions . handle ( request , msg , redirect = redirect ) <EOL> def _delete_port ( self , request , port ) : <EOL> try : <EOL> api . neutron . port_delete ( request , port . id ) <EOL> except Exception : <EOL> msg = _ ( '<STR_LIT>' ) % port . id <EOL> LOG . info ( msg ) <EOL> exceptions . handle ( request , msg ) <EOL> class SetGatewayForm ( forms . SelfHandlingForm ) : <EOL> network_id = forms . ChoiceField ( label = _ ( "<STR_LIT>" ) ) <EOL> router_name = forms . CharField ( label = _ ( "<STR_LIT>" ) , <EOL> widget = forms . TextInput ( <EOL> attrs = { '<STR_LIT>' : '<STR_LIT>' } ) ) <EOL> router_id = forms . CharField ( label = _ ( "<STR_LIT>" ) , <EOL> widget = forms . TextInput ( <EOL> attrs = { '<STR_LIT>' : '<STR_LIT>' } ) ) <EOL> failure_url = '<STR_LIT>' <EOL> def __init__ ( self , request , * args , ** kwargs ) : <EOL> super ( SetGatewayForm , self ) . __init__ ( request , * args , ** kwargs ) <EOL> c = self . populate_network_id_choices ( request ) <EOL> self . fields [ '<STR_LIT>' ] . choices = c <EOL> def populate_network_id_choices ( self , request ) : <EOL> search_opts = { '<STR_LIT>' : True } <EOL> try : <EOL> networks = api . neutron . network_list ( request , ** search_opts ) <EOL> except Exception as e : <EOL> msg = _ ( '<STR_LIT>' ) % e <EOL> LOG . info ( msg ) <EOL> messages . error ( request , msg ) <EOL> redirect = reverse ( self . failure_url ) <EOL> exceptions . handle ( request , msg , redirect = redirect ) <EOL> return <EOL> choices = [ ( network . id , network . name or network . id ) <EOL> for network in networks ] <EOL> if choices : <EOL> choices . insert ( <NUM_LIT:0> , ( "<STR_LIT>" , _ ( "<STR_LIT>" ) ) ) <EOL> else : <EOL> choices . insert ( <NUM_LIT:0> , ( "<STR_LIT>" , _ ( "<STR_LIT>" ) ) ) <EOL> return choices <EOL> def handle ( self , request , data ) : <EOL> try : <EOL> api . neutron . router_add_gateway ( request , <EOL> data [ '<STR_LIT>' ] , <EOL> data [ '<STR_LIT>' ] ) <EOL> msg = _ ( '<STR_LIT>' ) <EOL> LOG . debug ( msg ) <EOL> messages . success ( request , msg ) <EOL> return True <EOL> except Exception as e : <EOL> msg = _ ( '<STR_LIT>' ) % e <EOL> LOG . info ( msg ) <EOL> redirect = reverse ( self . failure_url ) <EOL> exceptions . handle ( request , msg , redirect = redirect ) </s>

<s> from django . core . urlresolvers import reverse <EOL> from django . utils . translation import ugettext_lazy as _ <EOL> from horizon import exceptions <EOL> from horizon import forms <EOL> from horizon import messages <EOL> from openstack_dashboard . api import cinder <EOL> class UpdateForm ( forms . SelfHandlingForm ) : <EOL> name = forms . CharField ( max_length = <NUM_LIT:255> , label = _ ( "<STR_LIT>" ) ) <EOL> description = forms . CharField ( max_length = <NUM_LIT:255> , <EOL> widget = forms . Textarea ( attrs = { '<STR_LIT>' : <NUM_LIT:4> } ) , <EOL> label = _ ( "<STR_LIT>" ) , <EOL> required = False ) <EOL> def handle ( self , request , data ) : <EOL> snapshot_id = self . initial [ '<STR_LIT>' ] <EOL> try : <EOL> cinder . volume_snapshot_update ( request , <EOL> snapshot_id , <EOL> data [ '<STR_LIT:name>' ] , <EOL> data [ '<STR_LIT:description>' ] ) <EOL> message = _ ( '<STR_LIT>' ) % data [ '<STR_LIT:name>' ] <EOL> messages . info ( request , message ) <EOL> return True <EOL> except Exception : <EOL> redirect = reverse ( "<STR_LIT>" ) <EOL> exceptions . handle ( request , <EOL> _ ( '<STR_LIT>' ) , <EOL> redirect = redirect ) </s>

<s> from django . utils . translation import ugettext_lazy as _ <EOL> from horizon import tabs <EOL> class NetworkProfileTab ( tabs . Tab ) : <EOL> name = _ ( "<STR_LIT>" ) <EOL> slug = "<STR_LIT>" <EOL> template_name = '<STR_LIT>' <EOL> def get_context_data ( self , request ) : <EOL> return None <EOL> class PolicyProfileTab ( tabs . Tab ) : <EOL> name = _ ( "<STR_LIT>" ) <EOL> slug = "<STR_LIT>" <EOL> template_name = '<STR_LIT>' <EOL> preload = False <EOL> class IndexTabs ( tabs . TabGroup ) : <EOL> slug = "<STR_LIT>" <EOL> tabs = ( NetworkProfileTab , PolicyProfileTab ) </s>

<s> """<STR_LIT>""" <EOL> import abc <EOL> import ast <EOL> import os <EOL> import re <EOL> from oslo . config import cfg <EOL> from oslo . serialization import jsonutils <EOL> import six <EOL> import six . moves . urllib . parse as urlparse <EOL> import six . moves . urllib . request as urlrequest <EOL> from openstack_dashboard . openstack . common import fileutils <EOL> from openstack_dashboard . openstack . common . _i18n import _ , _LE , _LW <EOL> from openstack_dashboard . openstack . common import log as logging <EOL> policy_opts = [ <EOL> cfg . StrOpt ( '<STR_LIT>' , <EOL> default = '<STR_LIT>' , <EOL> help = _ ( '<STR_LIT>' ) ) , <EOL> cfg . StrOpt ( '<STR_LIT>' , <EOL> default = '<STR_LIT:default>' , <EOL> help = _ ( '<STR_LIT>' <EOL> '<STR_LIT>' ) ) , <EOL> cfg . MultiStrOpt ( '<STR_LIT>' , <EOL> default = [ '<STR_LIT>' ] , <EOL> help = _ ( '<STR_LIT>' <EOL> '<STR_LIT>' ) ) , <EOL> ] <EOL> CONF = cfg . CONF <EOL> CONF . register_opts ( policy_opts ) <EOL> LOG = logging . getLogger ( __name__ ) <EOL> _checks = { } <EOL> class PolicyNotAuthorized ( Exception ) : <EOL> def __init__ ( self , rule ) : <EOL> msg = _ ( "<STR_LIT>" ) % rule <EOL> super ( PolicyNotAuthorized , self ) . __init__ ( msg ) <EOL> class Rules ( dict ) : <EOL> """<STR_LIT>""" <EOL> @ classmethod <EOL> def load_json ( cls , data , default_rule = None ) : <EOL> """<STR_LIT>""" <EOL> rules = dict ( ( k , parse_rule ( v ) ) for k , v in <EOL> jsonutils . loads ( data ) . items ( ) ) <EOL> return cls ( rules , default_rule ) <EOL> def __init__ ( self , rules = None , default_rule = None ) : <EOL> """<STR_LIT>""" <EOL> super ( Rules , self ) . __init__ ( rules or { } ) <EOL> self . default_rule = default_rule <EOL> def __missing__ ( self , key ) : <EOL> """<STR_LIT>""" <EOL> if isinstance ( self . default_rule , dict ) : <EOL> raise KeyError ( key ) <EOL> if not self . default_rule : <EOL> raise KeyError ( key ) <EOL> if isinstance ( self . default_rule , BaseCheck ) : <EOL> return self . default_rule <EOL> if self . default_rule not in self : <EOL> raise KeyError ( key ) <EOL> elif isinstance ( self . default_rule , six . string_types ) : <EOL> return self [ self . default_rule ] <EOL> def __str__ ( self ) : <EOL> """<STR_LIT>""" <EOL> out_rules = { } <EOL> for key , value in self . items ( ) : <EOL> if isinstance ( value , TrueCheck ) : <EOL> out_rules [ key ] = '<STR_LIT>' <EOL> else : <EOL> out_rules [ key ] = str ( value ) <EOL> return jsonutils . dumps ( out_rules , indent = <NUM_LIT:4> ) <EOL> class Enforcer ( object ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , policy_file = None , rules = None , <EOL> default_rule = None , use_conf = True ) : <EOL> self . rules = Rules ( rules , default_rule ) <EOL> self . default_rule = default_rule or CONF . policy_default_rule <EOL> self . policy_path = None <EOL> self . policy_file = policy_file or CONF . policy_file <EOL> self . use_conf = use_conf <EOL> def set_rules ( self , rules , overwrite = True , use_conf = False ) : <EOL> """<STR_LIT>""" <EOL> if not isinstance ( rules , dict ) : <EOL> raise TypeError ( _ ( "<STR_LIT>" <EOL> "<STR_LIT>" ) % type ( rules ) ) <EOL> self . use_conf = use_conf <EOL> if overwrite : <EOL> self . rules = Rules ( rules , self . default_rule ) <EOL> else : <EOL> self . rules . update ( rules ) <EOL> def clear ( self ) : <EOL> """<STR_LIT>""" <EOL> self . set_rules ( { } ) <EOL> fileutils . delete_cached_file ( self . policy_path ) <EOL> self . default_rule = None <EOL> self . policy_path = None <EOL> def load_rules ( self , force_reload = False ) : <EOL> """<STR_LIT>""" <EOL> if force_reload : <EOL> self . use_conf = force_reload <EOL> if self . use_conf : <EOL> if not self . policy_path : <EOL> self . policy_path = self . _get_policy_path ( self . policy_file ) <EOL> self . _load_policy_file ( self . policy_path , force_reload ) <EOL> for path in CONF . policy_dirs : <EOL> try : <EOL> path = self . _get_policy_path ( path ) <EOL> except cfg . ConfigFilesNotFoundError : <EOL> LOG . warn ( _LW ( "<STR_LIT>" ) , path ) <EOL> continue <EOL> self . _walk_through_policy_directory ( path , <EOL> self . _load_policy_file , <EOL> force_reload , False ) <EOL> def _walk_through_policy_directory ( self , path , func , * args ) : <EOL> policy_files = next ( os . walk ( path ) ) [ <NUM_LIT:2> ] <EOL> policy_files . sort ( ) <EOL> for policy_file in [ p for p in policy_files if not p . startswith ( '<STR_LIT:.>' ) ] : <EOL> func ( os . path . join ( path , policy_file ) , * args ) <EOL> def _load_policy_file ( self , path , force_reload , overwrite = True ) : <EOL> reloaded , data = fileutils . read_cached_file ( <EOL> path , force_reload = force_reload ) <EOL> if reloaded or not self . rules : <EOL> rules = Rules . load_json ( data , self . default_rule ) <EOL> self . set_rules ( rules , overwrite ) <EOL> LOG . debug ( "<STR_LIT>" ) <EOL> def _get_policy_path ( self , path ) : <EOL> """<STR_LIT>""" <EOL> policy_path = CONF . find_file ( path ) <EOL> if policy_path : <EOL> return policy_path <EOL> raise cfg . ConfigFilesNotFoundError ( ( path , ) ) <EOL> def enforce ( self , rule , target , creds , do_raise = False , <EOL> exc = None , * args , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> self . load_rules ( ) <EOL> if isinstance ( rule , BaseCheck ) : <EOL> result = rule ( target , creds , self ) <EOL> elif not self . rules : <EOL> result = False <EOL> else : <EOL> try : <EOL> result = self . rules [ rule ] ( target , creds , self ) <EOL> except KeyError : <EOL> LOG . debug ( "<STR_LIT>" % rule ) <EOL> result = False <EOL> if do_raise and not result : <EOL> if exc : <EOL> raise exc ( * args , ** kwargs ) <EOL> raise PolicyNotAuthorized ( rule ) <EOL> return result <EOL> @ six . add_metaclass ( abc . ABCMeta ) <EOL> class BaseCheck ( object ) : <EOL> """<STR_LIT>""" <EOL> @ abc . abstractmethod <EOL> def __str__ ( self ) : <EOL> """<STR_LIT>""" <EOL> pass <EOL> @ abc . abstractmethod <EOL> def __call__ ( self , target , cred , enforcer ) : <EOL> """<STR_LIT>""" <EOL> pass <EOL> class FalseCheck ( BaseCheck ) : <EOL> """<STR_LIT>""" <EOL> def __str__ ( self ) : <EOL> """<STR_LIT>""" <EOL> return "<STR_LIT:!>" <EOL> def __call__ ( self , target , cred , enforcer ) : <EOL> """<STR_LIT>""" <EOL> return False <EOL> class TrueCheck ( BaseCheck ) : <EOL> """<STR_LIT>""" <EOL> def __str__ ( self ) : <EOL> """<STR_LIT>""" <EOL> return "<STR_LIT:@>" <EOL> def __call__ ( self , target , cred , enforcer ) : <EOL> """<STR_LIT>""" <EOL> return True <EOL> class Check ( BaseCheck ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , kind , match ) : <EOL> """<STR_LIT>""" <EOL> self . kind = kind <EOL> self . match = match <EOL> def __str__ ( self ) : <EOL> """<STR_LIT>""" <EOL> return "<STR_LIT>" % ( self . kind , self . match ) <EOL> class NotCheck ( BaseCheck ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , rule ) : <EOL> """<STR_LIT>""" <EOL> self . rule = rule <EOL> def __str__ ( self ) : <EOL> """<STR_LIT>""" <EOL> return "<STR_LIT>" % self . rule <EOL> def __call__ ( self , target , cred , enforcer ) : <EOL> """<STR_LIT>""" <EOL> return not self . rule ( target , cred , enforcer ) <EOL> class AndCheck ( BaseCheck ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , rules ) : <EOL> """<STR_LIT>""" <EOL> self . rules = rules <EOL> def __str__ ( self ) : <EOL> """<STR_LIT>""" <EOL> return "<STR_LIT>" % '<STR_LIT>' . join ( str ( r ) for r in self . rules ) <EOL> def __call__ ( self , target , cred , enforcer ) : <EOL> """<STR_LIT>""" <EOL> for rule in self . rules : <EOL> if not rule ( target , cred , enforcer ) : <EOL> return False <EOL> return True <EOL> def add_check ( self , rule ) : <EOL> """<STR_LIT>""" <EOL> self . rules . append ( rule ) <EOL> return self <EOL> class OrCheck ( BaseCheck ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , rules ) : <EOL> """<STR_LIT>""" <EOL> self . rules = rules <EOL> def __str__ ( self ) : <EOL> """<STR_LIT>""" <EOL> return "<STR_LIT>" % '<STR_LIT>' . join ( str ( r ) for r in self . rules ) <EOL> def __call__ ( self , target , cred , enforcer ) : <EOL> """<STR_LIT>""" <EOL> for rule in self . rules : <EOL> if rule ( target , cred , enforcer ) : <EOL> return True <EOL> return False <EOL> def add_check ( self , rule ) : <EOL> """<STR_LIT>""" <EOL> self . rules . append ( rule ) <EOL> return self <EOL> def _parse_check ( rule ) : <EOL> """<STR_LIT>""" <EOL> if rule == '<STR_LIT:!>' : <EOL> return FalseCheck ( ) <EOL> elif rule == '<STR_LIT:@>' : <EOL> return TrueCheck ( ) <EOL> try : <EOL> kind , match = rule . split ( '<STR_LIT::>' , <NUM_LIT:1> ) <EOL> except Exception : <EOL> LOG . exception ( _LE ( "<STR_LIT>" ) % rule ) <EOL> return FalseCheck ( ) <EOL> if kind in _checks : <EOL> return _checks [ kind ] ( kind , match ) <EOL> elif None in _checks : <EOL> return _checks [ None ] ( kind , match ) <EOL> else : <EOL> LOG . error ( _LE ( "<STR_LIT>" ) % kind ) <EOL> return FalseCheck ( ) <EOL> def _parse_list_rule ( rule ) : <EOL> """<STR_LIT>""" <EOL> if not rule : <EOL> return TrueCheck ( ) <EOL> or_list = [ ] <EOL> for inner_rule in rule : <EOL> if not inner_rule : <EOL> continue <EOL> if isinstance ( inner_rule , six . string_types ) : <EOL> inner_rule = [ inner_rule ] <EOL> and_list = [ _parse_check ( r ) for r in inner_rule ] <EOL> if len ( and_list ) == <NUM_LIT:1> : <EOL> or_list . append ( and_list [ <NUM_LIT:0> ] ) <EOL> else : <EOL> or_list . append ( AndCheck ( and_list ) ) <EOL> if not or_list : <EOL> return FalseCheck ( ) <EOL> elif len ( or_list ) == <NUM_LIT:1> : <EOL> return or_list [ <NUM_LIT:0> ] <EOL> return OrCheck ( or_list ) <EOL> _tokenize_re = re . compile ( r'<STR_LIT>' ) <EOL> def _parse_tokenize ( rule ) : <EOL> """<STR_LIT>""" <EOL> for tok in _tokenize_re . split ( rule ) : <EOL> if not tok or tok . isspace ( ) : <EOL> continue <EOL> clean = tok . lstrip ( '<STR_LIT:(>' ) <EOL> for i in range ( len ( tok ) - len ( clean ) ) : <EOL> yield '<STR_LIT:(>' , '<STR_LIT:(>' <EOL> if not clean : <EOL> continue <EOL> else : <EOL> tok = clean <EOL> clean = tok . rstrip ( '<STR_LIT:)>' ) <EOL> trail = len ( tok ) - len ( clean ) <EOL> lowered = clean . lower ( ) <EOL> if lowered in ( '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ) : <EOL> yield lowered , clean <EOL> elif clean : <EOL> if len ( tok ) >= <NUM_LIT:2> and ( ( tok [ <NUM_LIT:0> ] , tok [ - <NUM_LIT:1> ] ) in <EOL> [ ( '<STR_LIT:">' , '<STR_LIT:">' ) , ( "<STR_LIT:'>" , "<STR_LIT:'>" ) ] ) : <EOL> yield '<STR_LIT:string>' , tok [ <NUM_LIT:1> : - <NUM_LIT:1> ] <EOL> else : <EOL> yield '<STR_LIT>' , _parse_check ( clean ) <EOL> for i in range ( trail ) : <EOL> yield '<STR_LIT:)>' , '<STR_LIT:)>' <EOL> class ParseStateMeta ( type ) : <EOL> """<STR_LIT>""" <EOL> def __new__ ( mcs , name , bases , cls_dict ) : <EOL> """<STR_LIT>""" <EOL> reducers = [ ] <EOL> for key , value in cls_dict . items ( ) : <EOL> if not hasattr ( value , '<STR_LIT>' ) : <EOL> continue <EOL> for reduction in value . reducers : <EOL> reducers . append ( ( reduction , key ) ) <EOL> cls_dict [ '<STR_LIT>' ] = reducers <EOL> return super ( ParseStateMeta , mcs ) . __new__ ( mcs , name , bases , cls_dict ) <EOL> def reducer ( * tokens ) : <EOL> """<STR_LIT>""" <EOL> def decorator ( func ) : <EOL> if not hasattr ( func , '<STR_LIT>' ) : <EOL> func . reducers = [ ] <EOL> func . reducers . append ( list ( tokens ) ) <EOL> return func <EOL> return decorator <EOL> @ six . add_metaclass ( ParseStateMeta ) <EOL> class ParseState ( object ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self ) : <EOL> """<STR_LIT>""" <EOL> self . tokens = [ ] <EOL> self . values = [ ] <EOL> def reduce ( self ) : <EOL> """<STR_LIT>""" <EOL> for reduction , methname in self . reducers : <EOL> if ( len ( self . tokens ) >= len ( reduction ) and <EOL> self . tokens [ - len ( reduction ) : ] == reduction ) : <EOL> meth = getattr ( self , methname ) <EOL> results = meth ( * self . values [ - len ( reduction ) : ] ) <EOL> self . tokens [ - len ( reduction ) : ] = [ r [ <NUM_LIT:0> ] for r in results ] <EOL> self . values [ - len ( reduction ) : ] = [ r [ <NUM_LIT:1> ] for r in results ] <EOL> return self . reduce ( ) <EOL> def shift ( self , tok , value ) : <EOL> """<STR_LIT>""" <EOL> self . tokens . append ( tok ) <EOL> self . values . append ( value ) <EOL> self . reduce ( ) <EOL> @ property <EOL> def result ( self ) : <EOL> """<STR_LIT>""" <EOL> if len ( self . values ) != <NUM_LIT:1> : <EOL> raise ValueError ( "<STR_LIT>" ) <EOL> return self . values [ <NUM_LIT:0> ] <EOL> @ reducer ( '<STR_LIT:(>' , '<STR_LIT>' , '<STR_LIT:)>' ) <EOL> @ reducer ( '<STR_LIT:(>' , '<STR_LIT>' , '<STR_LIT:)>' ) <EOL> @ reducer ( '<STR_LIT:(>' , '<STR_LIT>' , '<STR_LIT:)>' ) <EOL> def _wrap_check ( self , _p1 , check , _p2 ) : <EOL> """<STR_LIT>""" <EOL> return [ ( '<STR_LIT>' , check ) ] <EOL> @ reducer ( '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ) <EOL> def _make_and_expr ( self , check1 , _and , check2 ) : <EOL> """<STR_LIT>""" <EOL> return [ ( '<STR_LIT>' , AndCheck ( [ check1 , check2 ] ) ) ] <EOL> @ reducer ( '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ) <EOL> def _extend_and_expr ( self , and_expr , _and , check ) : <EOL> """<STR_LIT>""" <EOL> return [ ( '<STR_LIT>' , and_expr . add_check ( check ) ) ] <EOL> @ reducer ( '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ) <EOL> def _make_or_expr ( self , check1 , _or , check2 ) : <EOL> """<STR_LIT>""" <EOL> return [ ( '<STR_LIT>' , OrCheck ( [ check1 , check2 ] ) ) ] <EOL> @ reducer ( '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ) <EOL> def _extend_or_expr ( self , or_expr , _or , check ) : <EOL> """<STR_LIT>""" <EOL> return [ ( '<STR_LIT>' , or_expr . add_check ( check ) ) ] <EOL> @ reducer ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> def _make_not_expr ( self , _not , check ) : <EOL> """<STR_LIT>""" <EOL> return [ ( '<STR_LIT>' , NotCheck ( check ) ) ] <EOL> def _parse_text_rule ( rule ) : <EOL> """<STR_LIT>""" <EOL> if not rule : <EOL> return TrueCheck ( ) <EOL> state = ParseState ( ) <EOL> for tok , value in _parse_tokenize ( rule ) : <EOL> state . shift ( tok , value ) <EOL> try : <EOL> return state . result <EOL> except ValueError : <EOL> LOG . exception ( _LE ( "<STR_LIT>" ) % rule ) <EOL> return FalseCheck ( ) <EOL> def parse_rule ( rule ) : <EOL> """<STR_LIT>""" <EOL> if isinstance ( rule , six . string_types ) : <EOL> return _parse_text_rule ( rule ) <EOL> return _parse_list_rule ( rule ) <EOL> def register ( name , func = None ) : <EOL> """<STR_LIT>""" <EOL> def decorator ( func ) : <EOL> _checks [ name ] = func <EOL> return func <EOL> if func : <EOL> return decorator ( func ) <EOL> return decorator <EOL> @ register ( "<STR_LIT>" ) <EOL> class RuleCheck ( Check ) : <EOL> def __call__ ( self , target , creds , enforcer ) : <EOL> """<STR_LIT>""" <EOL> try : <EOL> return enforcer . rules [ self . match ] ( target , creds , enforcer ) <EOL> except KeyError : <EOL> return False <EOL> @ register ( "<STR_LIT>" ) <EOL> class RoleCheck ( Check ) : <EOL> def __call__ ( self , target , creds , enforcer ) : <EOL> """<STR_LIT>""" <EOL> return self . match . lower ( ) in [ x . lower ( ) for x in creds [ '<STR_LIT>' ] ] <EOL> @ register ( '<STR_LIT:http>' ) <EOL> class HttpCheck ( Check ) : <EOL> def __call__ ( self , target , creds , enforcer ) : <EOL> """<STR_LIT>""" <EOL> url = ( '<STR_LIT>' + self . match ) % target <EOL> data = { '<STR_LIT:target>' : jsonutils . dumps ( target ) , <EOL> '<STR_LIT>' : jsonutils . dumps ( creds ) } <EOL> post_data = urlparse . urlencode ( data ) <EOL> f = urlrequest . urlopen ( url , post_data ) <EOL> return f . read ( ) == "<STR_LIT:True>" <EOL> @ register ( None ) <EOL> class GenericCheck ( Check ) : <EOL> def __call__ ( self , target , creds , enforcer ) : <EOL> """<STR_LIT>""" <EOL> try : <EOL> match = self . match % target <EOL> except KeyError : <EOL> return False <EOL> try : <EOL> leftval = ast . literal_eval ( self . kind ) <EOL> except ValueError : <EOL> try : <EOL> kind_parts = self . kind . split ( '<STR_LIT:.>' ) <EOL> leftval = creds <EOL> for kind_part in kind_parts : <EOL> leftval = leftval [ kind_part ] <EOL> except KeyError : <EOL> return False <EOL> return match == six . text_type ( leftval ) </s>

<s> from selenium . webdriver . common import by <EOL> from openstack_dashboard . test . integration_tests . pages import basepage <EOL> from openstack_dashboard . test . integration_tests . regions import forms <EOL> from openstack_dashboard . test . integration_tests . regions import tables <EOL> class OverviewPage ( basepage . BaseNavigationPage ) : <EOL> _usage_table_locator = ( by . By . CSS_SELECTOR , '<STR_LIT>' ) <EOL> _date_form_locator = ( by . By . CSS_SELECTOR , '<STR_LIT>' ) <EOL> USAGE_TABLE_ACTIONS = ( "<STR_LIT>" , ) <EOL> def __init__ ( self , driver , conf ) : <EOL> super ( OverviewPage , self ) . __init__ ( driver , conf ) <EOL> self . _page_title = '<STR_LIT>' <EOL> @ property <EOL> def usage_table ( self ) : <EOL> src_elem = self . _get_element ( * self . _usage_table_locator ) <EOL> return tables . ActionsTableRegion ( self . driver , self . conf , src_elem , <EOL> self . USAGE_TABLE_ACTIONS ) <EOL> @ property <EOL> def date_form ( self ) : <EOL> src_elem = self . _get_element ( * self . _date_form_locator ) <EOL> return forms . DateFormRegion ( self . driver , self . conf , src_elem ) </s>

<s> from troveclient . v1 import backups <EOL> from troveclient . v1 import databases <EOL> from troveclient . v1 import datastores <EOL> from troveclient . v1 import flavors <EOL> from troveclient . v1 import instances <EOL> from troveclient . v1 import users <EOL> from openstack_dashboard . test . test_data import utils <EOL> DATABASE_DATA_ONE = { <EOL> "<STR_LIT:status>" : "<STR_LIT>" , <EOL> "<STR_LIT>" : "<STR_LIT>" , <EOL> "<STR_LIT:name>" : "<STR_LIT>" , <EOL> "<STR_LIT>" : [ ] , <EOL> "<STR_LIT>" : "<STR_LIT>" , <EOL> "<STR_LIT>" : [ <EOL> "<STR_LIT>" , <EOL> ] , <EOL> "<STR_LIT>" : { <EOL> "<STR_LIT>" : <NUM_LIT> , <EOL> "<STR_LIT:size>" : <NUM_LIT:1> , <EOL> } , <EOL> "<STR_LIT>" : { <EOL> "<STR_LIT:id>" : "<STR_LIT:1>" , <EOL> "<STR_LIT>" : [ ] , <EOL> } , <EOL> "<STR_LIT>" : { <EOL> "<STR_LIT:type>" : "<STR_LIT>" , <EOL> "<STR_LIT:version>" : "<STR_LIT>" <EOL> } , <EOL> "<STR_LIT:id>" : "<STR_LIT>" , <EOL> } <EOL> DATABASE_DATA_TWO = { <EOL> "<STR_LIT:status>" : "<STR_LIT>" , <EOL> "<STR_LIT>" : "<STR_LIT>" , <EOL> "<STR_LIT:name>" : "<STR_LIT>" , <EOL> "<STR_LIT>" : [ ] , <EOL> "<STR_LIT>" : "<STR_LIT>" , <EOL> "<STR_LIT>" : "<STR_LIT>" , <EOL> "<STR_LIT>" : { <EOL> "<STR_LIT>" : <NUM_LIT> , <EOL> "<STR_LIT:size>" : <NUM_LIT:1> , <EOL> } , <EOL> "<STR_LIT>" : { <EOL> "<STR_LIT:id>" : "<STR_LIT:1>" , <EOL> "<STR_LIT>" : [ ] , <EOL> } , <EOL> "<STR_LIT>" : { <EOL> "<STR_LIT:type>" : "<STR_LIT>" , <EOL> "<STR_LIT:version>" : "<STR_LIT>" <EOL> } , <EOL> "<STR_LIT:id>" : "<STR_LIT>" , <EOL> } <EOL> BACKUP_ONE = { <EOL> "<STR_LIT>" : "<STR_LIT>" , <EOL> "<STR_LIT:status>" : "<STR_LIT>" , <EOL> "<STR_LIT>" : "<STR_LIT>" , <EOL> "<STR_LIT>" : "<STR_LIT>" , <EOL> "<STR_LIT:name>" : "<STR_LIT>" , <EOL> "<STR_LIT>" : "<STR_LIT>" , <EOL> "<STR_LIT:size>" : <NUM_LIT> , <EOL> "<STR_LIT:id>" : "<STR_LIT>" , <EOL> "<STR_LIT:description>" : "<STR_LIT>" , <EOL> } <EOL> BACKUP_TWO = { <EOL> "<STR_LIT>" : "<STR_LIT>" , <EOL> "<STR_LIT:status>" : "<STR_LIT>" , <EOL> "<STR_LIT>" : "<STR_LIT>" , <EOL> "<STR_LIT>" : "<STR_LIT>" , <EOL> "<STR_LIT:name>" : "<STR_LIT>" , <EOL> "<STR_LIT>" : "<STR_LIT>" , <EOL> "<STR_LIT:size>" : <NUM_LIT> , <EOL> "<STR_LIT:id>" : "<STR_LIT>" , <EOL> "<STR_LIT:description>" : "<STR_LIT>" , <EOL> } <EOL> BACKUP_TWO_INC = { <EOL> "<STR_LIT>" : "<STR_LIT>" , <EOL> "<STR_LIT:status>" : "<STR_LIT>" , <EOL> "<STR_LIT>" : "<STR_LIT>" , <EOL> "<STR_LIT>" : "<STR_LIT>" , <EOL> "<STR_LIT:name>" : "<STR_LIT>" , <EOL> "<STR_LIT>" : "<STR_LIT>" , <EOL> "<STR_LIT:size>" : <NUM_LIT> , <EOL> "<STR_LIT:id>" : "<STR_LIT>" , <EOL> "<STR_LIT:description>" : "<STR_LIT>" , <EOL> "<STR_LIT>" : "<STR_LIT>" , <EOL> } <EOL> USER_ONE = { <EOL> "<STR_LIT:name>" : "<STR_LIT>" , <EOL> "<STR_LIT:host>" : "<STR_LIT:%>" , <EOL> "<STR_LIT>" : [ DATABASE_DATA_ONE [ "<STR_LIT:name>" ] ] , <EOL> } <EOL> USER_DB_ONE = { <EOL> "<STR_LIT:name>" : "<STR_LIT>" , <EOL> } <EOL> DATASTORE_ONE = { <EOL> "<STR_LIT:id>" : "<STR_LIT>" , <EOL> "<STR_LIT>" : [ ] , <EOL> "<STR_LIT:name>" : "<STR_LIT>" <EOL> } <EOL> DATASTORE_TWO = { <EOL> "<STR_LIT:id>" : "<STR_LIT>" , <EOL> "<STR_LIT>" : [ ] , <EOL> "<STR_LIT:name>" : "<STR_LIT>" <EOL> } <EOL> VERSION_ONE = { <EOL> "<STR_LIT:name>" : "<STR_LIT>" , <EOL> "<STR_LIT>" : [ ] , <EOL> "<STR_LIT:image>" : "<STR_LIT>" , <EOL> "<STR_LIT>" : <NUM_LIT:1> , <EOL> "<STR_LIT>" : "<STR_LIT>" , <EOL> "<STR_LIT>" : "<STR_LIT>" , <EOL> "<STR_LIT:id>" : "<STR_LIT>" <EOL> } <EOL> VERSION_TWO = { <EOL> "<STR_LIT:name>" : "<STR_LIT>" , <EOL> "<STR_LIT>" : [ ] , <EOL> "<STR_LIT:image>" : "<STR_LIT>" , <EOL> "<STR_LIT>" : <NUM_LIT:1> , <EOL> "<STR_LIT>" : "<STR_LIT>" , <EOL> "<STR_LIT>" : "<STR_LIT>" , <EOL> "<STR_LIT:id>" : "<STR_LIT>" <EOL> } <EOL> FLAVOR_ONE = { <EOL> "<STR_LIT>" : <NUM_LIT> , <EOL> "<STR_LIT:id>" : "<STR_LIT:1>" , <EOL> "<STR_LIT>" : [ ] , <EOL> "<STR_LIT:name>" : "<STR_LIT>" <EOL> } <EOL> FLAVOR_TWO = { <EOL> "<STR_LIT>" : <NUM_LIT> , <EOL> "<STR_LIT:id>" : "<STR_LIT>" , <EOL> "<STR_LIT>" : [ ] , <EOL> "<STR_LIT:name>" : "<STR_LIT>" <EOL> } <EOL> FLAVOR_THREE = { <EOL> "<STR_LIT>" : <NUM_LIT> , <EOL> "<STR_LIT:id>" : "<STR_LIT:100>" , <EOL> "<STR_LIT>" : [ ] , <EOL> "<STR_LIT:name>" : "<STR_LIT>" <EOL> } <EOL> def data ( TEST ) : <EOL> database1 = instances . Instance ( instances . Instances ( None ) , <EOL> DATABASE_DATA_ONE ) <EOL> database2 = instances . Instance ( instances . Instances ( None ) , <EOL> DATABASE_DATA_TWO ) <EOL> bkup1 = backups . Backup ( backups . Backups ( None ) , BACKUP_ONE ) <EOL> bkup2 = backups . Backup ( backups . Backups ( None ) , BACKUP_TWO ) <EOL> bkup3 = backups . Backup ( backups . Backups ( None ) , BACKUP_TWO_INC ) <EOL> user1 = users . User ( users . Users ( None ) , USER_ONE ) <EOL> user_db1 = databases . Database ( databases . Databases ( None ) , <EOL> USER_DB_ONE ) <EOL> datastore1 = datastores . Datastore ( datastores . Datastores ( None ) , <EOL> DATASTORE_ONE ) <EOL> version1 = datastores . DatastoreVersion ( datastores . DatastoreVersions ( None ) , <EOL> VERSION_ONE ) <EOL> version2 = datastores . DatastoreVersion ( datastores . DatastoreVersions ( None ) , <EOL> VERSION_TWO ) <EOL> flavor1 = flavors . Flavor ( flavors . Flavors ( None ) , FLAVOR_ONE ) <EOL> flavor2 = flavors . Flavor ( flavors . Flavors ( None ) , FLAVOR_TWO ) <EOL> flavor3 = flavors . Flavor ( flavors . Flavors ( None ) , FLAVOR_THREE ) <EOL> TEST . databases = utils . TestDataContainer ( ) <EOL> TEST . database_backups = utils . TestDataContainer ( ) <EOL> TEST . database_users = utils . TestDataContainer ( ) <EOL> TEST . database_user_dbs = utils . TestDataContainer ( ) <EOL> TEST . database_flavors = utils . TestDataContainer ( ) <EOL> TEST . databases . add ( database1 ) <EOL> TEST . databases . add ( database2 ) <EOL> TEST . database_backups . add ( bkup1 ) <EOL> TEST . database_backups . add ( bkup2 ) <EOL> TEST . database_backups . add ( bkup3 ) <EOL> TEST . database_users . add ( user1 ) <EOL> TEST . database_user_dbs . add ( user_db1 ) <EOL> TEST . datastores = utils . TestDataContainer ( ) <EOL> TEST . datastores . add ( datastore1 ) <EOL> TEST . datastore_versions = utils . TestDataContainer ( ) <EOL> TEST . datastore_versions . add ( version1 ) <EOL> TEST . datastore_versions . add ( version2 ) <EOL> TEST . database_flavors . add ( flavor1 , flavor2 , flavor3 ) </s>

<s> import setuptools <EOL> try : <EOL> import multiprocessing <EOL> except ImportError : <EOL> pass <EOL> setuptools . setup ( <EOL> setup_requires = [ '<STR_LIT>' ] , <EOL> pbr = True ) </s>

<s> import arcpy , os , shutil <EOL> from arcpy import AddMessage , AddWarning , AddError <EOL> from export import Export <EOL> from esri2open import esri2open <EOL> class Convert ( object ) : <EOL> def __init__ ( self ) : <EOL> self . label = '<STR_LIT>' <EOL> self . description = '<STR_LIT>' <EOL> self . canRunInBackground = False <EOL> def getParameterInfo ( self ) : <EOL> """<STR_LIT>""" <EOL> feature_class = arcpy . Parameter ( <EOL> name = '<STR_LIT>' , <EOL> displayName = '<STR_LIT>' , <EOL> direction = '<STR_LIT>' , <EOL> datatype = '<STR_LIT>' , <EOL> parameterType = '<STR_LIT>' ) <EOL> field_mappings = arcpy . Parameter ( <EOL> name = '<STR_LIT>' , <EOL> displayName = '<STR_LIT>' , <EOL> direction = '<STR_LIT>' , <EOL> datatype = '<STR_LIT>' , <EOL> parameterType = '<STR_LIT>' ) <EOL> field_mappings . parameterDependencies = [ feature_class . name ] <EOL> output_dir = arcpy . Parameter ( <EOL> name = '<STR_LIT>' , <EOL> displayName = '<STR_LIT>' , <EOL> direction = '<STR_LIT>' , <EOL> datatype = '<STR_LIT>' , <EOL> parameterType = '<STR_LIT>' ) <EOL> output_name = arcpy . Parameter ( <EOL> name = '<STR_LIT>' , <EOL> displayName = '<STR_LIT>' , <EOL> direction = '<STR_LIT>' , <EOL> datatype = '<STR_LIT>' , <EOL> parameterType = '<STR_LIT>' ) <EOL> convert_4326 = arcpy . Parameter ( <EOL> name = '<STR_LIT>' , <EOL> displayName = '<STR_LIT>' , <EOL> direction = '<STR_LIT>' , <EOL> datatype = '<STR_LIT>' , <EOL> parameterType = '<STR_LIT>' ) <EOL> convert_4326 . value = '<STR_LIT:True>' <EOL> convert_geojson = arcpy . Parameter ( <EOL> name = '<STR_LIT>' , <EOL> displayName = '<STR_LIT>' , <EOL> direction = '<STR_LIT>' , <EOL> datatype = '<STR_LIT>' , <EOL> parameterType = '<STR_LIT>' ) <EOL> convert_geojson . value = '<STR_LIT:True>' <EOL> convert_kmz = arcpy . Parameter ( <EOL> name = '<STR_LIT>' , <EOL> displayName = '<STR_LIT>' , <EOL> direction = '<STR_LIT>' , <EOL> datatype = '<STR_LIT>' , <EOL> parameterType = '<STR_LIT>' ) <EOL> convert_kmz . value = '<STR_LIT:True>' <EOL> convert_csv = arcpy . Parameter ( <EOL> name = '<STR_LIT>' , <EOL> displayName = '<STR_LIT>' , <EOL> direction = '<STR_LIT>' , <EOL> datatype = '<STR_LIT>' , <EOL> parameterType = '<STR_LIT>' ) <EOL> convert_metadata = arcpy . Parameter ( <EOL> name = '<STR_LIT>' , <EOL> displayName = '<STR_LIT>' , <EOL> direction = '<STR_LIT>' , <EOL> datatype = '<STR_LIT>' , <EOL> parameterType = '<STR_LIT>' ) <EOL> debug = arcpy . Parameter ( <EOL> name = '<STR_LIT>' , <EOL> displayName = '<STR_LIT>' , <EOL> direction = '<STR_LIT>' , <EOL> datatype = '<STR_LIT>' , <EOL> parameterType = '<STR_LIT>' ) <EOL> return [ feature_class , field_mappings , output_dir , output_name , <EOL> convert_4326 , convert_geojson , convert_kmz , convert_csv , <EOL> convert_metadata , debug ] <EOL> def isLicensed ( self ) : <EOL> return True <EOL> def updateParameters ( self , params ) : <EOL> """<STR_LIT>""" <EOL> """<STR_LIT>""" <EOL> if params [ <NUM_LIT:0> ] . valueAsText : <EOL> fc_type = arcpy . Describe ( params [ <NUM_LIT:0> ] . valueAsText ) . shapeType <EOL> if fc_type in [ '<STR_LIT>' , '<STR_LIT>' ] : <EOL> params [ <NUM_LIT:7> ] . enabled = <NUM_LIT:1> <EOL> else : <EOL> params [ <NUM_LIT:7> ] . enabled = <NUM_LIT:0> <EOL> return <EOL> def checkFieldMappings ( self , param ) : <EOL> """<STR_LIT>""" <EOL> field_mappings = param . value <EOL> over_fields = [ ] <EOL> fields_warning = ( '<STR_LIT>' + <EOL> '<STR_LIT>' + <EOL> '<STR_LIT>' ) <EOL> for idx , val in enumerate ( range ( field_mappings . count ) ) : <EOL> if field_mappings . getVisible ( idx ) == '<STR_LIT>' : <EOL> field = field_mappings . getNewName ( idx ) <EOL> if len ( field ) > <NUM_LIT:10> : <EOL> over_fields . append ( field ) <EOL> if over_fields : <EOL> param . setWarningMessage ( fields_warning + "<STR_LIT:U+002CU+0020>" . join ( over_fields ) ) <EOL> else : <EOL> param . clearMessage ( ) <EOL> def checkShapefileExists ( self , dir , name ) : <EOL> """<STR_LIT>""" <EOL> shapefile = dir . valueAsText + '<STR_LIT>' + name . valueAsText + '<STR_LIT>' <EOL> exists_error = ( '<STR_LIT>' + <EOL> '<STR_LIT>' + <EOL> '<STR_LIT>' + <EOL> '<STR_LIT>' ) <EOL> if arcpy . Exists ( shapefile ) : <EOL> name . setErrorMessage ( exists_error ) <EOL> else : <EOL> name . clearMessage ( ) <EOL> def updateMessages ( self , params ) : <EOL> """<STR_LIT>""" <EOL> """<STR_LIT>""" <EOL> if params [ <NUM_LIT:2> ] . value and params [ <NUM_LIT:2> ] . altered : <EOL> if params [ <NUM_LIT:3> ] . value and params [ <NUM_LIT:3> ] . altered : <EOL> self . checkShapefileExists ( params [ <NUM_LIT:2> ] , params [ <NUM_LIT:3> ] ) <EOL> """<STR_LIT>""" <EOL> if params [ <NUM_LIT:1> ] . value : <EOL> self . checkFieldMappings ( params [ <NUM_LIT:1> ] ) <EOL> return <EOL> def toBool ( self , value ) : <EOL> """<STR_LIT>""" <EOL> if value == '<STR_LIT:true>' : <EOL> return True <EOL> else : <EOL> return False <EOL> def execute ( self , parameters , messages ) : <EOL> """<STR_LIT>""" <EOL> fc = parameters [ <NUM_LIT:0> ] . valueAsText <EOL> field_mappings = parameters [ <NUM_LIT:1> ] . valueAsText <EOL> fields = parameters [ <NUM_LIT:1> ] . valueAsText . split ( '<STR_LIT:;>' ) <EOL> fields . append ( '<STR_LIT>' ) <EOL> output_dir = parameters [ <NUM_LIT:2> ] . valueAsText <EOL> output_name = parameters [ <NUM_LIT:3> ] . valueAsText <EOL> convert_to_wgs84 = self . toBool ( parameters [ <NUM_LIT:4> ] . valueAsText ) <EOL> convert_to_geojson = self . toBool ( parameters [ <NUM_LIT:5> ] . valueAsText ) <EOL> convert_to_kmz = self . toBool ( parameters [ <NUM_LIT:6> ] . valueAsText ) <EOL> convert_to_csv = self . toBool ( parameters [ <NUM_LIT:7> ] . valueAsText ) <EOL> convert_metadata = self . toBool ( parameters [ <NUM_LIT:8> ] . valueAsText ) <EOL> debug = self . toBool ( parameters [ <NUM_LIT:9> ] . valueAsText ) <EOL> output_path = output_dir + '<STR_LIT:\\>' + output_name <EOL> shp_output_path = output_dir + '<STR_LIT>' <EOL> shp_temp_output_path = output_dir + '<STR_LIT>' <EOL> shapefile = shp_output_path + '<STR_LIT:\\>' + output_name + '<STR_LIT>' <EOL> temp_shapefile = shp_output_path + '<STR_LIT>' + output_name + '<STR_LIT>' <EOL> if debug : <EOL> AddMessage ( '<STR_LIT>' ) <EOL> AddMessage ( field_mappings ) <EOL> try : <EOL> arcpy . Delete_management ( '<STR_LIT>' ) <EOL> except : <EOL> if debug : <EOL> AddMessage ( '<STR_LIT>' + <EOL> '<STR_LIT>' ) <EOL> if not os . path . exists ( shp_output_path ) : <EOL> os . makedirs ( shp_output_path ) <EOL> if debug : <EOL> AddMessage ( '<STR_LIT>' + shp_output_path ) <EOL> if not os . path . exists ( shp_temp_output_path ) : <EOL> os . makedirs ( shp_temp_output_path ) <EOL> else : <EOL> for file in os . listdir ( shp_temp_output_path ) : <EOL> file_path = os . path . join ( shp_temp_output_path , file ) <EOL> try : <EOL> if os . path . isfile ( file_path ) : <EOL> os . unlink ( file_path ) <EOL> except : <EOL> AddWarning ( '<STR_LIT>' + file + <EOL> '<STR_LIT>' + <EOL> '<STR_LIT>' ) <EOL> pass <EOL> arcpy . MakeFeatureLayer_management ( fc , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , <EOL> field_mappings ) <EOL> arcpy . CopyFeatures_management ( '<STR_LIT>' , temp_shapefile ) <EOL> if convert_to_wgs84 : <EOL> AddMessage ( '<STR_LIT>' ) <EOL> arcpy . Project_management ( temp_shapefile , shapefile , "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" ) <EOL> AddMessage ( '<STR_LIT>' ) <EOL> else : <EOL> AddMessage ( '<STR_LIT>' ) <EOL> arcpy . FeatureClassToShapefile_conversion ( temp_shapefile , <EOL> shp_output_path ) <EOL> try : <EOL> arcpy . Delete_management ( '<STR_LIT>' ) <EOL> except : <EOL> AddError ( '<STR_LIT>' ) <EOL> AddMessage ( '<STR_LIT>' ) <EOL> export = Export ( output_dir , output_name , debug ) <EOL> zip = export . zip ( ) <EOL> if zip : <EOL> AddMessage ( '<STR_LIT>' ) <EOL> if convert_to_geojson : <EOL> AddMessage ( '<STR_LIT>' ) <EOL> output = output_path + '<STR_LIT>' <EOL> geojson = esri2open . toOpen ( shapefile , output , <EOL> includeGeometry = '<STR_LIT>' ) <EOL> if geojson : <EOL> AddMessage ( '<STR_LIT>' ) <EOL> if convert_to_kmz : <EOL> AddMessage ( '<STR_LIT>' ) <EOL> kmz = export . kmz ( ) <EOL> if kmz : <EOL> AddMessage ( '<STR_LIT>' ) <EOL> if convert_to_csv : <EOL> AddMessage ( '<STR_LIT>' ) <EOL> csv = export . csv ( ) <EOL> if csv : <EOL> AddMessage ( '<STR_LIT>' ) <EOL> if convert_metadata : <EOL> AddMessage ( '<STR_LIT>' + <EOL> '<STR_LIT>' ) <EOL> md = export . md ( ) <EOL> if md : <EOL> AddMessage ( '<STR_LIT>' + <EOL> '<STR_LIT>' ) <EOL> shutil . rmtree ( shp_output_path + '<STR_LIT>' ) <EOL> if ( debug ) : <EOL> AddMessage ( '<STR_LIT>' + <EOL> '<STR_LIT>' ) <EOL> return </s>

<s> try : <EOL> import configparser <EOL> except : <EOL> import ConfigParser as configparser <EOL> import copy <EOL> try : <EOL> from io import StringIO <EOL> except : <EOL> from StringIO import StringIO <EOL> import os <EOL> import shutil <EOL> import tempfile <EOL> import unittest <EOL> from green import config <EOL> from green . output import GreenStream <EOL> class ParseArguments ( unittest . TestCase ) : <EOL> def test_target ( self ) : <EOL> """<STR_LIT>""" <EOL> config . sys . argv = [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] <EOL> args = config . parseArguments ( ) <EOL> self . assertEqual ( args . targets , [ '<STR_LIT>' , '<STR_LIT>' ] ) <EOL> def test_absent ( self ) : <EOL> """<STR_LIT>""" <EOL> config . sys . argv = [ '<STR_LIT>' , '<STR_LIT>' ] <EOL> args = config . parseArguments ( ) <EOL> self . assertEqual ( getattr ( args , '<STR_LIT>' , '<STR_LIT>' ) , True ) <EOL> self . assertEqual ( getattr ( args , '<STR_LIT>' , '<STR_LIT>' ) , '<STR_LIT>' ) <EOL> self . assertEqual ( getattr ( args , '<STR_LIT>' , '<STR_LIT>' ) , '<STR_LIT>' ) <EOL> self . assertEqual ( getattr ( args , '<STR_LIT>' , '<STR_LIT>' ) , '<STR_LIT>' ) <EOL> class ModifiedEnvironment ( object ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , ** kwargs ) : <EOL> self . prev = { } <EOL> self . excur = kwargs <EOL> for k in kwargs : <EOL> self . prev [ k ] = os . getenv ( k ) <EOL> def __enter__ ( self ) : <EOL> self . update_environment ( self . excur ) <EOL> def __exit__ ( self , type , value , traceback ) : <EOL> self . update_environment ( self . prev ) <EOL> def update_environment ( self , d ) : <EOL> for k in d : <EOL> if d [ k ] is None : <EOL> if k in os . environ : <EOL> del os . environ [ k ] <EOL> else : <EOL> os . environ [ k ] = d [ k ] <EOL> class ConfigBase ( unittest . TestCase ) : <EOL> """<STR_LIT>""" <EOL> def _write_file ( self , path , lines ) : <EOL> f = open ( path , '<STR_LIT:w>' ) <EOL> f . writelines ( [ x + "<STR_LIT:\n>" for x in lines ] ) <EOL> f . close ( ) <EOL> def setUp ( self ) : <EOL> self . tmpd = tempfile . mkdtemp ( ) <EOL> self . default_filename = os . path . join ( self . tmpd , "<STR_LIT>" ) <EOL> self . default_logging = False <EOL> self . default_version = False <EOL> self . default_failfast = True <EOL> self . default_termcolor = True <EOL> self . _write_file ( self . default_filename , <EOL> [ "<STR_LIT>" , <EOL> "<STR_LIT>" . format ( str ( self . default_logging ) ) , <EOL> "<STR_LIT>" . format ( str ( self . default_version ) ) , <EOL> "<STR_LIT>" . format ( self . default_filename ) , <EOL> "<STR_LIT>" . format ( str ( self . default_failfast ) ) , <EOL> "<STR_LIT>" . format ( str ( self . default_termcolor ) ) , <EOL> ] ) <EOL> self . env_filename = os . path . join ( self . tmpd , "<STR_LIT>" ) <EOL> self . env_logging = True <EOL> self . env_no_skip_report = False <EOL> self . _write_file ( self . env_filename , <EOL> [ "<STR_LIT>" , <EOL> "<STR_LIT>" . format ( str ( self . env_logging ) ) , <EOL> "<STR_LIT>" . format ( self . env_filename ) , <EOL> "<STR_LIT>" . format ( self . env_no_skip_report ) , <EOL> ] ) <EOL> self . cmd_filename = os . path . join ( self . tmpd , "<STR_LIT>" ) <EOL> self . cmd_logging = False <EOL> self . cmd_run_coverage = False <EOL> self . _write_file ( self . cmd_filename , <EOL> [ "<STR_LIT>" , <EOL> "<STR_LIT>" . format ( str ( self . cmd_logging ) ) , <EOL> "<STR_LIT>" . format ( self . cmd_filename ) , <EOL> "<STR_LIT>" . format ( self . cmd_run_coverage ) , <EOL> ] ) <EOL> def tearDown ( self ) : <EOL> shutil . rmtree ( self . tmpd ) <EOL> class TestConfig ( ConfigBase ) : <EOL> """<STR_LIT>""" <EOL> def test_cmd_env_def ( self ) : <EOL> """<STR_LIT>""" <EOL> with ModifiedEnvironment ( GREEN_CONFIG = self . env_filename , HOME = self . tmpd ) : <EOL> cfg = config . getConfig ( self . cmd_filename ) <EOL> ae = self . assertEqual <EOL> ae ( [ "<STR_LIT>" ] , cfg . sections ( ) ) <EOL> ae ( self . cmd_filename , cfg . get ( "<STR_LIT>" , "<STR_LIT>" ) ) <EOL> ae ( self . cmd_run_coverage , cfg . getboolean ( "<STR_LIT>" , "<STR_LIT>" ) ) <EOL> ae ( self . cmd_logging , cfg . getboolean ( "<STR_LIT>" , "<STR_LIT>" ) ) <EOL> ae ( self . env_no_skip_report , cfg . getboolean ( "<STR_LIT>" , "<STR_LIT>" ) ) <EOL> ae ( self . default_version , cfg . getboolean ( "<STR_LIT>" , "<STR_LIT:version>" ) ) <EOL> def test_cmd_env_nodef ( self ) : <EOL> """<STR_LIT>""" <EOL> os . unlink ( self . default_filename ) <EOL> with ModifiedEnvironment ( GREEN_CONFIG = self . env_filename , HOME = self . tmpd ) : <EOL> cfg = config . getConfig ( self . cmd_filename ) <EOL> ae = self . assertEqual <EOL> ar = self . assertRaises <EOL> ae ( [ "<STR_LIT>" ] , cfg . sections ( ) ) <EOL> ae ( self . cmd_filename , cfg . get ( "<STR_LIT>" , "<STR_LIT>" ) ) <EOL> ae ( self . cmd_run_coverage , cfg . getboolean ( "<STR_LIT>" , "<STR_LIT>" ) ) <EOL> ae ( self . cmd_logging , cfg . getboolean ( "<STR_LIT>" , "<STR_LIT>" ) ) <EOL> ae ( self . env_no_skip_report , cfg . getboolean ( "<STR_LIT>" , "<STR_LIT>" ) ) <EOL> ar ( configparser . NoOptionError , cfg . getboolean , "<STR_LIT>" , "<STR_LIT:version>" ) <EOL> def test_cmd_noenv_def ( self ) : <EOL> """<STR_LIT>""" <EOL> os . unlink ( self . env_filename ) <EOL> with ModifiedEnvironment ( GREEN_CONFIG = None , HOME = self . tmpd ) : <EOL> cfg = config . getConfig ( self . cmd_filename ) <EOL> ae = self . assertEqual <EOL> ar = self . assertRaises <EOL> ae ( [ "<STR_LIT>" ] , cfg . sections ( ) ) <EOL> ae ( self . cmd_filename , cfg . get ( "<STR_LIT>" , "<STR_LIT>" ) ) <EOL> ae ( self . cmd_run_coverage , cfg . getboolean ( "<STR_LIT>" , "<STR_LIT>" ) ) <EOL> ae ( self . cmd_logging , cfg . getboolean ( "<STR_LIT>" , "<STR_LIT>" ) ) <EOL> ar ( configparser . NoOptionError , cfg . getboolean , "<STR_LIT>" , "<STR_LIT>" ) <EOL> ae ( self . default_version , cfg . getboolean ( "<STR_LIT>" , "<STR_LIT:version>" ) ) <EOL> def test_cmd_noenv_nodef ( self ) : <EOL> """<STR_LIT>""" <EOL> os . unlink ( self . env_filename ) <EOL> os . unlink ( self . default_filename ) <EOL> with ModifiedEnvironment ( GREEN_CONFIG = None , HOME = self . tmpd ) : <EOL> cfg = config . getConfig ( self . cmd_filename ) <EOL> ae = self . assertEqual <EOL> ar = self . assertRaises <EOL> ae ( [ "<STR_LIT>" ] , cfg . sections ( ) ) <EOL> ae ( self . cmd_filename , cfg . get ( "<STR_LIT>" , "<STR_LIT>" ) ) <EOL> ae ( self . cmd_run_coverage , cfg . getboolean ( "<STR_LIT>" , "<STR_LIT>" ) ) <EOL> ae ( self . cmd_logging , cfg . getboolean ( "<STR_LIT>" , "<STR_LIT>" ) ) <EOL> ar ( configparser . NoOptionError , cfg . getboolean , "<STR_LIT>" , "<STR_LIT>" ) <EOL> ar ( configparser . NoOptionError , cfg . getboolean , "<STR_LIT>" , "<STR_LIT:version>" ) <EOL> def test_nocmd_env_def ( self ) : <EOL> """<STR_LIT>""" <EOL> os . unlink ( self . cmd_filename ) <EOL> with ModifiedEnvironment ( GREEN_CONFIG = self . env_filename , HOME = self . tmpd ) : <EOL> cfg = config . getConfig ( ) <EOL> ae = self . assertEqual <EOL> ar = self . assertRaises <EOL> ae ( [ "<STR_LIT>" ] , cfg . sections ( ) ) <EOL> ae ( self . env_filename , cfg . get ( "<STR_LIT>" , "<STR_LIT>" ) ) <EOL> ar ( configparser . NoOptionError , cfg . get , "<STR_LIT>" , "<STR_LIT>" ) <EOL> ae ( self . env_logging , cfg . getboolean ( "<STR_LIT>" , "<STR_LIT>" ) ) <EOL> ae ( self . env_no_skip_report , cfg . getboolean ( "<STR_LIT>" , "<STR_LIT>" ) ) <EOL> ae ( self . default_version , cfg . getboolean ( "<STR_LIT>" , "<STR_LIT:version>" ) ) <EOL> def test_nocmd_env_nodef ( self ) : <EOL> """<STR_LIT>""" <EOL> os . unlink ( self . cmd_filename ) <EOL> os . unlink ( self . default_filename ) <EOL> with ModifiedEnvironment ( GREEN_CONFIG = self . env_filename , HOME = self . tmpd ) : <EOL> cfg = config . getConfig ( ) <EOL> ae = self . assertEqual <EOL> ar = self . assertRaises <EOL> ae ( [ "<STR_LIT>" ] , cfg . sections ( ) ) <EOL> ae ( self . env_filename , cfg . get ( "<STR_LIT>" , "<STR_LIT>" ) ) <EOL> ar ( configparser . NoOptionError , cfg . get , "<STR_LIT>" , "<STR_LIT>" ) <EOL> ae ( self . env_logging , cfg . getboolean ( "<STR_LIT>" , "<STR_LIT>" ) ) <EOL> ae ( self . env_no_skip_report , cfg . getboolean ( "<STR_LIT>" , "<STR_LIT>" ) ) <EOL> ar ( configparser . NoOptionError , cfg . getboolean , "<STR_LIT>" , "<STR_LIT:version>" ) <EOL> def test_nocmd_noenv_def ( self ) : <EOL> """<STR_LIT>""" <EOL> os . unlink ( self . cmd_filename ) <EOL> os . unlink ( self . env_filename ) <EOL> with ModifiedEnvironment ( GREEN_CONFIG = None , HOME = self . tmpd ) : <EOL> cfg = config . getConfig ( ) <EOL> ae = self . assertEqual <EOL> ar = self . assertRaises <EOL> ae ( [ "<STR_LIT>" ] , cfg . sections ( ) ) <EOL> ae ( self . default_filename , cfg . get ( "<STR_LIT>" , "<STR_LIT>" ) ) <EOL> ar ( configparser . NoOptionError , cfg . get , "<STR_LIT>" , "<STR_LIT>" ) <EOL> ae ( self . default_logging , cfg . getboolean ( "<STR_LIT>" , "<STR_LIT>" ) ) <EOL> ar ( configparser . NoOptionError , cfg . getboolean , "<STR_LIT>" , "<STR_LIT>" ) <EOL> ae ( self . default_version , cfg . getboolean ( "<STR_LIT>" , "<STR_LIT:version>" ) ) <EOL> def test_nocmd_noenv_nodef ( self ) : <EOL> """<STR_LIT>""" <EOL> os . unlink ( self . default_filename ) <EOL> os . unlink ( self . env_filename ) <EOL> os . unlink ( self . cmd_filename ) <EOL> with ModifiedEnvironment ( GREEN_CONFIG = None , HOME = self . tmpd ) : <EOL> cfg = config . getConfig ( ) <EOL> ae = self . assertEqual <EOL> ar = self . assertRaises <EOL> ae ( [ ] , cfg . sections ( ) ) <EOL> ar ( configparser . NoSectionError , cfg . get , "<STR_LIT>" , "<STR_LIT>" ) <EOL> ar ( configparser . NoSectionError , cfg . get , "<STR_LIT>" , "<STR_LIT>" ) <EOL> ar ( configparser . NoSectionError , cfg . get , "<STR_LIT>" , "<STR_LIT>" ) <EOL> ar ( configparser . NoSectionError , cfg . get , "<STR_LIT>" , "<STR_LIT>" ) <EOL> ar ( configparser . NoSectionError , cfg . get , "<STR_LIT>" , "<STR_LIT:version>" ) <EOL> class TestMergeConfig ( ConfigBase ) : <EOL> """<STR_LIT>""" <EOL> def test_overwrite ( self ) : <EOL> """<STR_LIT>""" <EOL> s = StringIO ( ) <EOL> gs = GreenStream ( s ) <EOL> saved_stdout = config . sys . stdout <EOL> config . sys . stdout = gs <EOL> self . addCleanup ( setattr , config . sys , '<STR_LIT>' , saved_stdout ) <EOL> with ModifiedEnvironment ( GREEN_CONFIG = self . env_filename , HOME = self . tmpd ) : <EOL> new_args = copy . deepcopy ( config . default_args ) <EOL> new_args . omit_patterns = '<STR_LIT>' <EOL> new_args . run_coverage = True <EOL> new_args . logging = True <EOL> new_args . no_skip_report = True <EOL> new_args . version = True <EOL> new_args . config = self . cmd_filename <EOL> computed_args = config . mergeConfig ( new_args , testing = True ) <EOL> self . assertEqual ( computed_args . omit_patterns , '<STR_LIT>' ) <EOL> self . assertEqual ( computed_args . run_coverage , new_args . run_coverage ) <EOL> self . assertEqual ( computed_args . logging , new_args . logging ) <EOL> self . assertEqual ( computed_args . no_skip_report , new_args . no_skip_report ) <EOL> self . assertEqual ( computed_args . version , new_args . version ) <EOL> def test_no_overwrite ( self ) : <EOL> """<STR_LIT>""" <EOL> with ModifiedEnvironment ( GREEN_CONFIG = self . env_filename , HOME = "<STR_LIT>" ) : <EOL> da = copy . deepcopy ( config . default_args ) <EOL> del ( da . logging ) <EOL> computed_args = config . mergeConfig ( da , testing = True ) <EOL> self . assertEqual ( computed_args . logging , True ) <EOL> def test_specified_command_line ( self ) : <EOL> """<STR_LIT>""" <EOL> with ModifiedEnvironment ( HOME = self . tmpd ) : <EOL> new_args = copy . deepcopy ( config . default_args ) <EOL> new_args . failfast = True <EOL> new_args . logging = True <EOL> del ( new_args . version ) <EOL> new_args . termcolor = False <EOL> computed_args = config . mergeConfig ( new_args , testing = True ) <EOL> self . assertEqual ( computed_args . failfast , True ) <EOL> self . assertEqual ( computed_args . logging , True ) <EOL> self . assertEqual ( computed_args . version , False ) <EOL> self . assertEqual ( computed_args . termcolor , False ) <EOL> def test_targets ( self ) : <EOL> """<STR_LIT>""" <EOL> config . sys . argv = [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] <EOL> args = config . parseArguments ( ) <EOL> args = config . mergeConfig ( args ) <EOL> self . assertEqual ( args . targets , [ '<STR_LIT>' , '<STR_LIT>' ] ) <EOL> def test_forgotToUpdateMerge ( self ) : <EOL> """<STR_LIT>""" <EOL> orig_args = copy . deepcopy ( config . default_args ) <EOL> self . addCleanup ( setattr , config , '<STR_LIT>' , orig_args ) <EOL> config . default_args . new_option = True <EOL> new_args = copy . deepcopy ( config . default_args ) <EOL> self . assertRaises ( NotImplementedError , config . mergeConfig , new_args , <EOL> testing = True ) </s>

<s> '''<STR_LIT>''' <EOL> import os , sys <EOL> import traceback <EOL> import json <EOL> import optparse <EOL> import pickle <EOL> import collections <EOL> import sklearn <EOL> import sklearn . feature_extraction <EOL> import sklearn . ensemble <EOL> import sklearn . metrics <EOL> import pandas as pd <EOL> import numpy as np <EOL> import tldextract <EOL> import math <EOL> print '<STR_LIT>' % sklearn . __version__ <EOL> print '<STR_LIT>' % pd . __version__ <EOL> print '<STR_LIT>' % tldextract . __version__ <EOL> import warnings <EOL> warnings . filterwarnings ( "<STR_LIT:ignore>" , category = DeprecationWarning ) <EOL> def domain_extract ( uri ) : <EOL> ext = tldextract . extract ( uri ) <EOL> if ( not ext . suffix ) : <EOL> return None <EOL> else : <EOL> return ext . domain <EOL> def entropy ( s ) : <EOL> p , lns = collections . Counter ( s ) , float ( len ( s ) ) <EOL> return - sum ( count / lns * math . log ( count / lns , <NUM_LIT:2> ) for count in p . values ( ) ) <EOL> def show_cm ( cm , labels ) : <EOL> percent = ( cm * <NUM_LIT> ) / np . array ( np . matrix ( cm . sum ( axis = <NUM_LIT:1> ) ) . T ) <EOL> print '<STR_LIT>' <EOL> for i , label_i in enumerate ( labels ) : <EOL> for j , label_j in enumerate ( labels ) : <EOL> print "<STR_LIT>" % ( label_i , label_j , ( percent [ i ] [ j ] ) , cm [ i ] [ j ] , cm [ i ] . sum ( ) ) <EOL> def save_model_to_disk ( name , model , model_dir = '<STR_LIT>' ) : <EOL> '''<STR_LIT>''' <EOL> serialized_model = pickle . dumps ( model , protocol = pickle . HIGHEST_PROTOCOL ) <EOL> model_path = os . path . join ( model_dir , name + '<STR_LIT>' ) <EOL> print '<STR_LIT>' % ( name , len ( serialized_model ) / <NUM_LIT> / <NUM_LIT> ) <EOL> open ( model_path , '<STR_LIT:wb>' ) . write ( serialized_model ) <EOL> def load_model_from_disk ( name , model_dir = '<STR_LIT>' ) : <EOL> model_path = os . path . join ( model_dir , name + '<STR_LIT>' ) <EOL> try : <EOL> model = pickle . loads ( open ( model_path , '<STR_LIT:rb>' ) . read ( ) ) <EOL> except : <EOL> print '<STR_LIT>' % ( name , model_path ) <EOL> return None <EOL> return model <EOL> def main ( ) : <EOL> '''<STR_LIT>''' <EOL> parser = optparse . OptionParser ( ) <EOL> parser . add_option ( '<STR_LIT>' , default = '<STR_LIT>' , help = '<STR_LIT>' ) <EOL> ( options , arguments ) = parser . parse_args ( ) <EOL> print options , arguments <EOL> try : <EOL> print '<STR_LIT>' <EOL> alexa_dataframe = pd . read_csv ( options . alexa_file , names = [ '<STR_LIT>' , '<STR_LIT>' ] , header = None , encoding = '<STR_LIT:utf-8>' ) <EOL> print alexa_dataframe . info ( ) <EOL> print alexa_dataframe . head ( ) <EOL> alexa_dataframe [ '<STR_LIT>' ] = [ domain_extract ( uri ) for uri in alexa_dataframe [ '<STR_LIT>' ] ] <EOL> del alexa_dataframe [ '<STR_LIT>' ] <EOL> del alexa_dataframe [ '<STR_LIT>' ] <EOL> alexa_dataframe = alexa_dataframe . dropna ( ) <EOL> alexa_dataframe = alexa_dataframe . drop_duplicates ( ) <EOL> print alexa_dataframe . head ( ) <EOL> alexa_dataframe [ '<STR_LIT:class>' ] = '<STR_LIT>' <EOL> alexa_dataframe = alexa_dataframe . reindex ( np . random . permutation ( alexa_dataframe . index ) ) <EOL> alexa_total = alexa_dataframe . shape [ <NUM_LIT:0> ] <EOL> print '<STR_LIT>' % alexa_total <EOL> dga_dataframe = pd . read_csv ( '<STR_LIT>' , names = [ '<STR_LIT>' ] , header = None , encoding = '<STR_LIT:utf-8>' ) <EOL> dga_dataframe [ '<STR_LIT>' ] = dga_dataframe . applymap ( lambda x : x . split ( '<STR_LIT:.>' ) [ <NUM_LIT:0> ] . strip ( ) . lower ( ) ) <EOL> del dga_dataframe [ '<STR_LIT>' ] <EOL> dga_dataframe = dga_dataframe . dropna ( ) <EOL> dga_dataframe = dga_dataframe . drop_duplicates ( ) <EOL> dga_total = dga_dataframe . shape [ <NUM_LIT:0> ] <EOL> print '<STR_LIT>' % dga_total <EOL> dga_dataframe [ '<STR_LIT:class>' ] = '<STR_LIT>' <EOL> print '<STR_LIT>' % dga_dataframe . shape [ <NUM_LIT:0> ] <EOL> print dga_dataframe . head ( ) <EOL> all_domains = pd . concat ( [ alexa_dataframe , dga_dataframe ] , ignore_index = True ) <EOL> all_domains [ '<STR_LIT>' ] = [ len ( x ) for x in all_domains [ '<STR_LIT>' ] ] <EOL> all_domains = all_domains [ all_domains [ '<STR_LIT>' ] > <NUM_LIT:6> ] <EOL> all_domains [ '<STR_LIT>' ] = [ entropy ( x ) for x in all_domains [ '<STR_LIT>' ] ] <EOL> print all_domains . head ( ) <EOL> alexa_vc = sklearn . feature_extraction . text . CountVectorizer ( analyzer = '<STR_LIT>' , ngram_range = ( <NUM_LIT:3> , <NUM_LIT:5> ) , min_df = <NUM_LIT> , max_df = <NUM_LIT:1.0> ) <EOL> counts_matrix = alexa_vc . fit_transform ( alexa_dataframe [ '<STR_LIT>' ] ) <EOL> alexa_counts = np . log10 ( counts_matrix . sum ( axis = <NUM_LIT:0> ) . getA1 ( ) ) <EOL> ngrams_list = alexa_vc . get_feature_names ( ) <EOL> import operator <EOL> _sorted_ngrams = sorted ( zip ( ngrams_list , alexa_counts ) , key = operator . itemgetter ( <NUM_LIT:1> ) , reverse = True ) <EOL> print '<STR_LIT>' % len ( _sorted_ngrams ) <EOL> for ngram , count in _sorted_ngrams [ : <NUM_LIT:10> ] : <EOL> print ngram , count <EOL> word_dataframe = pd . read_csv ( '<STR_LIT>' , names = [ '<STR_LIT>' ] , header = None , dtype = { '<STR_LIT>' : np . str } , encoding = '<STR_LIT:utf-8>' ) <EOL> word_dataframe = word_dataframe [ word_dataframe [ '<STR_LIT>' ] . map ( lambda x : str ( x ) . isalpha ( ) ) ] <EOL> word_dataframe = word_dataframe . applymap ( lambda x : str ( x ) . strip ( ) . lower ( ) ) <EOL> word_dataframe = word_dataframe . dropna ( ) <EOL> word_dataframe = word_dataframe . drop_duplicates ( ) <EOL> print word_dataframe . head ( <NUM_LIT:10> ) <EOL> dict_vc = sklearn . feature_extraction . text . CountVectorizer ( analyzer = '<STR_LIT>' , ngram_range = ( <NUM_LIT:3> , <NUM_LIT:5> ) , min_df = <NUM_LIT> , max_df = <NUM_LIT:1.0> ) <EOL> counts_matrix = dict_vc . fit_transform ( word_dataframe [ '<STR_LIT>' ] ) <EOL> dict_counts = np . log10 ( counts_matrix . sum ( axis = <NUM_LIT:0> ) . getA1 ( ) ) <EOL> ngrams_list = dict_vc . get_feature_names ( ) <EOL> import operator <EOL> _sorted_ngrams = sorted ( zip ( ngrams_list , dict_counts ) , key = operator . itemgetter ( <NUM_LIT:1> ) , reverse = True ) <EOL> print '<STR_LIT>' % len ( _sorted_ngrams ) <EOL> for ngram , count in _sorted_ngrams [ : <NUM_LIT:10> ] : <EOL> print ngram , count <EOL> def ngram_count ( domain ) : <EOL> alexa_match = alexa_counts * alexa_vc . transform ( [ domain ] ) . T <EOL> dict_match = dict_counts * dict_vc . transform ( [ domain ] ) . T <EOL> print '<STR_LIT>' % ( domain , alexa_match , dict_match ) <EOL> ngram_count ( '<STR_LIT>' ) <EOL> ngram_count ( '<STR_LIT>' ) <EOL> ngram_count ( '<STR_LIT>' ) <EOL> ngram_count ( '<STR_LIT>' ) <EOL> ngram_count ( '<STR_LIT>' ) <EOL> ngram_count ( '<STR_LIT>' ) <EOL> ngram_count ( '<STR_LIT>' ) <EOL> all_domains [ '<STR_LIT>' ] = alexa_counts * alexa_vc . transform ( all_domains [ '<STR_LIT>' ] ) . T <EOL> all_domains [ '<STR_LIT>' ] = dict_counts * dict_vc . transform ( all_domains [ '<STR_LIT>' ] ) . T <EOL> print all_domains . head ( ) <EOL> all_domains [ '<STR_LIT>' ] = all_domains [ '<STR_LIT>' ] - all_domains [ '<STR_LIT>' ] <EOL> print all_domains . sort ( [ '<STR_LIT>' ] , ascending = True ) . head ( <NUM_LIT:10> ) <EOL> print all_domains . sort ( [ '<STR_LIT>' ] , ascending = False ) . head ( <NUM_LIT:50> ) <EOL> weird_cond = ( all_domains [ '<STR_LIT:class>' ] == '<STR_LIT>' ) & ( all_domains [ '<STR_LIT>' ] < <NUM_LIT:3> ) & ( all_domains [ '<STR_LIT>' ] < <NUM_LIT:2> ) <EOL> weird = all_domains [ weird_cond ] <EOL> print weird . shape [ <NUM_LIT:0> ] <EOL> print weird . head ( <NUM_LIT:10> ) <EOL> all_domains . loc [ weird_cond , '<STR_LIT:class>' ] = '<STR_LIT>' <EOL> print all_domains [ '<STR_LIT:class>' ] . value_counts ( ) <EOL> all_domains [ all_domains [ '<STR_LIT:class>' ] == '<STR_LIT>' ] . head ( ) <EOL> not_weird = all_domains [ all_domains [ '<STR_LIT:class>' ] != '<STR_LIT>' ] <EOL> X = not_weird . as_matrix ( [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] ) <EOL> y = np . array ( not_weird [ '<STR_LIT:class>' ] . tolist ( ) ) <EOL> clf = sklearn . ensemble . RandomForestClassifier ( n_estimators = <NUM_LIT:20> , compute_importances = True ) <EOL> from sklearn . cross_validation import train_test_split <EOL> X_train , X_test , y_train , y_test = train_test_split ( X , y , test_size = <NUM_LIT> ) <EOL> clf . fit ( X_train , y_train ) <EOL> y_pred = clf . predict ( X_test ) <EOL> labels = [ '<STR_LIT>' , '<STR_LIT>' ] <EOL> cm = sklearn . metrics . confusion_matrix ( y_test , y_pred , labels ) <EOL> show_cm ( cm , labels ) <EOL> importances = zip ( [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] , clf . feature_importances_ ) <EOL> print importances <EOL> clf . fit ( X , y ) <EOL> def test_it ( domain ) : <EOL> _alexa_match = alexa_counts * alexa_vc . transform ( [ domain ] ) . T <EOL> _dict_match = dict_counts * dict_vc . transform ( [ domain ] ) . T <EOL> _X = [ len ( domain ) , entropy ( domain ) , _alexa_match , _dict_match ] <EOL> print '<STR_LIT>' % ( domain , clf . predict ( _X ) [ <NUM_LIT:0> ] ) <EOL> test_it ( '<STR_LIT>' ) <EOL> test_it ( '<STR_LIT>' ) <EOL> test_it ( '<STR_LIT>' ) <EOL> test_it ( '<STR_LIT>' ) <EOL> test_it ( '<STR_LIT>' ) <EOL> test_it ( '<STR_LIT>' ) <EOL> test_it ( '<STR_LIT>' ) <EOL> test_it ( '<STR_LIT>' ) <EOL> test_it ( '<STR_LIT>' ) <EOL> test_it ( '<STR_LIT>' ) <EOL> test_it ( '<STR_LIT>' ) <EOL> test_it ( '<STR_LIT>' ) <EOL> save_model_to_disk ( '<STR_LIT>' , clf ) <EOL> save_model_to_disk ( '<STR_LIT>' , alexa_vc ) <EOL> save_model_to_disk ( '<STR_LIT>' , alexa_counts ) <EOL> save_model_to_disk ( '<STR_LIT>' , dict_vc ) <EOL> save_model_to_disk ( '<STR_LIT>' , dict_counts ) <EOL> except KeyboardInterrupt : <EOL> print '<STR_LIT>' <EOL> sys . exit ( <NUM_LIT:0> ) <EOL> except Exception , error : <EOL> traceback . print_exc ( ) <EOL> print '<STR_LIT>' % ( str ( error ) ) <EOL> sys . exit ( <NUM_LIT:1> ) <EOL> if __name__ == '<STR_LIT:__main__>' : <EOL> main ( ) </s>

<s> """<STR_LIT>""" <EOL> from __future__ import unicode_literals <EOL> import struct <EOL> from binascii import b2a_hex , a2b_hex <EOL> _STRUCTURE = b"<STR_LIT>" <EOL> _OFFSET = ( <NUM_LIT:2> ** <NUM_LIT> ) + <NUM_LIT:10> <EOL> def encode ( timestamp ) : <EOL> """<STR_LIT>""" <EOL> seconds = int ( timestamp ) <EOL> nanoseconds = int ( ( timestamp - seconds ) * <NUM_LIT> ) <EOL> seconds = seconds + _OFFSET <EOL> encoded = b2a_hex ( struct . pack ( _STRUCTURE , seconds , nanoseconds ) ) <EOL> return "<STR_LIT:@>" + encoded . decode ( "<STR_LIT:ascii>" ) <EOL> def decode ( tai64n ) : <EOL> """<STR_LIT>""" <EOL> seconds , nanoseconds = struct . unpack ( _STRUCTURE , a2b_hex ( tai64n [ <NUM_LIT:1> : ] ) ) <EOL> seconds -= _OFFSET <EOL> return seconds + ( nanoseconds / <NUM_LIT> ) </s>

<s> from sys import stdout <EOL> from eliot import start_action , start_task , to_file <EOL> to_file ( stdout ) <EOL> class Place ( object ) : <EOL> def __init__ ( self , name , contained = ( ) ) : <EOL> self . name = name <EOL> self . contained = contained <EOL> def visited ( self , people ) : <EOL> with start_action ( action_type = "<STR_LIT>" , place = self . name ) : <EOL> for thing in self . contained : <EOL> thing . visited ( people ) <EOL> def honeymoon ( family , destination ) : <EOL> with start_task ( action_type = "<STR_LIT>" , people = family ) : <EOL> destination . visited ( family ) <EOL> honeymoon ( [ "<STR_LIT>" , "<STR_LIT>" ] , <EOL> Place ( "<STR_LIT>" , <EOL> [ Place ( "<STR_LIT>" , <EOL> [ Place ( "<STR_LIT>" ) , Place ( "<STR_LIT>" ) ] ) ] ) ) </s>

<s> """<STR_LIT>""" <EOL> from glob import glob <EOL> import platform <EOL> from subprocess import check_output <EOL> from textwrap import dedent <EOL> from unittest import skipIf <EOL> from StringIO import StringIO <EOL> from twisted . python . filepath import FilePath <EOL> from twisted . python . procutils import which <EOL> from twisted . python . usage import UsageError <EOL> from virtualenv import REQUIRED_MODULES as VIRTUALENV_REQUIRED_MODULES <EOL> from flocker . testtools import TestCase , FakeSysModule <EOL> from . . import packaging <EOL> from . . packaging import ( <EOL> omnibus_package_builder , InstallVirtualEnv , InstallApplication , <EOL> BuildPackage , BuildSequence , BuildOptions , BuildScript , DockerBuildOptions , <EOL> DockerBuildScript , GetPackageVersion , DelayedRpmVersion , CreateLinks , <EOL> PythonPackage , create_virtualenv , VirtualEnv , PackageTypes , Distribution , <EOL> Dependency , build_in_docker , DockerBuild , DockerRun , <EOL> PACKAGE , PACKAGE_PYTHON , PACKAGE_CLI , PACKAGE_NODE , PACKAGE_DOCKER_PLUGIN , <EOL> make_dependencies , available_distributions , <EOL> LintPackage , <EOL> ) <EOL> from flocker . common . version import RPMVersion <EOL> FLOCKER_PATH = FilePath ( __file__ ) . parent ( ) . parent ( ) . parent ( ) <EOL> require_fpm = skipIf ( not which ( '<STR_LIT>' ) , "<STR_LIT>" ) <EOL> require_rpm = skipIf ( not which ( '<STR_LIT>' ) , "<STR_LIT>" ) <EOL> require_rpmlint = skipIf ( not which ( '<STR_LIT>' ) , <EOL> "<STR_LIT>" ) <EOL> require_dpkg = skipIf ( not which ( '<STR_LIT>' ) , "<STR_LIT>" ) <EOL> require_lintian = skipIf ( not which ( '<STR_LIT>' ) , <EOL> "<STR_LIT>" ) <EOL> require_not_ubuntu = skipIf ( <EOL> platform . linux_distribution ( ) [ <NUM_LIT:0> ] == '<STR_LIT>' , <EOL> "<STR_LIT>" ) <EOL> DOCKER_SOCK = '<STR_LIT>' <EOL> def assert_equal_steps ( test_case , expected , actual ) : <EOL> """<STR_LIT>""" <EOL> expected_steps = getattr ( expected , '<STR_LIT>' ) <EOL> actual_steps = getattr ( actual , '<STR_LIT>' ) <EOL> if None in ( expected_steps , actual_steps ) : <EOL> test_case . assertEqual ( expected , actual ) <EOL> else : <EOL> mismatch_steps = [ ] <EOL> missing_steps = [ ] <EOL> index = <NUM_LIT:0> <EOL> for index , expected_step in enumerate ( expected_steps ) : <EOL> try : <EOL> actual_step = actual_steps [ index ] <EOL> except IndexError : <EOL> missing_steps = expected_steps [ index : ] <EOL> break <EOL> if expected_step != actual_step : <EOL> mismatch_steps . append ( <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' . format ( <EOL> expected_step , actual_step ) ) <EOL> extra_steps = actual_steps [ index + <NUM_LIT:1> : ] <EOL> if mismatch_steps or missing_steps or extra_steps : <EOL> test_case . fail ( <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' . format ( <EOL> '<STR_LIT:\n>' . join ( mismatch_steps ) , missing_steps , extra_steps ) <EOL> ) <EOL> def assert_dict_contains ( test_case , expected , actual , message = '<STR_LIT>' ) : <EOL> """<STR_LIT>""" <EOL> missing_items = [ ] <EOL> mismatch_items = [ ] <EOL> no_value = object ( ) <EOL> for key , expected_value in expected . items ( ) : <EOL> actual_value = actual . get ( key , no_value ) <EOL> if actual_value is no_value : <EOL> missing_items . append ( key ) <EOL> elif actual_value != expected_value : <EOL> mismatch_items . append ( <EOL> '<STR_LIT>' . format ( key , expected_value , actual_value ) <EOL> ) <EOL> if missing_items or mismatch_items : <EOL> test_case . fail ( <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' . format ( <EOL> message , missing_items , mismatch_items , actual ) <EOL> ) <EOL> def parse_colon_dict ( data ) : <EOL> """<STR_LIT>""" <EOL> result = { } <EOL> key = None <EOL> for line in data . splitlines ( ) : <EOL> parts = [ value . strip ( ) for value in line . split ( '<STR_LIT::>' , <NUM_LIT:1> ) ] <EOL> if len ( parts ) == <NUM_LIT:2> : <EOL> key , val = parts <EOL> result [ key ] = val <EOL> else : <EOL> result . setdefault ( key , '<STR_LIT>' ) <EOL> result [ key ] += parts [ <NUM_LIT:0> ] <EOL> return result <EOL> def assert_rpm_headers ( test_case , expected_headers , rpm_path ) : <EOL> """<STR_LIT>""" <EOL> output = check_output ( <EOL> [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , rpm_path . path ] <EOL> ) <EOL> actual_headers = parse_colon_dict ( output ) <EOL> assert_dict_contains ( <EOL> test_case , expected_headers , actual_headers , '<STR_LIT>' <EOL> ) <EOL> def assert_rpm_content ( test_case , expected_paths , package_path ) : <EOL> """<STR_LIT>""" <EOL> output = check_output ( <EOL> [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , package_path . path ] <EOL> ) <EOL> actual_paths = set ( map ( FilePath , output . splitlines ( ) ) ) <EOL> test_case . assertEqual ( expected_paths , actual_paths ) <EOL> def assert_deb_content ( test_case , expected_paths , package_path ) : <EOL> """<STR_LIT>""" <EOL> output_dir = FilePath ( test_case . mktemp ( ) ) <EOL> output_dir . makedirs ( ) <EOL> check_output ( [ '<STR_LIT>' , '<STR_LIT>' , package_path . path , output_dir . path ] ) <EOL> actual_paths = set ( ) <EOL> for f in output_dir . walk ( ) : <EOL> if f . isdir ( ) : <EOL> continue <EOL> actual_paths . add ( FilePath ( '<STR_LIT:/>' ) . descendant ( f . segmentsFrom ( output_dir ) ) ) <EOL> test_case . assertEqual ( expected_paths , actual_paths ) <EOL> def assert_deb_headers ( test_case , expected_headers , package_path ) : <EOL> """<STR_LIT>""" <EOL> output = check_output ( <EOL> [ '<STR_LIT>' , '<STR_LIT>' , package_path . path ] <EOL> ) <EOL> actual_headers = parse_colon_dict ( output ) <EOL> assert_dict_contains ( <EOL> test_case , expected_headers , actual_headers , '<STR_LIT>' <EOL> ) <EOL> def assert_rpm_requires ( test_case , expected_requirements , rpm_path ) : <EOL> """<STR_LIT>""" <EOL> output = check_output ( <EOL> [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , rpm_path . path ] <EOL> ) <EOL> actual_requirements = set ( line . strip ( ) for line in output . splitlines ( ) ) <EOL> expected_requirements = set ( expected_requirements ) <EOL> missing_requirements = expected_requirements - actual_requirements <EOL> if missing_requirements : <EOL> test_case . fail ( '<STR_LIT>' . format ( <EOL> missing_requirements , rpm_path . path ) ) <EOL> class SpyVirtualEnv ( object ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self ) : <EOL> self . _installed_packages = [ ] <EOL> def install ( self , package_uri ) : <EOL> self . _installed_packages . append ( package_uri ) <EOL> class SpyStep ( object ) : <EOL> """<STR_LIT>""" <EOL> ran = False <EOL> def run ( self ) : <EOL> self . ran = True <EOL> class BuildSequenceTests ( TestCase ) : <EOL> """<STR_LIT>""" <EOL> def test_run ( self ) : <EOL> """<STR_LIT>""" <EOL> step1 = SpyStep ( ) <EOL> step2 = SpyStep ( ) <EOL> BuildSequence ( steps = ( step1 , step2 ) ) . run ( ) <EOL> self . assertEqual ( ( True , True ) , ( step1 . ran , step2 . ran ) ) <EOL> def assert_has_paths ( test_case , expected_paths , parent_path ) : <EOL> """<STR_LIT>""" <EOL> missing_paths = [ ] <EOL> for path in expected_paths : <EOL> if not parent_path . preauthChild ( path ) . exists ( ) : <EOL> missing_paths . append ( path ) <EOL> if missing_paths : <EOL> test_case . fail ( '<STR_LIT>' . format ( missing_paths ) ) <EOL> class InstallVirtualEnvTests ( TestCase ) : <EOL> """<STR_LIT>""" <EOL> def test_run ( self ) : <EOL> """<STR_LIT>""" <EOL> virtualenv = VirtualEnv ( root = FilePath ( self . mktemp ( ) ) ) <EOL> step = InstallVirtualEnv ( virtualenv = virtualenv ) <EOL> calls = [ ] <EOL> self . patch ( <EOL> step , '<STR_LIT>' , lambda ** kwargs : calls . append ( kwargs ) ) <EOL> step . run ( ) <EOL> self . assertEqual ( [ dict ( root = virtualenv . root ) ] , calls ) <EOL> class CreateVirtualenvTests ( TestCase ) : <EOL> """<STR_LIT:U+0020>""" <EOL> def test_bin ( self ) : <EOL> """<STR_LIT>""" <EOL> virtualenv = VirtualEnv ( root = FilePath ( self . mktemp ( ) ) ) <EOL> InstallVirtualEnv ( virtualenv = virtualenv ) . run ( ) <EOL> expected_paths = [ '<STR_LIT>' , '<STR_LIT>' ] <EOL> assert_has_paths ( self , expected_paths , virtualenv . root ) <EOL> def test_pythonpath ( self ) : <EOL> """<STR_LIT>""" <EOL> target_path = FilePath ( self . mktemp ( ) ) <EOL> create_virtualenv ( root = target_path ) <EOL> output = check_output ( [ <EOL> target_path . descendant ( [ '<STR_LIT>' , '<STR_LIT>' ] ) . path , <EOL> '<STR_LIT:-c>' , r'<STR_LIT>' <EOL> ] ) <EOL> self . assertNotIn ( <EOL> '<STR_LIT>' , output . splitlines ( ) ) <EOL> def test_bootstrap_pyc ( self ) : <EOL> """<STR_LIT>""" <EOL> target_path = FilePath ( self . mktemp ( ) ) <EOL> create_virtualenv ( root = target_path ) <EOL> py_files = [ ] <EOL> for module_name in VIRTUALENV_REQUIRED_MODULES : <EOL> py_base = target_path . descendant ( [ '<STR_LIT>' , '<STR_LIT>' , module_name ] ) <EOL> py = py_base . siblingExtension ( '<STR_LIT>' ) <EOL> pyc = py_base . siblingExtension ( '<STR_LIT>' ) <EOL> if py . exists ( ) and False in ( py . islink ( ) , pyc . islink ( ) ) : <EOL> py_files . append ( '<STR_LIT>' . format ( <EOL> '<STR_LIT:/>' . join ( py . segmentsFrom ( target_path ) ) , <EOL> py . realpath ( ) . path , <EOL> '<STR_LIT:/>' . join ( pyc . segmentsFrom ( target_path ) ) , <EOL> pyc . islink ( ) and pyc . realpath ( ) . path or '<STR_LIT>' <EOL> ) ) <EOL> if py_files : <EOL> self . fail ( <EOL> '<STR_LIT>' . format ( <EOL> target_path , '<STR_LIT:\n>' . join ( py_files ) <EOL> ) <EOL> ) <EOL> def test_internal_symlinks_only ( self ) : <EOL> """<STR_LIT>""" <EOL> target_path = FilePath ( self . mktemp ( ) ) <EOL> create_virtualenv ( root = target_path ) <EOL> allowed_targets = ( target_path , FilePath ( '<STR_LIT>' ) , ) <EOL> bad_links = [ ] <EOL> for path in target_path . walk ( ) : <EOL> if path . islink ( ) : <EOL> realpath = path . realpath ( ) <EOL> for allowed_target in allowed_targets : <EOL> try : <EOL> realpath . segmentsFrom ( allowed_target ) <EOL> except ValueError : <EOL> pass <EOL> else : <EOL> break <EOL> else : <EOL> bad_links . append ( path ) <EOL> if bad_links : <EOL> self . fail ( <EOL> "<STR_LIT>" + <EOL> '<STR_LIT:\n>' . join ( <EOL> '<STR_LIT:/>' . join ( <EOL> path . segmentsFrom ( target_path ) <EOL> ) + '<STR_LIT>' + path . realpath ( ) . path <EOL> for path in bad_links <EOL> ) <EOL> ) <EOL> class VirtualEnvTests ( TestCase ) : <EOL> """<STR_LIT>""" <EOL> def test_install ( self ) : <EOL> """<STR_LIT>""" <EOL> virtualenv_dir = FilePath ( self . mktemp ( ) ) <EOL> virtualenv = create_virtualenv ( root = virtualenv_dir ) <EOL> package_dir = FilePath ( self . mktemp ( ) ) <EOL> package = canned_package ( package_dir ) <EOL> virtualenv . install ( package_dir . path ) <EOL> self . assertIn ( <EOL> '<STR_LIT>' . format ( package . name , package . version ) , <EOL> [ f . basename ( ) for f in virtualenv_dir . descendant ( <EOL> [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] ) . children ( ) ] <EOL> ) <EOL> class InstallApplicationTests ( TestCase ) : <EOL> """<STR_LIT>""" <EOL> def test_run ( self ) : <EOL> """<STR_LIT>""" <EOL> package_uri = '<STR_LIT>' <EOL> fake_env = SpyVirtualEnv ( ) <EOL> InstallApplication ( <EOL> virtualenv = fake_env , <EOL> package_uri = package_uri <EOL> ) . run ( ) <EOL> self . assertEqual ( <EOL> [ package_uri ] , fake_env . _installed_packages ) <EOL> class CreateLinksTests ( TestCase ) : <EOL> """<STR_LIT>""" <EOL> def test_run ( self ) : <EOL> """<STR_LIT>""" <EOL> root = FilePath ( self . mktemp ( ) ) <EOL> bin_dir = root . descendant ( [ '<STR_LIT>' , '<STR_LIT>' ] ) <EOL> bin_dir . makedirs ( ) <EOL> CreateLinks ( <EOL> links = frozenset ( [ <EOL> ( FilePath ( '<STR_LIT>' ) , bin_dir ) , <EOL> ( FilePath ( '<STR_LIT>' ) , bin_dir ) , <EOL> ] ) <EOL> ) . run ( ) <EOL> self . assertEqual ( <EOL> set ( FilePath ( '<STR_LIT>' ) . child ( script ) <EOL> for script in ( '<STR_LIT>' , '<STR_LIT>' ) ) , <EOL> set ( child . realpath ( ) for child in bin_dir . children ( ) ) <EOL> ) <EOL> def canned_package ( root , version = b'<STR_LIT>' ) : <EOL> """<STR_LIT>""" <EOL> name = '<STR_LIT>' <EOL> root . makedirs ( ) <EOL> setup_py = root . child ( '<STR_LIT>' ) <EOL> setup_py . setContent ( <EOL> dedent ( """<STR_LIT>""" ) . format ( package_name = name , package_version = version ) <EOL> ) <EOL> package_module = root . child ( name + "<STR_LIT>" ) <EOL> package_module . setContent ( <EOL> dedent ( """<STR_LIT>""" ) . format ( package_version = version ) <EOL> ) <EOL> return PythonPackage ( name = name , version = version ) <EOL> class GetPackageVersionTests ( TestCase ) : <EOL> """<STR_LIT>""" <EOL> def test_version_default ( self ) : <EOL> """<STR_LIT>""" <EOL> step = GetPackageVersion ( virtualenv = None , package_name = None ) <EOL> self . assertIs ( None , step . version ) <EOL> def assert_version_found ( self , version ) : <EOL> """<STR_LIT>""" <EOL> test_env = FilePath ( self . mktemp ( ) ) <EOL> virtualenv = VirtualEnv ( root = test_env ) <EOL> InstallVirtualEnv ( virtualenv = virtualenv ) . run ( ) <EOL> package_root = FilePath ( self . mktemp ( ) ) <EOL> test_package = canned_package ( root = package_root , version = version ) <EOL> InstallApplication ( <EOL> virtualenv = virtualenv , package_uri = package_root . path ) . run ( ) <EOL> step = GetPackageVersion ( <EOL> virtualenv = virtualenv , package_name = test_package . name ) <EOL> step . run ( ) <EOL> self . assertEqual ( test_package . version , step . version ) <EOL> def test_version_found ( self ) : <EOL> """<STR_LIT>""" <EOL> versions = [ <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' <EOL> ] <EOL> for version in versions : <EOL> self . assert_version_found ( version = version ) <EOL> def test_version_not_found ( self ) : <EOL> """<STR_LIT>""" <EOL> test_env = FilePath ( self . mktemp ( ) ) <EOL> virtualenv = VirtualEnv ( root = test_env ) <EOL> InstallVirtualEnv ( virtualenv = virtualenv ) . run ( ) <EOL> step = GetPackageVersion ( <EOL> virtualenv = virtualenv , <EOL> package_name = '<STR_LIT>' <EOL> ) <EOL> self . assertRaises ( Exception , step . run ) <EOL> class BuildPackageTests ( TestCase ) : <EOL> """<STR_LIT>""" <EOL> @ require_fpm <EOL> def setUp ( self ) : <EOL> super ( BuildPackageTests , self ) . setUp ( ) <EOL> @ require_rpm <EOL> def test_rpm ( self ) : <EOL> """<STR_LIT>""" <EOL> destination_path = FilePath ( self . mktemp ( ) ) <EOL> destination_path . makedirs ( ) <EOL> source_path = FilePath ( self . mktemp ( ) ) <EOL> source_path . makedirs ( ) <EOL> source_path . child ( '<STR_LIT>' ) . touch ( ) <EOL> source_path . child ( '<STR_LIT>' ) . touch ( ) <EOL> expected_prefix = FilePath ( '<STR_LIT>' ) <EOL> expected_paths = set ( [ <EOL> expected_prefix . child ( '<STR_LIT>' ) , <EOL> expected_prefix . child ( '<STR_LIT>' ) , <EOL> FilePath ( '<STR_LIT>' ) , <EOL> ] ) <EOL> expected_name = '<STR_LIT>' <EOL> expected_epoch = b'<STR_LIT:3>' <EOL> expected_rpm_version = RPMVersion ( version = '<STR_LIT>' , release = '<STR_LIT>' ) <EOL> expected_license = '<STR_LIT>' <EOL> expected_url = '<STR_LIT>' <EOL> expected_vendor = '<STR_LIT>' <EOL> expected_maintainer = '<STR_LIT>' <EOL> expected_architecture = '<STR_LIT>' <EOL> expected_description = '<STR_LIT>' <EOL> expected_dependencies = [ '<STR_LIT>' , '<STR_LIT>' ] <EOL> BuildPackage ( <EOL> package_type = PackageTypes . RPM , <EOL> destination_path = destination_path , <EOL> source_paths = { <EOL> source_path : FilePath ( '<STR_LIT>' ) , <EOL> source_path . child ( '<STR_LIT>' ) : FilePath ( '<STR_LIT>' ) , <EOL> } , <EOL> name = expected_name , <EOL> prefix = FilePath ( '<STR_LIT:/>' ) , <EOL> epoch = expected_epoch , <EOL> rpm_version = expected_rpm_version , <EOL> license = expected_license , <EOL> url = expected_url , <EOL> vendor = expected_vendor , <EOL> maintainer = expected_maintainer , <EOL> architecture = expected_architecture , <EOL> description = expected_description , <EOL> category = "<STR_LIT>" , <EOL> dependencies = [ <EOL> Dependency ( package = '<STR_LIT>' ) , <EOL> Dependency ( package = '<STR_LIT>' , compare = '<STR_LIT>' , version = '<STR_LIT>' ) ] , <EOL> ) . run ( ) <EOL> rpms = glob ( '<STR_LIT>' . format ( <EOL> destination_path . child ( expected_name ) . path ) ) <EOL> self . assertEqual ( <NUM_LIT:1> , len ( rpms ) ) <EOL> expected_headers = dict ( <EOL> Name = expected_name , <EOL> Epoch = expected_epoch , <EOL> Version = expected_rpm_version . version , <EOL> Release = expected_rpm_version . release , <EOL> License = expected_license , <EOL> URL = expected_url , <EOL> Vendor = expected_vendor , <EOL> Packager = expected_maintainer , <EOL> Architecture = expected_architecture , <EOL> Group = "<STR_LIT>" , <EOL> ) <EOL> rpm_path = FilePath ( rpms [ <NUM_LIT:0> ] ) <EOL> assert_rpm_requires ( self , expected_dependencies , rpm_path ) <EOL> assert_rpm_headers ( self , expected_headers , rpm_path ) <EOL> assert_rpm_content ( self , expected_paths , rpm_path ) <EOL> @ require_dpkg <EOL> def test_deb ( self ) : <EOL> """<STR_LIT>""" <EOL> destination_path = FilePath ( self . mktemp ( ) ) <EOL> destination_path . makedirs ( ) <EOL> source_path = FilePath ( self . mktemp ( ) ) <EOL> source_path . makedirs ( ) <EOL> source_path . child ( '<STR_LIT>' ) . touch ( ) <EOL> source_path . child ( '<STR_LIT>' ) . touch ( ) <EOL> expected_prefix = FilePath ( '<STR_LIT>' ) <EOL> expected_paths = set ( [ <EOL> expected_prefix . child ( '<STR_LIT>' ) , <EOL> expected_prefix . child ( '<STR_LIT>' ) , <EOL> FilePath ( '<STR_LIT>' ) , <EOL> FilePath ( '<STR_LIT>' ) , <EOL> ] ) <EOL> expected_name = '<STR_LIT>' . lower ( ) <EOL> expected_epoch = b'<STR_LIT:3>' <EOL> expected_rpm_version = RPMVersion ( version = '<STR_LIT>' , release = '<STR_LIT>' ) <EOL> expected_license = '<STR_LIT>' <EOL> expected_url = '<STR_LIT>' <EOL> expected_vendor = '<STR_LIT>' <EOL> expected_maintainer = '<STR_LIT>' <EOL> expected_architecture = '<STR_LIT>' <EOL> expected_description = '<STR_LIT>' <EOL> BuildPackage ( <EOL> package_type = PackageTypes . DEB , <EOL> destination_path = destination_path , <EOL> source_paths = { <EOL> source_path : FilePath ( '<STR_LIT>' ) , <EOL> source_path . child ( '<STR_LIT>' ) : FilePath ( '<STR_LIT>' ) , <EOL> } , <EOL> name = expected_name , <EOL> prefix = FilePath ( "<STR_LIT:/>" ) , <EOL> epoch = expected_epoch , <EOL> rpm_version = expected_rpm_version , <EOL> license = expected_license , <EOL> url = expected_url , <EOL> vendor = expected_vendor , <EOL> maintainer = expected_maintainer , <EOL> architecture = expected_architecture , <EOL> description = expected_description , <EOL> category = "<STR_LIT>" , <EOL> dependencies = [ <EOL> Dependency ( package = '<STR_LIT>' ) , <EOL> Dependency ( package = '<STR_LIT>' , compare = '<STR_LIT>' , version = '<STR_LIT>' ) ] , <EOL> ) . run ( ) <EOL> packages = glob ( '<STR_LIT>' . format ( <EOL> destination_path . child ( expected_name . lower ( ) ) . path ) ) <EOL> self . assertEqual ( <NUM_LIT:1> , len ( packages ) ) <EOL> expected_headers = dict ( <EOL> Package = expected_name , <EOL> Version = ( <EOL> expected_epoch + <EOL> b'<STR_LIT::>' + <EOL> expected_rpm_version . version + <EOL> '<STR_LIT:->' + <EOL> expected_rpm_version . release <EOL> ) , <EOL> License = expected_license , <EOL> Vendor = expected_vendor , <EOL> Architecture = expected_architecture , <EOL> Maintainer = expected_maintainer , <EOL> Homepage = expected_url , <EOL> Depends = '<STR_LIT:U+002CU+0020>' . join ( [ '<STR_LIT>' , '<STR_LIT>' ] ) , <EOL> Section = "<STR_LIT>" , <EOL> ) <EOL> assert_deb_headers ( self , expected_headers , FilePath ( packages [ <NUM_LIT:0> ] ) ) <EOL> assert_deb_content ( self , expected_paths , FilePath ( packages [ <NUM_LIT:0> ] ) ) <EOL> class LintPackageTests ( TestCase ) : <EOL> """<STR_LIT>""" <EOL> @ require_fpm <EOL> def setUp ( self ) : <EOL> super ( LintPackageTests , self ) . setUp ( ) <EOL> def assert_lint ( self , package_type , expected_output ) : <EOL> """<STR_LIT>""" <EOL> destination_path = FilePath ( self . mktemp ( ) ) <EOL> destination_path . makedirs ( ) <EOL> source_path = FilePath ( self . mktemp ( ) ) <EOL> source_path . makedirs ( ) <EOL> source_path . child ( '<STR_LIT>' ) . touch ( ) <EOL> source_path . child ( '<STR_LIT>' ) . touch ( ) <EOL> BuildPackage ( <EOL> package_type = package_type , <EOL> destination_path = destination_path , <EOL> source_paths = { <EOL> source_path : FilePath ( '<STR_LIT>' ) , <EOL> source_path . child ( '<STR_LIT>' ) : FilePath ( '<STR_LIT>' ) , <EOL> } , <EOL> name = "<STR_LIT>" , <EOL> prefix = FilePath ( '<STR_LIT:/>' ) , <EOL> epoch = b'<STR_LIT:3>' , <EOL> rpm_version = RPMVersion ( version = '<STR_LIT>' , release = '<STR_LIT>' ) , <EOL> license = "<STR_LIT>" , <EOL> url = "<STR_LIT>" , <EOL> vendor = "<STR_LIT>" , <EOL> maintainer = '<STR_LIT>' , <EOL> architecture = "<STR_LIT:all>" , <EOL> description = "<STR_LIT>" , <EOL> category = "<STR_LIT:none>" , <EOL> dependencies = [ ] <EOL> ) . run ( ) <EOL> step = LintPackage ( <EOL> package_type = package_type , <EOL> destination_path = destination_path , <EOL> epoch = b'<STR_LIT:3>' , <EOL> rpm_version = RPMVersion ( version = '<STR_LIT>' , release = '<STR_LIT>' ) , <EOL> package = '<STR_LIT>' , <EOL> architecture = '<STR_LIT:all>' <EOL> ) <EOL> step . output = StringIO ( ) <EOL> self . assertRaises ( SystemExit , step . run ) <EOL> self . assertEqual ( step . output . getvalue ( ) , expected_output ) <EOL> @ require_not_ubuntu <EOL> @ require_rpmlint <EOL> def test_rpm ( self ) : <EOL> """<STR_LIT>""" <EOL> self . assert_lint ( PackageTypes . RPM , b"""<STR_LIT>""" ) <EOL> @ require_lintian <EOL> def test_deb ( self ) : <EOL> """<STR_LIT>""" <EOL> self . assert_lint ( PackageTypes . DEB , b"""<STR_LIT>""" ) <EOL> class OmnibusPackageBuilderTests ( TestCase ) : <EOL> """<STR_LIT>""" <EOL> def test_centos_7 ( self ) : <EOL> self . assert_omnibus_steps ( <EOL> distribution = Distribution ( name = '<STR_LIT>' , version = '<STR_LIT>' ) , <EOL> expected_category = '<STR_LIT>' , <EOL> expected_package_type = PackageTypes . RPM , <EOL> ) <EOL> def test_ubuntu_14_04 ( self ) : <EOL> self . assert_omnibus_steps ( <EOL> distribution = Distribution ( name = '<STR_LIT>' , version = '<STR_LIT>' ) , <EOL> expected_category = '<STR_LIT>' , <EOL> expected_package_type = PackageTypes . DEB , <EOL> ) <EOL> def assert_omnibus_steps ( <EOL> self , <EOL> distribution = Distribution ( name = '<STR_LIT>' , version = '<STR_LIT>' ) , <EOL> expected_category = '<STR_LIT>' , <EOL> expected_package_type = PackageTypes . RPM , <EOL> ) : <EOL> """<STR_LIT>""" <EOL> self . patch ( packaging , '<STR_LIT>' , distribution ) <EOL> fake_dependencies = { <EOL> '<STR_LIT>' : [ Dependency ( package = '<STR_LIT>' ) ] , <EOL> '<STR_LIT>' : [ Dependency ( package = '<STR_LIT>' ) ] , <EOL> '<STR_LIT>' : [ Dependency ( package = '<STR_LIT>' ) ] , <EOL> '<STR_LIT>' : [ Dependency ( package = '<STR_LIT>' ) ] , <EOL> } <EOL> def fake_make_dependencies ( <EOL> package_name , package_version , distribution ) : <EOL> return fake_dependencies [ package_name ] <EOL> self . patch ( packaging , '<STR_LIT>' , fake_make_dependencies ) <EOL> expected_destination_path = FilePath ( self . mktemp ( ) ) <EOL> target_path = FilePath ( self . mktemp ( ) ) <EOL> flocker_cli_path = target_path . child ( '<STR_LIT>' ) <EOL> flocker_node_path = target_path . child ( '<STR_LIT>' ) <EOL> flocker_docker_plugin_path = target_path . child ( '<STR_LIT>' ) <EOL> flocker_shared_path = target_path . child ( '<STR_LIT>' ) <EOL> empty_path = target_path . child ( '<STR_LIT>' ) <EOL> expected_virtualenv_path = FilePath ( '<STR_LIT>' ) <EOL> expected_prefix = FilePath ( '<STR_LIT:/>' ) <EOL> expected_epoch = PACKAGE . EPOCH . value <EOL> expected_package_uri = b'<STR_LIT>' <EOL> expected_package_version_step = GetPackageVersion ( <EOL> virtualenv = VirtualEnv ( root = expected_virtualenv_path ) , <EOL> package_name = '<STR_LIT>' <EOL> ) <EOL> expected_version = DelayedRpmVersion ( <EOL> package_version_step = expected_package_version_step <EOL> ) <EOL> expected_license = PACKAGE . LICENSE . value <EOL> expected_url = PACKAGE . URL . value <EOL> expected_vendor = PACKAGE . VENDOR . value <EOL> expected_maintainer = PACKAGE . MAINTAINER . value <EOL> package_files = FilePath ( '<STR_LIT>' ) <EOL> virtualenv = VirtualEnv ( root = expected_virtualenv_path ) <EOL> expected = BuildSequence ( <EOL> steps = ( <EOL> InstallVirtualEnv ( virtualenv = virtualenv ) , <EOL> InstallApplication ( virtualenv = virtualenv , <EOL> package_uri = '<STR_LIT>' ) , <EOL> InstallApplication ( virtualenv = virtualenv , <EOL> package_uri = '<STR_LIT>' ) , <EOL> InstallApplication ( <EOL> virtualenv = VirtualEnv ( root = expected_virtualenv_path ) , <EOL> package_uri = b'<STR_LIT>' , <EOL> ) , <EOL> expected_package_version_step , <EOL> CreateLinks ( <EOL> links = [ <EOL> ( FilePath ( '<STR_LIT>' ) , <EOL> flocker_shared_path ) , <EOL> ( FilePath ( '<STR_LIT>' ) , <EOL> flocker_shared_path ) , <EOL> ] , <EOL> ) , <EOL> BuildPackage ( <EOL> package_type = expected_package_type , <EOL> destination_path = expected_destination_path , <EOL> source_paths = { <EOL> expected_virtualenv_path : expected_virtualenv_path , <EOL> flocker_shared_path : FilePath ( "<STR_LIT>" ) , <EOL> } , <EOL> name = '<STR_LIT>' , <EOL> prefix = expected_prefix , <EOL> epoch = expected_epoch , <EOL> rpm_version = expected_version , <EOL> license = expected_license , <EOL> url = expected_url , <EOL> vendor = expected_vendor , <EOL> maintainer = expected_maintainer , <EOL> architecture = '<STR_LIT>' , <EOL> description = PACKAGE_PYTHON . DESCRIPTION . value , <EOL> category = expected_category , <EOL> directories = [ expected_virtualenv_path ] , <EOL> dependencies = [ Dependency ( package = '<STR_LIT>' ) ] , <EOL> ) , <EOL> LintPackage ( <EOL> package_type = expected_package_type , <EOL> destination_path = expected_destination_path , <EOL> epoch = expected_epoch , <EOL> rpm_version = expected_version , <EOL> package = '<STR_LIT>' , <EOL> architecture = "<STR_LIT>" , <EOL> ) , <EOL> CreateLinks ( <EOL> links = [ <EOL> ( FilePath ( '<STR_LIT>' ) , <EOL> flocker_cli_path ) , <EOL> ( FilePath ( '<STR_LIT>' ) , <EOL> flocker_cli_path ) , <EOL> ( FilePath ( '<STR_LIT>' ) , <EOL> flocker_cli_path ) , <EOL> ] <EOL> ) , <EOL> BuildPackage ( <EOL> package_type = expected_package_type , <EOL> destination_path = expected_destination_path , <EOL> source_paths = { flocker_cli_path : FilePath ( "<STR_LIT>" ) } , <EOL> name = '<STR_LIT>' , <EOL> prefix = expected_prefix , <EOL> epoch = expected_epoch , <EOL> rpm_version = expected_version , <EOL> license = expected_license , <EOL> url = expected_url , <EOL> vendor = expected_vendor , <EOL> maintainer = expected_maintainer , <EOL> architecture = '<STR_LIT:all>' , <EOL> description = PACKAGE_CLI . DESCRIPTION . value , <EOL> category = expected_category , <EOL> dependencies = [ Dependency ( package = '<STR_LIT>' ) ] , <EOL> ) , <EOL> LintPackage ( <EOL> package_type = expected_package_type , <EOL> destination_path = expected_destination_path , <EOL> epoch = expected_epoch , <EOL> rpm_version = expected_version , <EOL> package = '<STR_LIT>' , <EOL> architecture = "<STR_LIT:all>" , <EOL> ) , <EOL> CreateLinks ( <EOL> links = [ <EOL> ( FilePath ( '<STR_LIT>' ) , <EOL> flocker_node_path ) , <EOL> ( FilePath ( '<STR_LIT>' ) , <EOL> flocker_node_path ) , <EOL> ( FilePath ( '<STR_LIT>' ) , <EOL> flocker_node_path ) , <EOL> ( FilePath ( '<STR_LIT>' ) , <EOL> flocker_node_path ) , <EOL> ( FilePath ( '<STR_LIT>' ) , <EOL> flocker_node_path ) , <EOL> ( FilePath ( '<STR_LIT>' ) , <EOL> flocker_node_path ) , <EOL> ( FilePath ( '<STR_LIT>' ) , <EOL> flocker_node_path ) , <EOL> ] <EOL> ) , <EOL> BuildPackage ( <EOL> package_type = expected_package_type , <EOL> destination_path = expected_destination_path , <EOL> source_paths = { <EOL> flocker_node_path : FilePath ( "<STR_LIT>" ) , <EOL> package_files . child ( '<STR_LIT>' ) : <EOL> FilePath ( "<STR_LIT>" ) , <EOL> package_files . child ( '<STR_LIT>' ) : <EOL> FilePath ( "<STR_LIT>" ) , <EOL> package_files . child ( '<STR_LIT>' ) : <EOL> FilePath ( "<STR_LIT>" ) , <EOL> package_files . child ( '<STR_LIT>' ) : <EOL> FilePath ( '<STR_LIT>' ) , <EOL> package_files . child ( b'<STR_LIT>' ) : <EOL> FilePath ( b"<STR_LIT>" ) , <EOL> empty_path : FilePath ( '<STR_LIT>' ) , <EOL> } , <EOL> name = '<STR_LIT>' , <EOL> prefix = expected_prefix , <EOL> epoch = expected_epoch , <EOL> rpm_version = expected_version , <EOL> license = expected_license , <EOL> url = expected_url , <EOL> vendor = expected_vendor , <EOL> maintainer = expected_maintainer , <EOL> architecture = '<STR_LIT:all>' , <EOL> description = PACKAGE_NODE . DESCRIPTION . value , <EOL> category = expected_category , <EOL> dependencies = [ Dependency ( package = '<STR_LIT>' ) ] , <EOL> after_install = package_files . child ( '<STR_LIT>' ) , <EOL> directories = [ FilePath ( '<STR_LIT>' ) ] , <EOL> ) , <EOL> LintPackage ( <EOL> package_type = expected_package_type , <EOL> destination_path = expected_destination_path , <EOL> epoch = expected_epoch , <EOL> rpm_version = expected_version , <EOL> package = '<STR_LIT>' , <EOL> architecture = "<STR_LIT:all>" , <EOL> ) , <EOL> CreateLinks ( <EOL> links = [ <EOL> ( FilePath ( '<STR_LIT>' ) , <EOL> flocker_docker_plugin_path ) , <EOL> ] <EOL> ) , <EOL> BuildPackage ( <EOL> package_type = expected_package_type , <EOL> destination_path = expected_destination_path , <EOL> source_paths = { <EOL> flocker_docker_plugin_path : FilePath ( "<STR_LIT>" ) , <EOL> package_files . child ( '<STR_LIT>' ) . child ( '<STR_LIT>' ) : <EOL> FilePath ( '<STR_LIT>' ) , <EOL> package_files . child ( '<STR_LIT>' ) . child ( '<STR_LIT>' ) : <EOL> FilePath ( '<STR_LIT>' ) , <EOL> } , <EOL> name = '<STR_LIT>' , <EOL> prefix = FilePath ( '<STR_LIT:/>' ) , <EOL> epoch = expected_epoch , <EOL> rpm_version = expected_version , <EOL> license = PACKAGE . LICENSE . value , <EOL> url = PACKAGE . URL . value , <EOL> vendor = PACKAGE . VENDOR . value , <EOL> maintainer = PACKAGE . MAINTAINER . value , <EOL> architecture = "<STR_LIT:all>" , <EOL> description = PACKAGE_DOCKER_PLUGIN . DESCRIPTION . value , <EOL> category = expected_category , <EOL> dependencies = [ Dependency ( package = '<STR_LIT>' ) ] , <EOL> ) , <EOL> LintPackage ( <EOL> package_type = distribution . package_type ( ) , <EOL> destination_path = expected_destination_path , <EOL> epoch = expected_epoch , <EOL> rpm_version = expected_version , <EOL> package = '<STR_LIT>' , <EOL> architecture = "<STR_LIT:all>" , <EOL> ) , <EOL> ) <EOL> ) <EOL> assert_equal_steps ( <EOL> self , <EOL> expected , <EOL> omnibus_package_builder ( distribution = distribution , <EOL> destination_path = expected_destination_path , <EOL> package_uri = expected_package_uri , <EOL> target_dir = target_path , <EOL> package_files = FilePath ( '<STR_LIT>' ) , <EOL> ) ) <EOL> class DockerBuildOptionsTests ( TestCase ) : <EOL> """<STR_LIT>""" <EOL> native_package_type = object ( ) <EOL> def setUp ( self ) : <EOL> """<STR_LIT>""" <EOL> super ( DockerBuildOptionsTests , self ) . setUp ( ) <EOL> self . patch ( <EOL> packaging , '<STR_LIT>' , <EOL> lambda : self . native_package_type ) <EOL> def test_defaults ( self ) : <EOL> """<STR_LIT>""" <EOL> expected_defaults = { <EOL> '<STR_LIT>' : '<STR_LIT:.>' , <EOL> } <EOL> self . assertEqual ( expected_defaults , DockerBuildOptions ( ) ) <EOL> def test_package_uri_missing ( self ) : <EOL> """<STR_LIT>""" <EOL> exception = self . assertRaises ( <EOL> UsageError , DockerBuildOptions ( ) . parseOptions , [ ] ) <EOL> self . assertEqual ( '<STR_LIT>' , str ( exception ) ) <EOL> def test_package_uri_supplied ( self ) : <EOL> """<STR_LIT>""" <EOL> expected_uri = '<STR_LIT>' <EOL> options = DockerBuildOptions ( ) <EOL> options . parseOptions ( [ expected_uri ] ) <EOL> self . assertEqual ( expected_uri , options [ '<STR_LIT>' ] ) <EOL> class DockerBuildScriptTests ( TestCase ) : <EOL> """<STR_LIT>""" <EOL> def test_usage_error_status ( self ) : <EOL> """<STR_LIT>""" <EOL> fake_sys_module = FakeSysModule ( argv = [ ] ) <EOL> script = DockerBuildScript ( sys_module = fake_sys_module ) <EOL> exception = self . assertRaises ( SystemExit , script . main ) <EOL> self . assertEqual ( <NUM_LIT:1> , exception . code ) <EOL> def test_usage_error_message ( self ) : <EOL> """<STR_LIT>""" <EOL> fake_sys_module = FakeSysModule ( argv = [ ] ) <EOL> script = DockerBuildScript ( sys_module = fake_sys_module ) <EOL> try : <EOL> script . main ( ) <EOL> except SystemExit : <EOL> pass <EOL> self . assertEqual ( <EOL> '<STR_LIT>' , <EOL> fake_sys_module . stderr . getvalue ( ) . splitlines ( ) [ - <NUM_LIT:1> ] <EOL> ) <EOL> def test_build_command ( self ) : <EOL> """<STR_LIT>""" <EOL> self . assertIs ( omnibus_package_builder , DockerBuildScript . build_command ) <EOL> def test_run ( self ) : <EOL> """<STR_LIT>""" <EOL> expected_destination_path = FilePath ( self . mktemp ( ) ) <EOL> expected_package_uri = '<STR_LIT>' <EOL> fake_sys_module = FakeSysModule ( <EOL> argv = [ <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' % ( expected_destination_path . path , ) , <EOL> expected_package_uri ] <EOL> ) <EOL> distribution = Distribution ( name = '<STR_LIT>' , version = '<STR_LIT>' ) <EOL> self . patch ( packaging , '<STR_LIT>' , distribution ) <EOL> script = DockerBuildScript ( sys_module = fake_sys_module ) <EOL> build_step = SpyStep ( ) <EOL> arguments = [ ] <EOL> def record_arguments ( * args , ** kwargs ) : <EOL> arguments . append ( ( args , kwargs ) ) <EOL> return build_step <EOL> script . build_command = record_arguments <EOL> script . main ( top_level = FilePath ( '<STR_LIT>' ) ) <EOL> expected_build_arguments = [ ( <EOL> ( ) , <EOL> dict ( destination_path = expected_destination_path , <EOL> package_uri = expected_package_uri , <EOL> distribution = distribution , <EOL> package_files = FilePath ( '<STR_LIT>' ) ) <EOL> ) ] <EOL> self . assertEqual ( expected_build_arguments , arguments ) <EOL> self . assertTrue ( build_step . ran ) <EOL> class BuildOptionsTests ( TestCase ) : <EOL> """<STR_LIT>""" <EOL> DISTROS = [ u"<STR_LIT>" ] <EOL> def test_defaults ( self ) : <EOL> """<STR_LIT>""" <EOL> expected_defaults = { <EOL> '<STR_LIT>' : '<STR_LIT:.>' , <EOL> '<STR_LIT>' : None , <EOL> } <EOL> self . assertEqual ( expected_defaults , BuildOptions ( [ ] ) ) <EOL> def test_possible_distributions ( self ) : <EOL> """<STR_LIT>""" <EOL> options = BuildOptions ( [ b"<STR_LIT>" , b"<STR_LIT>" ] ) <EOL> description = options . docs [ "<STR_LIT>" ] <EOL> self . assertNotIn ( <EOL> - <NUM_LIT:1> , <EOL> ( description . find ( b"<STR_LIT>" ) , description . find ( b"<STR_LIT>" ) ) , <EOL> "<STR_LIT>" <EOL> "<STR_LIT>" . format ( description ) <EOL> ) <EOL> def test_distribution_missing ( self ) : <EOL> """<STR_LIT>""" <EOL> options = BuildOptions ( self . DISTROS ) <EOL> self . assertRaises ( <EOL> UsageError , <EOL> options . parseOptions , <EOL> [ '<STR_LIT>' ] ) <EOL> def test_package_uri_missing ( self ) : <EOL> """<STR_LIT>""" <EOL> exception = self . assertRaises ( <EOL> UsageError , BuildOptions ( self . DISTROS ) . parseOptions , [ ] ) <EOL> self . assertEqual ( '<STR_LIT>' , str ( exception ) ) <EOL> def test_package_options_supplied ( self ) : <EOL> """<STR_LIT>""" <EOL> expected_uri = '<STR_LIT>' <EOL> expected_distribution = '<STR_LIT>' <EOL> options = BuildOptions ( self . DISTROS + [ expected_distribution ] ) <EOL> options . parseOptions ( <EOL> [ '<STR_LIT>' , expected_distribution , expected_uri ] ) <EOL> self . assertEqual ( <EOL> ( expected_distribution , expected_uri ) , <EOL> ( options [ '<STR_LIT>' ] , options [ '<STR_LIT>' ] ) <EOL> ) <EOL> class AvailableDistributionTests ( TestCase ) : <EOL> """<STR_LIT>""" <EOL> def test_dockerfiles ( self ) : <EOL> """<STR_LIT>""" <EOL> root = FilePath ( self . mktemp ( ) ) <EOL> build_targets = root . descendant ( [ b"<STR_LIT>" , b"<STR_LIT>" ] ) <EOL> build_targets . makedirs ( ) <EOL> build_targets . child ( b"<STR_LIT:foo>" ) . setContent ( b"<STR_LIT:bar>" ) <EOL> greatos = build_targets . child ( b"<STR_LIT>" ) <EOL> greatos . makedirs ( ) <EOL> greatos . child ( b"<STR_LIT>" ) . setContent ( <EOL> b"<STR_LIT>" <EOL> ) <EOL> nothing = build_targets . child ( b"<STR_LIT>" ) <EOL> nothing . makedirs ( ) <EOL> self . assertEqual ( <EOL> { b"<STR_LIT>" } , <EOL> available_distributions ( root ) , <EOL> ) <EOL> class BuildScriptTests ( TestCase ) : <EOL> """<STR_LIT>""" <EOL> def test_usage_error_status ( self ) : <EOL> """<STR_LIT>""" <EOL> fake_sys_module = FakeSysModule ( argv = [ ] ) <EOL> script = BuildScript ( sys_module = fake_sys_module ) <EOL> exception = self . assertRaises ( <EOL> SystemExit , <EOL> script . main , top_level = FLOCKER_PATH ) <EOL> self . assertEqual ( <NUM_LIT:1> , exception . code ) <EOL> def test_usage_error_message ( self ) : <EOL> """<STR_LIT>""" <EOL> fake_sys_module = FakeSysModule ( argv = [ ] ) <EOL> script = BuildScript ( sys_module = fake_sys_module ) <EOL> try : <EOL> script . main ( top_level = FLOCKER_PATH ) <EOL> except SystemExit : <EOL> pass <EOL> self . assertEqual ( <EOL> '<STR_LIT>' , <EOL> fake_sys_module . stderr . getvalue ( ) . splitlines ( ) [ - <NUM_LIT:1> ] <EOL> ) <EOL> def test_build_command ( self ) : <EOL> """<STR_LIT>""" <EOL> self . assertIs ( build_in_docker , BuildScript . build_command ) <EOL> def test_run ( self ) : <EOL> """<STR_LIT>""" <EOL> expected_destination_path = FilePath ( self . mktemp ( ) ) <EOL> expected_distribution = '<STR_LIT>' <EOL> expected_package_uri = '<STR_LIT>' <EOL> fake_sys_module = FakeSysModule ( <EOL> argv = [ <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , expected_destination_path . path , <EOL> '<STR_LIT>' % ( expected_distribution , ) , <EOL> expected_package_uri ] <EOL> ) <EOL> script = BuildScript ( sys_module = fake_sys_module ) <EOL> build_step = SpyStep ( ) <EOL> arguments = [ ] <EOL> def record_arguments ( * args , ** kwargs ) : <EOL> arguments . append ( ( args , kwargs ) ) <EOL> return build_step <EOL> script . build_command = record_arguments <EOL> script . main ( top_level = FLOCKER_PATH ) <EOL> expected_build_arguments = [ ( <EOL> ( ) , <EOL> dict ( destination_path = expected_destination_path , <EOL> distribution = expected_distribution , <EOL> package_uri = expected_package_uri , <EOL> top_level = FLOCKER_PATH ) <EOL> ) ] <EOL> self . assertEqual ( expected_build_arguments , arguments ) <EOL> self . assertTrue ( build_step . ran ) <EOL> class BuildInDockerFunctionTests ( TestCase ) : <EOL> """<STR_LIT>""" <EOL> def test_steps ( self ) : <EOL> """<STR_LIT>""" <EOL> supplied_distribution = '<STR_LIT>' <EOL> expected_tag = '<STR_LIT>' % ( supplied_distribution , ) <EOL> supplied_top_level = FilePath ( self . mktemp ( ) ) <EOL> expected_build_directory = supplied_top_level . descendant ( <EOL> [ '<STR_LIT>' , '<STR_LIT>' , supplied_distribution ] ) <EOL> expected_build_directory . makedirs ( ) <EOL> expected_build_directory . sibling ( '<STR_LIT>' ) . setContent ( '<STR_LIT>' ) <EOL> supplied_destination_path = FilePath ( '<STR_LIT>' ) <EOL> expected_volumes = { <EOL> FilePath ( '<STR_LIT>' ) : supplied_destination_path , <EOL> FilePath ( '<STR_LIT>' ) : supplied_top_level , <EOL> } <EOL> expected_package_uri = '<STR_LIT>' <EOL> assert_equal_steps ( <EOL> test_case = self , <EOL> expected = BuildSequence ( <EOL> steps = [ <EOL> DockerBuild ( <EOL> tag = expected_tag , <EOL> build_directory = expected_build_directory <EOL> ) , <EOL> DockerRun ( <EOL> tag = expected_tag , <EOL> volumes = expected_volumes , <EOL> command = [ expected_package_uri ] <EOL> ) , <EOL> ] <EOL> ) , <EOL> actual = build_in_docker ( <EOL> destination_path = supplied_destination_path , <EOL> distribution = supplied_distribution , <EOL> top_level = supplied_top_level , <EOL> package_uri = expected_package_uri , <EOL> ) <EOL> ) <EOL> def test_copies_requirements ( self ) : <EOL> """<STR_LIT>""" <EOL> supplied_distribution = '<STR_LIT>' <EOL> supplied_top_level = FilePath ( self . mktemp ( ) ) <EOL> expected_build_directory = supplied_top_level . descendant ( <EOL> [ '<STR_LIT>' , '<STR_LIT>' , supplied_distribution ] ) <EOL> expected_build_directory . makedirs ( ) <EOL> requirements = '<STR_LIT>' <EOL> expected_build_directory . sibling ( '<STR_LIT>' ) . setContent ( <EOL> requirements ) <EOL> supplied_destination_path = FilePath ( '<STR_LIT>' ) <EOL> expected_package_uri = '<STR_LIT>' <EOL> build_in_docker ( <EOL> destination_path = supplied_destination_path , <EOL> distribution = supplied_distribution , <EOL> top_level = supplied_top_level , <EOL> package_uri = expected_package_uri <EOL> ) <EOL> self . assertEqual ( <EOL> requirements , <EOL> expected_build_directory . child ( '<STR_LIT>' ) . getContent ( ) <EOL> ) <EOL> class MakeDependenciesTests ( TestCase ) : <EOL> """<STR_LIT>""" <EOL> def test_node ( self ) : <EOL> """<STR_LIT>""" <EOL> expected_version = '<STR_LIT>' <EOL> self . assertIn ( <EOL> Dependency ( <EOL> package = '<STR_LIT>' , <EOL> compare = '<STR_LIT:=>' , <EOL> version = expected_version <EOL> ) , <EOL> make_dependencies ( '<STR_LIT>' , expected_version , <EOL> Distribution ( name = '<STR_LIT>' , version = '<STR_LIT>' ) ) <EOL> ) <EOL> def test_cli ( self ) : <EOL> """<STR_LIT>""" <EOL> expected_version = '<STR_LIT>' <EOL> self . assertIn ( <EOL> Dependency ( <EOL> package = '<STR_LIT>' , <EOL> compare = '<STR_LIT:=>' , <EOL> version = expected_version <EOL> ) , <EOL> make_dependencies ( '<STR_LIT>' , expected_version , <EOL> Distribution ( name = '<STR_LIT>' , version = '<STR_LIT>' ) ) <EOL> ) </s>

<s> """<STR_LIT>""" <EOL> from zope . interface import implementer <EOL> from twisted . internet . defer import Deferred , succeed <EOL> from benchmark . _interfaces import IProbe , IOperation <EOL> @ implementer ( IProbe ) <EOL> class WaitProbe ( object ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , reactor , wait_seconds ) : <EOL> self . reactor = reactor <EOL> self . wait_seconds = wait_seconds <EOL> def run ( self ) : <EOL> d = Deferred ( ) <EOL> self . reactor . callLater ( self . wait_seconds , d . callback , None ) <EOL> return d <EOL> def cleanup ( self ) : <EOL> return succeed ( None ) <EOL> @ implementer ( IOperation ) <EOL> class Wait ( object ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , reactor , cluster , wait_seconds = <NUM_LIT:10> ) : <EOL> self . reactor = reactor <EOL> self . wait_seconds = wait_seconds <EOL> def get_probe ( self ) : <EOL> return WaitProbe ( self . reactor , self . wait_seconds ) </s>

<s> """<STR_LIT>""" <EOL> import os <EOL> from datetime import timedelta <EOL> from uuid import UUID , uuid4 <EOL> from unittest import SkipTest , skipIf <EOL> from testtools import run_test_with <EOL> from testtools . matchers import MatchesListwise , AfterPreprocessing , Equals <EOL> from twisted . internet import reactor <EOL> from flocker import __version__ as HEAD_FLOCKER_VERSION <EOL> from flocker . common . version import get_installable_version <EOL> from ... common import loop_until <EOL> from ... testtools import AsyncTestCase , flaky , async_runner <EOL> from ... node . agents . blockdevice import ICloudAPI <EOL> from ... provision import PackageSource <EOL> from ... node import backends <EOL> from . . testtools import ( <EOL> require_cluster , require_moving_backend , create_dataset , <EOL> skip_backend , get_backend_api , verify_socket , <EOL> get_default_volume_size , ACCEPTANCE_TEST_TIMEOUT <EOL> ) <EOL> class DatasetAPITests ( AsyncTestCase ) : <EOL> """<STR_LIT>""" <EOL> run_tests_with = async_runner ( timeout = ACCEPTANCE_TEST_TIMEOUT ) <EOL> @ flaky ( u'<STR_LIT>' ) <EOL> @ require_cluster ( <NUM_LIT:1> ) <EOL> def test_dataset_creation ( self , cluster ) : <EOL> """<STR_LIT>""" <EOL> return create_dataset ( self , cluster ) <EOL> def _get_package_source ( self , default_version = None ) : <EOL> """<STR_LIT>""" <EOL> env_vars = [ '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' ] <EOL> defaultable = frozenset ( [ '<STR_LIT>' , <EOL> '<STR_LIT>' ] ) <EOL> missing_vars = list ( var for var in env_vars if var not in os . environ ) <EOL> if missing_vars : <EOL> message = ( '<STR_LIT>' % <EOL> '<STR_LIT:U+002CU+0020>' . join ( missing_vars ) ) <EOL> missing_defaultable = list ( var for var in missing_vars <EOL> if var in defaultable ) <EOL> if missing_defaultable : <EOL> message += ( '<STR_LIT>' <EOL> '<STR_LIT>' % <EOL> '<STR_LIT:U+002CU+0020>' . join ( missing_defaultable ) ) <EOL> raise SkipTest ( message ) <EOL> version = ( os . environ [ '<STR_LIT>' ] or <EOL> default_version ) <EOL> return PackageSource ( <EOL> version = version , <EOL> branch = os . environ [ '<STR_LIT>' ] , <EOL> build_server = os . environ [ '<STR_LIT>' ] ) <EOL> @ skip_backend ( <EOL> unsupported = { backends . LOOPBACK } , <EOL> reason = "<STR_LIT>" <EOL> "<STR_LIT>" ) <EOL> @ skip_backend ( <EOL> unsupported = { backends . GCE } , <EOL> reason = "<STR_LIT>" ) <EOL> @ run_test_with ( async_runner ( timeout = timedelta ( minutes = <NUM_LIT:6> ) ) ) <EOL> @ require_cluster ( <NUM_LIT:1> ) <EOL> def test_upgrade ( self , cluster ) : <EOL> """<STR_LIT>""" <EOL> node = cluster . nodes [ <NUM_LIT:0> ] <EOL> SAMPLE_STR = '<STR_LIT>' * <NUM_LIT:100> <EOL> upgrade_from_version = get_installable_version ( HEAD_FLOCKER_VERSION ) <EOL> d = cluster . client . version ( ) <EOL> original_package_source = [ None ] <EOL> def setup_restore_original_flocker ( version ) : <EOL> version_bytes = version . get ( '<STR_LIT>' , u'<STR_LIT>' ) . encode ( '<STR_LIT:ascii>' ) <EOL> original_package_source [ <NUM_LIT:0> ] = ( <EOL> self . _get_package_source ( <EOL> default_version = version_bytes or None ) <EOL> ) <EOL> self . addCleanup ( <EOL> lambda : cluster . install_flocker_version ( <EOL> original_package_source [ <NUM_LIT:0> ] ) ) <EOL> return version <EOL> d . addCallback ( setup_restore_original_flocker ) <EOL> d . addCallback ( lambda _ : cluster . clean_nodes ( ) ) <EOL> d . addCallback ( <EOL> lambda _ : cluster . install_flocker_version ( <EOL> PackageSource ( version = upgrade_from_version ) , <EOL> destroy_persisted_state = True <EOL> ) <EOL> ) <EOL> d . addCallback ( lambda _ : create_dataset ( self , cluster , node = node ) ) <EOL> first_dataset = [ None ] <EOL> def write_to_file ( dataset ) : <EOL> first_dataset [ <NUM_LIT:0> ] = dataset <EOL> return node . run_as_root ( <EOL> [ '<STR_LIT>' , '<STR_LIT:-c>' , '<STR_LIT>' % ( <EOL> SAMPLE_STR , os . path . join ( dataset . path . path , '<STR_LIT>' ) ) ] ) <EOL> d . addCallback ( write_to_file ) <EOL> d . addCallback ( lambda _ : cluster . install_flocker_version ( <EOL> original_package_source [ <NUM_LIT:0> ] ) ) <EOL> d . addCallback ( lambda _ : create_dataset ( self , cluster , node = node ) ) <EOL> d . addCallback ( lambda _ : cluster . wait_for_dataset ( first_dataset [ <NUM_LIT:0> ] ) ) <EOL> def cat_and_verify_file ( dataset ) : <EOL> output = [ ] <EOL> file_catting = node . run_as_root ( <EOL> [ '<STR_LIT>' , '<STR_LIT:-c>' , '<STR_LIT>' % ( <EOL> os . path . join ( dataset . path . path , '<STR_LIT>' ) ) ] , <EOL> handle_stdout = output . append ) <EOL> def verify_file ( _ ) : <EOL> file_contents = '<STR_LIT>' . join ( output ) <EOL> self . assertEqual ( file_contents , SAMPLE_STR ) <EOL> file_catting . addCallback ( verify_file ) <EOL> return file_catting <EOL> d . addCallback ( cat_and_verify_file ) <EOL> return d <EOL> @ require_cluster ( <NUM_LIT:1> , required_backend = backends . AWS ) <EOL> def test_dataset_creation_with_gold_profile ( self , cluster , backend ) : <EOL> """<STR_LIT>""" <EOL> waiting_for_create = create_dataset ( <EOL> self , cluster , maximum_size = <NUM_LIT:4> * <NUM_LIT> * <NUM_LIT> * <NUM_LIT> , <EOL> metadata = { u"<STR_LIT>" : u"<STR_LIT>" } ) <EOL> def confirm_gold ( dataset ) : <EOL> volumes = backend . list_volumes ( ) <EOL> matching = [ <EOL> v for v in volumes if v . dataset_id == dataset . dataset_id ] <EOL> volume_types = [ <EOL> backend . _get_ebs_volume ( v . blockdevice_id ) . volume_type <EOL> for v in matching ] <EOL> self . assertEqual ( volume_types , [ '<STR_LIT>' ] ) <EOL> waiting_for_create . addCallback ( confirm_gold ) <EOL> return waiting_for_create <EOL> @ flaky ( u'<STR_LIT>' ) <EOL> @ require_moving_backend <EOL> @ require_cluster ( <NUM_LIT:2> ) <EOL> def test_dataset_move ( self , cluster ) : <EOL> """<STR_LIT>""" <EOL> waiting_for_create = create_dataset ( self , cluster ) <EOL> def move_dataset ( dataset ) : <EOL> dataset_moving = cluster . client . move_dataset ( <EOL> UUID ( cluster . nodes [ <NUM_LIT:1> ] . uuid ) , dataset . dataset_id ) <EOL> moved_dataset = dataset . set ( <EOL> primary = UUID ( cluster . nodes [ <NUM_LIT:1> ] . uuid ) ) <EOL> dataset_moving . addCallback ( <EOL> lambda dataset : cluster . wait_for_dataset ( moved_dataset ) ) <EOL> return dataset_moving <EOL> waiting_for_create . addCallback ( move_dataset ) <EOL> return waiting_for_create <EOL> @ flaky ( u'<STR_LIT>' ) <EOL> @ require_cluster ( <NUM_LIT:1> ) <EOL> def test_dataset_deletion ( self , cluster ) : <EOL> """<STR_LIT>""" <EOL> created = create_dataset ( self , cluster ) <EOL> def delete_dataset ( dataset ) : <EOL> deleted = cluster . client . delete_dataset ( dataset . dataset_id ) <EOL> def not_exists ( ) : <EOL> request = cluster . client . list_datasets_state ( ) <EOL> request . addCallback ( <EOL> lambda actual_datasets : dataset . dataset_id not in <EOL> ( d . dataset_id for d in actual_datasets ) ) <EOL> return request <EOL> deleted . addCallback ( lambda _ : loop_until ( reactor , not_exists ) ) <EOL> return deleted <EOL> created . addCallback ( delete_dataset ) <EOL> return created <EOL> @ skipIf ( True , <EOL> "<STR_LIT>" <EOL> "<STR_LIT>" ) <EOL> @ require_moving_backend <EOL> @ run_test_with ( async_runner ( timeout = timedelta ( minutes = <NUM_LIT:6> ) ) ) <EOL> @ require_cluster ( <NUM_LIT:2> ) <EOL> def test_dataset_move_from_dead_node ( self , cluster ) : <EOL> """<STR_LIT>""" <EOL> api = get_backend_api ( cluster . cluster_uuid ) <EOL> if not ICloudAPI . providedBy ( api ) : <EOL> raise SkipTest ( <EOL> "<STR_LIT>" <EOL> "<STR_LIT>" <EOL> "<STR_LIT>" ) <EOL> node = list ( node for node in cluster . nodes <EOL> if node . public_address != <EOL> cluster . control_node . public_address ) [ <NUM_LIT:0> ] <EOL> other_node = list ( other_node for other_node in cluster . nodes <EOL> if other_node != node ) [ <NUM_LIT:0> ] <EOL> waiting_for_create = create_dataset ( self , cluster , node = node ) <EOL> def startup_node ( node_id ) : <EOL> api . start_node ( node_id ) <EOL> return loop_until ( reactor , verify_socket ( node . public_address , <NUM_LIT> ) ) <EOL> def shutdown ( dataset ) : <EOL> live_node_ids = set ( api . list_live_nodes ( ) ) <EOL> d = node . shutdown ( ) <EOL> d . addCallback ( <EOL> lambda _ : <EOL> loop_until ( reactor , lambda : <EOL> set ( api . list_live_nodes ( ) ) != live_node_ids ) ) <EOL> d . addCallback ( <EOL> lambda _ : self . addCleanup ( <EOL> startup_node , <EOL> ( live_node_ids - set ( api . list_live_nodes ( ) ) ) . pop ( ) ) ) <EOL> d . addCallback ( lambda _ : dataset ) <EOL> return d <EOL> waiting_for_shutdown = waiting_for_create . addCallback ( shutdown ) <EOL> def move_dataset ( dataset ) : <EOL> dataset_moving = cluster . client . move_dataset ( <EOL> UUID ( other_node . uuid ) , dataset . dataset_id ) <EOL> moved_dataset = dataset . set ( <EOL> primary = UUID ( other_node . uuid ) ) <EOL> dataset_moving . addCallback ( <EOL> lambda dataset : cluster . wait_for_dataset ( moved_dataset ) ) <EOL> return dataset_moving <EOL> waiting_for_shutdown . addCallback ( move_dataset ) <EOL> return waiting_for_shutdown <EOL> @ require_cluster ( <NUM_LIT:1> ) <EOL> def test_unregistered_volume ( self , cluster ) : <EOL> """<STR_LIT>""" <EOL> api = get_backend_api ( cluster . cluster_uuid ) <EOL> dataset_id = uuid4 ( ) <EOL> volume = api . create_volume ( dataset_id , size = get_default_volume_size ( ) ) <EOL> wait_for_dataset = create_dataset ( self , cluster , dataset_id = dataset_id ) <EOL> def check_volumes ( dataset ) : <EOL> new_volumes = api . list_volumes ( ) <EOL> self . assertThat ( <EOL> new_volumes , <EOL> MatchesListwise ( [ <EOL> AfterPreprocessing ( <EOL> lambda new_volume : new_volume . set ( '<STR_LIT>' , None ) , <EOL> Equals ( volume ) <EOL> ) , <EOL> ] ) <EOL> ) <EOL> wait_for_dataset . addCallback ( check_volumes ) <EOL> return wait_for_dataset <EOL> @ skip_backend ( <EOL> unsupported = { backends . GCE } , <EOL> reason = "<STR_LIT>" <EOL> "<STR_LIT>" <EOL> "<STR_LIT>" <EOL> "<STR_LIT>" ) <EOL> @ require_cluster ( <NUM_LIT:2> ) <EOL> def test_extra_volume ( self , cluster ) : <EOL> """<STR_LIT>""" <EOL> api = get_backend_api ( cluster . cluster_uuid ) <EOL> wait_for_dataset = create_dataset ( self , cluster ) <EOL> created_volume = [ ] <EOL> def create_extra ( dataset ) : <EOL> volume = api . create_volume ( dataset . dataset_id , <EOL> size = get_default_volume_size ( ) ) <EOL> created_volume . append ( volume ) <EOL> return dataset <EOL> wait_for_extra_volume = wait_for_dataset . addCallback ( create_extra ) <EOL> def move_dataset ( dataset ) : <EOL> dataset_moving = cluster . client . move_dataset ( <EOL> UUID ( cluster . nodes [ <NUM_LIT:1> ] . uuid ) , dataset . dataset_id ) <EOL> moved_dataset = dataset . set ( <EOL> primary = UUID ( cluster . nodes [ <NUM_LIT:1> ] . uuid ) ) <EOL> dataset_moving . addCallback ( <EOL> lambda dataset : cluster . wait_for_dataset ( moved_dataset ) ) <EOL> return dataset_moving <EOL> wait_for_move = wait_for_extra_volume . addCallback ( move_dataset ) <EOL> def check_attached ( dataset ) : <EOL> blockdevice_id = created_volume [ <NUM_LIT:0> ] . blockdevice_id <EOL> [ volume ] = [ volume for volume in api . list_volumes ( ) <EOL> if volume . blockdevice_id == blockdevice_id ] <EOL> self . assertEqual ( volume . attached_to , None ) <EOL> return wait_for_move . addCallback ( check_attached ) <EOL> return wait_for_dataset </s>

<s> """<STR_LIT>""" <EOL> from . _client import ( <EOL> IFlockerAPIV1Client , FakeFlockerClient , Dataset , DatasetState , <EOL> DatasetAlreadyExists , FlockerClient , Lease , LeaseAlreadyHeld , <EOL> conditional_create , DatasetsConfiguration , Node , MountedDataset , <EOL> ) <EOL> __all__ = [ "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" , <EOL> "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" , <EOL> "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" , <EOL> "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" , ] </s>

<s> """<STR_LIT>""" <EOL> def make_file ( path , content = '<STR_LIT>' , permissions = None ) : <EOL> """<STR_LIT>""" <EOL> path . setContent ( content ) <EOL> if permissions is not None : <EOL> path . chmod ( permissions ) <EOL> return path <EOL> def make_directory ( path ) : <EOL> """<STR_LIT>""" <EOL> if not path . isdir ( ) : <EOL> path . makedirs ( ) <EOL> return path </s>

<s> """<STR_LIT>""" <EOL> import sys <EOL> from eliot . testing import validateLogging , assertHasMessage <EOL> from eliot import Message <EOL> from twisted . internet import task <EOL> from twisted . internet . defer import succeed <EOL> from twisted . python import usage <EOL> from twisted . python . failure import Failure <EOL> from twisted . python . log import LogPublisher <EOL> from twisted . python import log as twisted_log <EOL> from twisted . internet . defer import Deferred <EOL> from twisted . application . service import Service <EOL> from . . script import ( <EOL> flocker_standard_options , FlockerScriptRunner , main_for_service , <EOL> EliotObserver , TWISTED_LOG_MESSAGE , eliot_to_stdout , <EOL> ) <EOL> from ... testtools import ( <EOL> help_problems , FakeSysModule , make_standard_options_test , <EOL> MemoryCoreReactor , TestCase , <EOL> ) <EOL> class FlockerScriptRunnerInitTests ( TestCase ) : <EOL> """<STR_LIT>""" <EOL> def test_sys_default ( self ) : <EOL> """<STR_LIT>""" <EOL> self . assertIs ( <EOL> sys , <EOL> FlockerScriptRunner ( <EOL> script = None , options = None ) . sys_module <EOL> ) <EOL> def test_sys_override ( self ) : <EOL> """<STR_LIT>""" <EOL> dummySys = object ( ) <EOL> self . assertIs ( <EOL> dummySys , <EOL> FlockerScriptRunner ( script = None , options = None , <EOL> sys_module = dummySys ) . sys_module <EOL> ) <EOL> def test_react ( self ) : <EOL> """<STR_LIT>""" <EOL> self . assertIs ( <EOL> task . react , <EOL> FlockerScriptRunner ( script = None , options = None ) . _react <EOL> ) <EOL> class FlockerScriptRunnerParseOptionsTests ( TestCase ) : <EOL> """<STR_LIT>""" <EOL> def test_parse_options ( self ) : <EOL> """<STR_LIT>""" <EOL> class OptionsSpy ( usage . Options ) : <EOL> def parseOptions ( self , arguments ) : <EOL> self . parseOptionsArguments = arguments <EOL> expectedArguments = [ object ( ) , object ( ) ] <EOL> runner = FlockerScriptRunner ( script = None , options = OptionsSpy ( ) ) <EOL> options = runner . _parse_options ( expectedArguments ) <EOL> self . assertEqual ( expectedArguments , options . parseOptionsArguments ) <EOL> def test_parse_options_usage_error ( self ) : <EOL> """<STR_LIT>""" <EOL> expectedMessage = b'<STR_LIT>' <EOL> expectedCommandName = b'<STR_LIT>' <EOL> class FakeOptions ( usage . Options ) : <EOL> synopsis = '<STR_LIT>' % ( expectedCommandName , ) <EOL> def parseOptions ( self , arguments ) : <EOL> raise usage . UsageError ( expectedMessage ) <EOL> fake_sys = FakeSysModule ( ) <EOL> runner = FlockerScriptRunner ( script = None , options = FakeOptions ( ) , <EOL> sys_module = fake_sys ) <EOL> error = self . assertRaises ( SystemExit , runner . _parse_options , [ ] ) <EOL> expectedErrorMessage = b'<STR_LIT>' % ( expectedMessage , ) <EOL> errorText = fake_sys . stderr . getvalue ( ) <EOL> self . assertEqual ( <EOL> ( <NUM_LIT:1> , [ ] , expectedErrorMessage ) , <EOL> ( error . code , <EOL> help_problems ( u'<STR_LIT>' , errorText ) , <EOL> errorText [ - len ( expectedErrorMessage ) : ] ) <EOL> ) <EOL> class FlockerScriptRunnerMainTests ( TestCase ) : <EOL> """<STR_LIT>""" <EOL> def test_main_uses_sysargv ( self ) : <EOL> """<STR_LIT>""" <EOL> class SpyOptions ( usage . Options ) : <EOL> def opt_hello ( self , value ) : <EOL> self . value = value <EOL> class SpyScript ( object ) : <EOL> def main ( self , reactor , arguments ) : <EOL> self . reactor = reactor <EOL> self . arguments = arguments <EOL> return succeed ( None ) <EOL> options = SpyOptions ( ) <EOL> script = SpyScript ( ) <EOL> sys = FakeSysModule ( argv = [ b"<STR_LIT>" , b"<STR_LIT>" , b"<STR_LIT>" ] ) <EOL> from twisted . test . test_task import _FakeReactor <EOL> fakeReactor = _FakeReactor ( ) <EOL> runner = FlockerScriptRunner ( script , options , <EOL> reactor = fakeReactor , sys_module = sys , <EOL> logging = False ) <EOL> self . assertRaises ( SystemExit , runner . main ) <EOL> self . assertEqual ( b"<STR_LIT>" , script . arguments . value ) <EOL> def test_disabled_logging ( self ) : <EOL> """<STR_LIT>""" <EOL> class Script ( object ) : <EOL> def main ( self , reactor , arguments ) : <EOL> twisted_log . msg ( b"<STR_LIT>" ) <EOL> return succeed ( None ) <EOL> script = Script ( ) <EOL> sys = FakeSysModule ( argv = [ ] ) <EOL> from twisted . test . test_task import _FakeReactor <EOL> fakeReactor = _FakeReactor ( ) <EOL> runner = FlockerScriptRunner ( script , usage . Options ( ) , <EOL> reactor = fakeReactor , sys_module = sys , <EOL> logging = False ) <EOL> self . assertRaises ( SystemExit , runner . main ) <EOL> self . assertEqual ( sys . stdout . getvalue ( ) , b"<STR_LIT>" ) <EOL> @ flocker_standard_options <EOL> class TestOptions ( usage . Options ) : <EOL> """<STR_LIT>""" <EOL> class FlockerStandardOptionsTests ( make_standard_options_test ( TestOptions ) ) : <EOL> """<STR_LIT>""" <EOL> class AsyncStopService ( Service ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , stop_result ) : <EOL> self . stop_result = stop_result <EOL> def stopService ( self ) : <EOL> Service . stopService ( self ) <EOL> return self . stop_result <EOL> class MainForServiceTests ( TestCase ) : <EOL> """<STR_LIT>""" <EOL> def setUp ( self ) : <EOL> super ( MainForServiceTests , self ) . setUp ( ) <EOL> self . reactor = MemoryCoreReactor ( ) <EOL> self . service = Service ( ) <EOL> def _shutdown_reactor ( self , reactor ) : <EOL> """<STR_LIT>""" <EOL> reactor . fireSystemEvent ( "<STR_LIT>" ) <EOL> def test_starts_service ( self ) : <EOL> """<STR_LIT>""" <EOL> main_for_service ( self . reactor , self . service ) <EOL> self . assertTrue ( <EOL> self . service . running , "<STR_LIT>" ) <EOL> def test_returns_unfired_deferred ( self ) : <EOL> """<STR_LIT>""" <EOL> result = main_for_service ( self . reactor , self . service ) <EOL> self . assertNoResult ( result ) <EOL> def test_fire_on_stop ( self ) : <EOL> """<STR_LIT>""" <EOL> result = main_for_service ( self . reactor , self . service ) <EOL> self . _shutdown_reactor ( self . reactor ) <EOL> self . assertIs ( None , self . successResultOf ( result ) ) <EOL> def test_stops_service ( self ) : <EOL> """<STR_LIT>""" <EOL> main_for_service ( self . reactor , self . service ) <EOL> self . _shutdown_reactor ( self . reactor ) <EOL> self . assertFalse ( <EOL> self . service . running , "<STR_LIT>" ) <EOL> def test_wait_for_service_stop ( self ) : <EOL> """<STR_LIT>""" <EOL> result = main_for_service ( self . reactor , AsyncStopService ( Deferred ( ) ) ) <EOL> self . _shutdown_reactor ( self . reactor ) <EOL> self . assertNoResult ( result ) <EOL> def test_fire_after_service_stop ( self ) : <EOL> """<STR_LIT>""" <EOL> async = Deferred ( ) <EOL> result = main_for_service ( self . reactor , AsyncStopService ( async ) ) <EOL> self . _shutdown_reactor ( self . reactor ) <EOL> async . callback ( None ) <EOL> self . assertIs ( None , self . successResultOf ( result ) ) <EOL> class EliotObserverTests ( TestCase ) : <EOL> """<STR_LIT>""" <EOL> @ validateLogging ( None ) <EOL> def test_message ( self , logger ) : <EOL> """<STR_LIT>""" <EOL> publisher = LogPublisher ( ) <EOL> observer = EliotObserver ( publisher ) <EOL> observer . logger = logger <EOL> publisher . addObserver ( observer ) <EOL> publisher . msg ( b"<STR_LIT>" , b"<STR_LIT>" ) <EOL> assertHasMessage ( self , logger , TWISTED_LOG_MESSAGE , <EOL> dict ( error = False , message = u"<STR_LIT>" ) ) <EOL> @ validateLogging ( None ) <EOL> def test_error ( self , logger ) : <EOL> """<STR_LIT>""" <EOL> publisher = LogPublisher ( ) <EOL> observer = EliotObserver ( publisher ) <EOL> observer . logger = logger <EOL> publisher . addObserver ( observer ) <EOL> publisher . msg ( failure = Failure ( ZeroDivisionError ( "<STR_LIT>" ) ) , <EOL> why = b"<STR_LIT>" , <EOL> isError = True ) <EOL> message = ( u'<STR_LIT>' <EOL> u'<STR_LIT>' ) <EOL> assertHasMessage ( self , logger , TWISTED_LOG_MESSAGE , <EOL> dict ( error = True , message = message ) ) <EOL> class EliotStdoutTests ( TestCase ) : <EOL> """<STR_LIT>""" <EOL> class StubStdout ( object ) : <EOL> """<STR_LIT>""" <EOL> flushed_data = b'<STR_LIT>' <EOL> buffered_data = b'<STR_LIT>' <EOL> def write ( self , message ) : <EOL> self . buffered_data = self . buffered_data + message <EOL> def flush ( self ) : <EOL> self . flushed_data = self . buffered_data <EOL> self . buffered_data = b'<STR_LIT>' <EOL> def test_destination_stdout ( self ) : <EOL> """<STR_LIT>""" <EOL> fake_stdout = self . StubStdout ( ) <EOL> message_formats = { '<STR_LIT>' : '<STR_LIT>' } <EOL> eliot_to_stdout ( message_formats , { } , stdout = fake_stdout ) <EOL> Message . new ( <EOL> message_type = '<STR_LIT>' , command = "<STR_LIT>" ) . write ( ) <EOL> self . assertEqual ( fake_stdout . flushed_data , "<STR_LIT>" ) </s>

<s> """<STR_LIT>""" <EOL> from . . testtools import make_istatepersister_tests , InMemoryStatePersister <EOL> def make_inmemorystatepersister ( test_case ) : <EOL> """<STR_LIT>""" <EOL> state_persister = InMemoryStatePersister ( ) <EOL> return state_persister , state_persister . get_state <EOL> class InMemoryStatePersisterTests ( <EOL> make_istatepersister_tests ( make_inmemorystatepersister ) <EOL> ) : <EOL> """<STR_LIT>""" </s>

<s> """<STR_LIT>""" </s>

<s> from twisted . python . constants import NamedConstant <EOL> class StorageInitializationError ( Exception ) : <EOL> """<STR_LIT>""" <EOL> CONFIGURATION_ERROR = NamedConstant ( ) <EOL> OPERATIVE_ERROR = NamedConstant ( ) <EOL> def __init__ ( self , code , * args ) : <EOL> Exception . __init__ ( self , * args ) <EOL> self . code = code </s>

<s> """<STR_LIT>""" <EOL> from . _libcloud import LibcloudProvisioner <EOL> from . _install import provision <EOL> from . _ssh import run_remotely <EOL> from . _effect import sequence <EOL> def get_default_username ( distribution ) : <EOL> """<STR_LIT>""" <EOL> return '<STR_LIT:root>' <EOL> def provision_rackspace ( node , package_source , distribution , variants ) : <EOL> """<STR_LIT>""" <EOL> commands = [ ] <EOL> commands . append ( run_remotely ( <EOL> username = get_default_username ( distribution ) , <EOL> address = node . address , <EOL> commands = sequence ( [ <EOL> provision ( <EOL> package_source = package_source , <EOL> distribution = node . distribution , <EOL> variants = variants , <EOL> ) , <EOL> ] ) , <EOL> ) ) <EOL> return sequence ( commands ) <EOL> IMAGE_NAMES = { <EOL> '<STR_LIT>' : u'<STR_LIT>' , <EOL> '<STR_LIT>' : u'<STR_LIT>' , <EOL> '<STR_LIT>' : u'<STR_LIT>' , <EOL> } <EOL> def rackspace_provisioner ( username , key , region , keyname ) : <EOL> """<STR_LIT>""" <EOL> from libcloud . compute . providers import get_driver , Provider <EOL> driver = get_driver ( Provider . RACKSPACE ) ( <EOL> key = username , <EOL> secret = key , <EOL> region = region ) <EOL> provisioner = LibcloudProvisioner ( <EOL> driver = driver , <EOL> keyname = keyname , <EOL> image_names = IMAGE_NAMES , <EOL> create_node_arguments = lambda ** kwargs : { <EOL> "<STR_LIT>" : "<STR_LIT:true>" , <EOL> } , <EOL> provision = provision_rackspace , <EOL> default_size = "<STR_LIT>" , <EOL> get_default_user = get_default_username , <EOL> ) <EOL> return provisioner </s>

<s> """<STR_LIT>""" <EOL> from io import BytesIO <EOL> from json import dumps , loads as _loads <EOL> import os . path <EOL> from itertools import count <EOL> from jsonschema . exceptions import ValidationError <EOL> from zope . interface import implementer <EOL> from klein . app import KleinRequest <EOL> from klein . interfaces import IKleinRequest <EOL> from twisted . python . components import registerAdapter <EOL> from twisted . python . log import err <EOL> from twisted . web . iweb import IAgent , IResponse <EOL> from twisted . internet . endpoints import TCP4ClientEndpoint , UNIXClientEndpoint <EOL> from twisted . internet import defer <EOL> from twisted . web . client import ProxyAgent , readBody , FileBodyProducer <EOL> from twisted . web . server import NOT_DONE_YET , Site , Request <EOL> from twisted . web . resource import getChildForRequest <EOL> from twisted . web . http import HTTPChannel , urlparse , unquote <EOL> from twisted . internet . address import IPv4Address <EOL> from twisted . test . proto_helpers import StringTransport <EOL> from twisted . web . client import ResponseDone <EOL> from twisted . internet . interfaces import IPushProducer <EOL> from twisted . python . failure import Failure <EOL> from twisted . internet import reactor <EOL> from twisted . web . http_headers import Headers <EOL> from pyrsistent import pmap <EOL> from flocker . restapi . _schema import getValidator <EOL> from . . testtools import AsyncTestCase , TestCase <EOL> __all__ = [ "<STR_LIT>" , "<STR_LIT>" , <EOL> "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" , <EOL> "<STR_LIT>" , <EOL> "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" , <EOL> "<STR_LIT>" ] <EOL> def loads ( s ) : <EOL> try : <EOL> return _loads ( s ) <EOL> except Exception as e : <EOL> raise Exception ( <EOL> "<STR_LIT>" % ( s , e ) ) <EOL> class CloseEnoughResponse ( object ) : <EOL> """<STR_LIT>""" <EOL> decode = staticmethod ( lambda body : body ) <EOL> def __init__ ( self , code , headers , body ) : <EOL> """<STR_LIT>""" <EOL> self . code = code <EOL> self . headers = headers <EOL> self . body = body <EOL> def verify ( self , response ) : <EOL> """<STR_LIT>""" <EOL> reading = readBody ( response ) <EOL> reading . addCallback ( self . decode ) <EOL> reading . addCallback ( self . _verifyWithBody , response ) <EOL> return reading <EOL> def _verifyWithBody ( self , body , response ) : <EOL> """<STR_LIT>""" <EOL> problems = [ ] <EOL> if self . code != response . code : <EOL> problems . append ( <EOL> "<STR_LIT>" % ( self . code , response . code ) ) <EOL> for name , expected in self . headers . getAllRawHeaders ( ) : <EOL> received = response . headers . getRawHeaders ( name ) <EOL> if expected != received : <EOL> problems . append ( <EOL> "<STR_LIT>" % ( name , expected , received ) ) <EOL> if self . body != body : <EOL> problems . append ( "<STR_LIT>" % ( self . body , body ) ) <EOL> if problems : <EOL> raise Exception ( "<STR_LIT>" . join ( [ "<STR_LIT>" ] + problems ) ) <EOL> class CloseEnoughJSONResponse ( CloseEnoughResponse ) : <EOL> """<STR_LIT>""" <EOL> decode = staticmethod ( loads ) <EOL> def extractSuccessfulJSONResult ( response ) : <EOL> """<STR_LIT>""" <EOL> result = readBody ( response ) <EOL> result . addCallback ( loads ) <EOL> def getResult ( data ) : <EOL> if response . code > <NUM_LIT> : <EOL> raise AssertionError ( ( response . code , data ) ) <EOL> return data <EOL> result . addCallback ( getResult ) <EOL> return result <EOL> def buildIntegrationTests ( mixinClass , name , fixture ) : <EOL> """<STR_LIT>""" <EOL> class RealTests ( mixinClass , AsyncTestCase ) : <EOL> """<STR_LIT>""" <EOL> def setUp ( self ) : <EOL> self . app = fixture ( self ) <EOL> self . port = reactor . listenTCP ( <EOL> <NUM_LIT:0> , Site ( self . app . resource ( ) ) , <EOL> interface = b"<STR_LIT:127.0.0.1>" , <EOL> ) <EOL> self . addCleanup ( self . port . stopListening ) <EOL> portno = self . port . getHost ( ) . port <EOL> self . agent = ProxyAgent ( <EOL> TCP4ClientEndpoint ( <EOL> reactor , "<STR_LIT:127.0.0.1>" , portno , <EOL> ) , <EOL> reactor <EOL> ) <EOL> super ( RealTests , self ) . setUp ( ) <EOL> class MemoryTests ( mixinClass , AsyncTestCase ) : <EOL> """<STR_LIT>""" <EOL> def setUp ( self ) : <EOL> self . app = fixture ( self ) <EOL> self . agent = MemoryAgent ( self . app . resource ( ) ) <EOL> super ( MemoryTests , self ) . setUp ( ) <EOL> RealTests . __name__ += name <EOL> MemoryTests . __name__ += name <EOL> RealTests . __module__ = mixinClass . __module__ <EOL> MemoryTests . __module__ = mixinClass . __module__ <EOL> return RealTests , MemoryTests <EOL> def build_UNIX_integration_tests ( mixin_class , name , fixture ) : <EOL> """<STR_LIT>""" <EOL> class RealTests ( mixin_class , AsyncTestCase ) : <EOL> """<STR_LIT>""" <EOL> def setUp ( self ) : <EOL> path = os . path . relpath ( self . mktemp ( ) ) <EOL> self . app = fixture ( self ) <EOL> self . port = reactor . listenUNIX ( <EOL> path , Site ( self . app . resource ( ) ) , <EOL> ) <EOL> self . addCleanup ( self . port . stopListening ) <EOL> self . agent = ProxyAgent ( UNIXClientEndpoint ( reactor , path ) , reactor ) <EOL> super ( RealTests , self ) . setUp ( ) <EOL> RealTests . __name__ += name <EOL> RealTests . __module__ = mixin_class . __module__ <EOL> return RealTests <EOL> class EventChannel ( object ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self ) : <EOL> self . _subscriptions = [ ] <EOL> def _itersubscriptions ( self ) : <EOL> """<STR_LIT>""" <EOL> subscriptions = self . _subscriptions [ : ] <EOL> del self . _subscriptions [ : ] <EOL> return iter ( subscriptions ) <EOL> def callback ( self , value ) : <EOL> """<STR_LIT>""" <EOL> for subscr in self . _itersubscriptions ( ) : <EOL> subscr . callback ( value ) <EOL> def errback ( self , reason = None ) : <EOL> """<STR_LIT>""" <EOL> for subscr in self . _itersubscriptions ( ) : <EOL> subscr . errback ( reason ) <EOL> def subscribe ( self ) : <EOL> """<STR_LIT>""" <EOL> d = defer . Deferred ( canceller = self . _subscriptions . remove ) <EOL> self . _subscriptions . append ( d ) <EOL> return d <EOL> class _DummyRequest ( Request ) : <EOL> @ property <EOL> def _code ( self ) : <EOL> return self . code <EOL> @ property <EOL> def _message ( self ) : <EOL> return self . code_message <EOL> def __init__ ( self , counter , method , path , headers , content ) : <EOL> channel = HTTPChannel ( ) <EOL> host = IPv4Address ( b"<STR_LIT>" , b"<STR_LIT:127.0.0.1>" , <NUM_LIT> ) <EOL> channel . makeConnection ( StringTransport ( hostAddress = host ) ) <EOL> Request . __init__ ( self , channel , False ) <EOL> self . _counter = counter <EOL> self . prepath = [ ] <EOL> self . requestHeaders = headers <EOL> self . content = BytesIO ( content ) <EOL> self . requestReceived ( method , path , b"<STR_LIT>" ) <EOL> self . postpath = list ( map ( unquote , self . path [ <NUM_LIT:1> : ] . split ( b'<STR_LIT:/>' ) ) ) <EOL> self . _finished = False <EOL> self . _finishedChannel = EventChannel ( ) <EOL> self . _responseBody = b"<STR_LIT>" <EOL> def process ( self ) : <EOL> """<STR_LIT>""" <EOL> def finish ( self ) : <EOL> self . _finished = True <EOL> self . _finishedChannel . callback ( None ) <EOL> def notifyFinish ( self ) : <EOL> return self . _finishedChannel . subscribe ( ) <EOL> def processingFailed ( self , reason ) : <EOL> err ( reason , "<STR_LIT>" % ( self . _counter , ) ) <EOL> def write ( self , data ) : <EOL> self . _responseBody += data <EOL> def render ( self , resource ) : <EOL> render ( resource , self ) <EOL> def asResponse ( request ) : <EOL> """<STR_LIT>""" <EOL> return _MemoryResponse ( <EOL> b"<STR_LIT>" , request . code , request . code_message , <EOL> request . responseHeaders , None , None , <EOL> request . _responseBody ) <EOL> @ implementer ( IResponse ) <EOL> class _MemoryResponse ( object ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , version , code , phrase , headers , request , <EOL> previousResponse , responseBody ) : <EOL> """<STR_LIT>""" <EOL> self . version = version <EOL> self . code = code <EOL> self . phrase = phrase <EOL> self . headers = headers <EOL> self . request = request <EOL> self . length = len ( responseBody ) <EOL> self . _responseBody = responseBody <EOL> self . setPreviousResponse ( previousResponse ) <EOL> def deliverBody ( self , protocol ) : <EOL> """<STR_LIT>""" <EOL> protocol . makeConnection ( _StubProducer ( ) ) <EOL> protocol . dataReceived ( self . _responseBody ) <EOL> protocol . connectionLost ( Failure ( ResponseDone ( ) ) ) <EOL> def setPreviousResponse ( self , response ) : <EOL> self . previousResponse = response <EOL> @ implementer ( IPushProducer ) <EOL> class _StubProducer ( object ) : <EOL> """<STR_LIT>""" <EOL> def pauseProducing ( self ) : <EOL> pass <EOL> def resumeProducing ( self ) : <EOL> pass <EOL> def stopProducing ( self ) : <EOL> pass <EOL> @ implementer ( IAgent ) <EOL> class MemoryAgent ( object ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , resource ) : <EOL> self . resource = resource <EOL> def request ( self , method , url , headers = None , body = None ) : <EOL> """<STR_LIT>""" <EOL> if headers is None : <EOL> headers = Headers ( ) <EOL> content = BytesIO ( ) <EOL> if body is None : <EOL> reading = defer . succeed ( None ) <EOL> else : <EOL> reading = body . startProducing ( content ) <EOL> def finishedReading ( ignored ) : <EOL> request = dummyRequest ( method , url , headers , content . getvalue ( ) ) <EOL> resource = getChildForRequest ( self . resource , request ) <EOL> d = render ( resource , request ) <EOL> d . addCallback ( lambda ignored : request ) <EOL> return d <EOL> rendering = reading . addCallback ( finishedReading ) <EOL> def rendered ( request ) : <EOL> return _MemoryResponse ( <EOL> ( b"<STR_LIT>" , <NUM_LIT:1> , <NUM_LIT:1> ) , <EOL> request . _code , <EOL> request . _message , <EOL> request . responseHeaders , <EOL> request , <EOL> None , <EOL> request . _responseBody ) <EOL> rendering . addCallback ( rendered ) <EOL> return reading <EOL> _dummyRequestCounter = iter ( count ( ) ) <EOL> def dummyRequest ( method , path , headers , body = b"<STR_LIT>" ) : <EOL> """<STR_LIT>""" <EOL> parsed = urlparse ( path ) <EOL> if parsed . query : <EOL> new_path = parsed . path + "<STR_LIT:?>" + parsed . query <EOL> else : <EOL> new_path = parsed . path <EOL> return _DummyRequest ( <EOL> next ( _dummyRequestCounter ) , <EOL> method , new_path , headers , body ) <EOL> def render ( resource , request ) : <EOL> """<STR_LIT>""" <EOL> result = resource . render ( request ) <EOL> if isinstance ( result , bytes ) : <EOL> request . write ( result ) <EOL> request . finish ( ) <EOL> return defer . succeed ( None ) <EOL> elif result is NOT_DONE_YET : <EOL> if request . _finished : <EOL> return defer . succeed ( None ) <EOL> else : <EOL> return request . notifyFinish ( ) <EOL> else : <EOL> raise ValueError ( "<STR_LIT>" % ( result , ) ) <EOL> registerAdapter ( KleinRequest , _DummyRequest , IKleinRequest ) <EOL> def build_schema_test ( name , schema , schema_store , <EOL> failing_instances , passing_instances ) : <EOL> """<STR_LIT>""" <EOL> body = { <EOL> '<STR_LIT>' : schema , <EOL> '<STR_LIT>' : schema_store , <EOL> '<STR_LIT>' : getValidator ( schema , schema_store ) , <EOL> '<STR_LIT>' : passing_instances , <EOL> '<STR_LIT>' : failing_instances , <EOL> } <EOL> for error_type in failing_instances : <EOL> for i , inst in enumerate ( failing_instances [ error_type ] ) : <EOL> def test ( self , inst = inst , error_type = error_type ) : <EOL> e = self . assertRaises ( <EOL> ValidationError , self . validator . validate , inst <EOL> ) <EOL> self . assertEqual ( e . validator , error_type ) <EOL> test . __name__ = '<STR_LIT>' % ( error_type , i ) <EOL> body [ test . __name__ ] = test <EOL> for i , inst in enumerate ( passing_instances ) : <EOL> def test ( self , inst = inst ) : <EOL> self . validator . validate ( inst ) <EOL> test . __name__ = '<STR_LIT>' % ( i , ) <EOL> body [ test . __name__ ] = test <EOL> return type ( name , ( TestCase , object ) , body ) <EOL> class APIAssertionsMixin ( object ) : <EOL> """<STR_LIT>""" <EOL> def assertResponseCode ( self , method , path , request_body , expected_code , <EOL> additional_headers = pmap ( ) ) : <EOL> """<STR_LIT>""" <EOL> if request_body is None : <EOL> headers = { } <EOL> body_producer = None <EOL> else : <EOL> headers = { b"<STR_LIT>" : [ b"<STR_LIT:application/json>" ] } <EOL> body_producer = FileBodyProducer ( BytesIO ( dumps ( request_body ) ) ) <EOL> headers . update ( additional_headers ) <EOL> headers = Headers ( headers ) <EOL> requesting = self . agent . request ( <EOL> method , path , headers , body_producer <EOL> ) <EOL> def check_code ( response ) : <EOL> self . assertEqual ( expected_code , response . code ) <EOL> return response <EOL> requesting . addCallback ( check_code ) <EOL> return requesting <EOL> def assertResult ( self , method , path , request_body , <EOL> expected_code , expected_result , <EOL> additional_headers = pmap ( ) ) : <EOL> """<STR_LIT>""" <EOL> requesting = self . assertResponseCode ( <EOL> method , path , request_body , expected_code , additional_headers ) <EOL> requesting . addCallback ( readBody ) <EOL> requesting . addCallback ( loads ) <EOL> def assertEqualAndReturn ( expected , actual ) : <EOL> """<STR_LIT>""" <EOL> self . assertEqual ( expected , actual ) <EOL> return actual <EOL> requesting . addCallback ( <EOL> lambda actual_result : assertEqualAndReturn ( <EOL> expected_result , actual_result ) <EOL> ) <EOL> return requesting <EOL> def assertResultItems ( self , method , path , request_body , <EOL> expected_code , expected_result , <EOL> additional_headers = pmap ( ) ) : <EOL> """<STR_LIT>""" <EOL> requesting = self . assertResponseCode ( <EOL> method , path , request_body , expected_code , additional_headers ) <EOL> requesting . addCallback ( readBody ) <EOL> requesting . addCallback ( lambda body : self . assertItemsEqual ( <EOL> expected_result , loads ( body ) ) ) <EOL> return requesting </s>

<s> """<STR_LIT>""" <EOL> from . . amp import FakeAMPClient , DelayedAMPClient , LoopbackAMPClient <EOL> from twisted . internet . error import ConnectionLost <EOL> from twisted . protocols . amp import ( <EOL> Command , Integer , ListOf , MAX_VALUE_LENGTH , TooLong , CommandLocator , <EOL> ) <EOL> from ... testtools import TestCase <EOL> class TestCommand ( Command ) : <EOL> """<STR_LIT>""" <EOL> arguments = [ <EOL> ( '<STR_LIT>' , Integer ( ) ) , <EOL> ] <EOL> response = [ <EOL> ( '<STR_LIT>' , Integer ( ) ) , <EOL> ] <EOL> class DelayedAMPClientTests ( TestCase ) : <EOL> """<STR_LIT>""" <EOL> def test_forwards_call ( self ) : <EOL> """<STR_LIT>""" <EOL> expected_arguments = { '<STR_LIT>' : <NUM_LIT> } <EOL> client = FakeAMPClient ( ) <EOL> client . register_response ( <EOL> TestCommand , expected_arguments , { '<STR_LIT>' : <NUM_LIT:7> } ) <EOL> delayed_client = DelayedAMPClient ( client ) <EOL> delayed_client . callRemote ( TestCommand , argument = <NUM_LIT> ) <EOL> self . assertEqual ( <EOL> client . calls , <EOL> [ ( TestCommand , { '<STR_LIT>' : <NUM_LIT> } ) ] , <EOL> ) <EOL> def test_delays_response ( self ) : <EOL> """<STR_LIT>""" <EOL> expected_arguments = { '<STR_LIT>' : <NUM_LIT> } <EOL> client = FakeAMPClient ( ) <EOL> client . register_response ( <EOL> TestCommand , expected_arguments , { '<STR_LIT>' : <NUM_LIT:7> } ) <EOL> delayed_client = DelayedAMPClient ( client ) <EOL> d = delayed_client . callRemote ( TestCommand , ** expected_arguments ) <EOL> self . assertNoResult ( d ) <EOL> def test_forwards_response ( self ) : <EOL> """<STR_LIT>""" <EOL> expected_arguments = { '<STR_LIT>' : <NUM_LIT> } <EOL> expected_response = { '<STR_LIT>' : <NUM_LIT:7> } <EOL> client = FakeAMPClient ( ) <EOL> client . register_response ( <EOL> TestCommand , expected_arguments , expected_response ) <EOL> delayed_client = DelayedAMPClient ( client ) <EOL> d = delayed_client . callRemote ( TestCommand , ** expected_arguments ) <EOL> delayed_client . respond ( ) <EOL> self . assertEqual ( <EOL> self . successResultOf ( d ) , <EOL> expected_response , <EOL> ) <EOL> class CommandWithBigListArgument ( Command ) : <EOL> arguments = [ <EOL> ( "<STR_LIT>" , ListOf ( Integer ( ) ) ) , <EOL> ] <EOL> class CommandWithBigResponse ( Command ) : <EOL> response = [ <EOL> ( "<STR_LIT>" , ListOf ( Integer ( ) ) ) , <EOL> ] <EOL> class CommandWithSmallResponse ( Command ) : <EOL> response = [ <EOL> ( "<STR_LIT>" , ListOf ( Integer ( ) ) ) , <EOL> ] <EOL> class MinimalLocator ( CommandLocator ) : <EOL> @ CommandWithBigListArgument . responder <EOL> def big_argument_responder ( self , big ) : <EOL> return { } <EOL> @ CommandWithSmallResponse . responder <EOL> def small_response_responder ( self ) : <EOL> return dict ( <EOL> small = range ( <NUM_LIT:10> ) , <EOL> ) <EOL> @ CommandWithBigResponse . responder <EOL> def big_response_responder ( self ) : <EOL> return dict ( <EOL> big = range ( MAX_VALUE_LENGTH ) , <EOL> ) <EOL> class LoopbackAMPClientTests ( TestCase ) : <EOL> """<STR_LIT>""" <EOL> def test_regular_argument ( self ) : <EOL> """<STR_LIT>""" <EOL> client = LoopbackAMPClient ( <EOL> command_locator = MinimalLocator ( ) <EOL> ) <EOL> d = client . callRemote ( <EOL> command = CommandWithBigListArgument , <EOL> big = range ( <NUM_LIT:10> ) , <EOL> ) <EOL> self . successResultOf ( d ) <EOL> def test_big_argument ( self ) : <EOL> """<STR_LIT>""" <EOL> client = LoopbackAMPClient ( <EOL> command_locator = MinimalLocator ( ) <EOL> ) <EOL> self . assertRaises ( <EOL> TooLong , <EOL> client . callRemote , <EOL> command = CommandWithBigListArgument , <EOL> big = range ( MAX_VALUE_LENGTH ) , <EOL> ) <EOL> def test_regular_response ( self ) : <EOL> """<STR_LIT>""" <EOL> client = LoopbackAMPClient ( <EOL> command_locator = MinimalLocator ( ) <EOL> ) <EOL> d = client . callRemote ( <EOL> command = CommandWithSmallResponse , <EOL> ) <EOL> self . successResultOf ( d ) <EOL> def test_big_response ( self ) : <EOL> """<STR_LIT>""" <EOL> client = LoopbackAMPClient ( <EOL> command_locator = MinimalLocator ( ) <EOL> ) <EOL> d = client . callRemote ( command = CommandWithBigResponse ) <EOL> failure = self . failureResultOf ( d , ConnectionLost ) <EOL> self . assertIn ( '<STR_LIT>' , failure . value . args [ <NUM_LIT:0> ] ) </s>

<s> """<STR_LIT>""" <EOL> import platform <EOL> from setuptools import setup , find_packages <EOL> import versioneer <EOL> with open ( "<STR_LIT>" ) as readme : <EOL> description = readme . read ( ) <EOL> with open ( "<STR_LIT>" ) as requirements : <EOL> install_requires = [ req for req in requirements . readlines ( ) if '<STR_LIT>' not in req ] <EOL> with open ( "<STR_LIT>" ) as dev_requirements : <EOL> dev_requires = dev_requirements . readlines ( ) <EOL> if platform . system ( ) == '<STR_LIT>' : <EOL> dev_requires . extend ( [ <EOL> "<STR_LIT>" , <EOL> ] ) <EOL> setup ( <EOL> name = "<STR_LIT>" , <EOL> version = versioneer . get_version ( ) , <EOL> author = "<STR_LIT>" , <EOL> author_email = "<STR_LIT>" , <EOL> url = "<STR_LIT>" , <EOL> license = "<STR_LIT>" , <EOL> long_description = description , <EOL> packages = find_packages ( exclude = ( '<STR_LIT>' , '<STR_LIT>' ) ) , <EOL> package_data = { <EOL> '<STR_LIT>' : [ <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' <EOL> ] , <EOL> '<STR_LIT>' : [ '<STR_LIT>' ] , <EOL> '<STR_LIT>' : [ '<STR_LIT>' ] , <EOL> '<STR_LIT>' : [ <EOL> '<STR_LIT>' , '<STR_LIT>' <EOL> ] , <EOL> } , <EOL> entry_points = { <EOL> '<STR_LIT>' : [ <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' + <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' + <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' + <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> ] , <EOL> } , <EOL> install_requires = install_requires , <EOL> extras_require = { <EOL> "<STR_LIT>" : dev_requires , <EOL> } , <EOL> cmdclass = versioneer . get_cmdclass ( ) , <EOL> dependency_links = [ <EOL> ] , <EOL> classifiers = [ <EOL> "<STR_LIT>" , <EOL> ] , <EOL> ) </s>

<s> """<STR_LIT>""" <EOL> __version__ = '<STR_LIT>' <EOL> from debacl . level_set_tree import construct_tree <EOL> from debacl . level_set_tree import construct_tree_from_graph <EOL> from debacl . level_set_tree import load_tree <EOL> from debacl . level_set_tree import LevelSetTree </s>

<s> import sys <EOL> import timeit <EOL> import inspect <EOL> import logging <EOL> import functools <EOL> try : <EOL> from cStringIO import StringIO <EOL> except ImportError : <EOL> from StringIO import StringIO <EOL> try : <EOL> import cProfile as profile_module <EOL> except ImportError : <EOL> import profile as profile_module <EOL> try : <EOL> from django . conf import settings <EOL> except ImportError : <EOL> settings = None <EOL> try : <EOL> if settings . configured : <EOL> from django . db import connections <EOL> else : <EOL> connections = None <EOL> except ( ImportError , AttributeError ) : <EOL> connections = None <EOL> class Profiler ( object ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , name , start = False , profile_sql = False , connection_names = ( '<STR_LIT:default>' , ) ) : <EOL> """<STR_LIT>""" <EOL> if settings is not None and hasattr ( settings , '<STR_LIT>' ) : <EOL> logger_name = settings . PROFILING_LOGGER_NAME <EOL> else : <EOL> logger_name = __name__ <EOL> if name . find ( '<STR_LIT:U+0020>' ) == - <NUM_LIT:1> : <EOL> logger_name += '<STR_LIT>' . format ( name ) <EOL> self . log = logging . getLogger ( logger_name ) <EOL> self . name = name <EOL> self . pre_queries_cnt = { } <EOL> self . profile_sql = profile_sql <EOL> try : <EOL> assert isinstance ( connection_names , tuple ) <EOL> self . connection_names = connection_names <EOL> except AssertionError : <EOL> self . connection_names = '<STR_LIT:default>' , <EOL> if start : <EOL> self . start ( ) <EOL> def get_duration_seconds ( self ) : <EOL> """<STR_LIT>""" <EOL> if hasattr ( self , '<STR_LIT>' ) : <EOL> stop_time = self . stop_time <EOL> else : <EOL> stop_time = timeit . default_timer ( ) <EOL> delta = stop_time - self . start_time <EOL> return delta <EOL> def get_duration_milliseconds ( self ) : <EOL> """<STR_LIT>""" <EOL> return round ( self . get_duration_seconds ( ) * <NUM_LIT:1000> , <NUM_LIT:6> ) <EOL> def get_duration_microseconds ( self ) : <EOL> """<STR_LIT>""" <EOL> return round ( self . get_duration_seconds ( ) * <NUM_LIT> , <NUM_LIT:6> ) <EOL> def start ( self ) : <EOL> """<STR_LIT>""" <EOL> self . start_time = timeit . default_timer ( ) <EOL> if self . __can_profile_sql ( ) : <EOL> for connection_name in self . connection_names : <EOL> self . pre_queries_cnt [ connection_name ] = len ( connections [ connection_name ] . queries ) <EOL> def stop ( self ) : <EOL> """<STR_LIT>""" <EOL> if not hasattr ( self , '<STR_LIT>' ) : <EOL> raise RuntimeError ( '<STR_LIT>' % self . name ) <EOL> self . stop_time = timeit . default_timer ( ) <EOL> if self . __can_profile_sql ( ) : <EOL> sql_count , sql_time = <NUM_LIT:0> , <NUM_LIT:0.0> <EOL> for connection_name in self . connection_names : <EOL> sql_stat = self . __get_sql_stats_for_connection ( connection_name ) <EOL> sql_count , sql_time = sql_count + sql_stat [ <NUM_LIT:0> ] , sql_time + sql_stat [ <NUM_LIT:1> ] <EOL> self . log . info ( '<STR_LIT>' , self . name , self . get_duration_milliseconds ( ) , sql_count , sql_time , <EOL> extra = { <EOL> '<STR_LIT>' : { <EOL> '<STR_LIT>' : self . get_duration_seconds ( ) , <EOL> '<STR_LIT>' : self . get_duration_milliseconds ( ) , <EOL> '<STR_LIT>' : self . get_duration_microseconds ( ) <EOL> } <EOL> } ) <EOL> if self . __can_profile_sql ( ) and sql_count : <EOL> for connection_name in self . connection_names : <EOL> for query in connections [ connection_name ] . queries [ self . pre_queries_cnt [ connection_name ] : ] : <EOL> self . log . debug ( '<STR_LIT>' , query . get ( '<STR_LIT:time>' ) , query . get ( '<STR_LIT>' ) , extra = { <EOL> '<STR_LIT>' : query . get ( '<STR_LIT>' ) , <EOL> '<STR_LIT:time>' : query . get ( '<STR_LIT:time>' ) <EOL> } ) <EOL> else : <EOL> self . log . info ( '<STR_LIT>' , self . name , self . get_duration_milliseconds ( ) , extra = { <EOL> '<STR_LIT>' : { <EOL> '<STR_LIT>' : self . get_duration_seconds ( ) , <EOL> '<STR_LIT>' : self . get_duration_milliseconds ( ) , <EOL> '<STR_LIT>' : self . get_duration_microseconds ( ) <EOL> } <EOL> } ) <EOL> def __enter__ ( self ) : <EOL> self . start ( ) <EOL> return self <EOL> def __exit__ ( self , exc_type , exc_value , traceback ) : <EOL> if exc_type is not None and exc_value is not None and traceback is not None : <EOL> self . log . exception ( '<STR_LIT>' , self . name , exc_type , exc_value ) <EOL> self . stop ( ) <EOL> return False <EOL> def __can_profile_sql ( self ) : <EOL> return connections is not None and ( getattr ( settings , '<STR_LIT>' , False ) or self . profile_sql ) <EOL> def __get_sql_stats_for_connection ( self , connection_name ) : <EOL> pre_queries_cnt = self . pre_queries_cnt [ connection_name ] <EOL> sql_count = len ( connections [ connection_name ] . queries ) - pre_queries_cnt <EOL> if sql_count > <NUM_LIT:0> : <EOL> sql_time = sum ( [ float ( q [ '<STR_LIT:time>' ] ) for q in connections [ connection_name ] . queries [ pre_queries_cnt : pre_queries_cnt + sql_count ] ] ) <EOL> else : <EOL> sql_time = <NUM_LIT:0.0> <EOL> return sql_count , sql_time <EOL> def profile ( * fn , ** options ) : <EOL> """<STR_LIT>""" <EOL> profile_sql = options . pop ( '<STR_LIT>' , False ) <EOL> stats = options . pop ( '<STR_LIT>' , False ) <EOL> stats_filename = options . pop ( '<STR_LIT>' , None ) <EOL> stats_buffer = options . pop ( '<STR_LIT>' , None ) <EOL> if options : <EOL> raise TypeError ( '<STR_LIT>' % '<STR_LIT:U+002C>' . join ( options . keys ( ) ) ) <EOL> def decorator ( func ) : <EOL> try : <EOL> func . __name__ <EOL> except AttributeError : <EOL> func . __name__ = func . __class__ . __name__ <EOL> try : <EOL> functools . update_wrapper ( decorator , func ) <EOL> except AttributeError : <EOL> pass <EOL> def wrapper ( * args , ** kwargs ) : <EOL> try : <EOL> functools . update_wrapper ( wrapper , func ) <EOL> except AttributeError : <EOL> pass <EOL> if ( args and hasattr ( args [ <NUM_LIT:0> ] , '<STR_LIT>' ) and args [ <NUM_LIT:0> ] . __class__ . __dict__ . get ( func . __name__ ) is not None and <EOL> args [ <NUM_LIT:0> ] . __class__ . __dict__ . get ( func . __name__ ) . __name__ == func . __name__ ) : <EOL> profiler_name = '<STR_LIT>' % ( args [ <NUM_LIT:0> ] . __class__ . __name__ , func . __name__ ) <EOL> else : <EOL> if hasattr ( func , '<STR_LIT>' ) : <EOL> profiler_name = '<STR_LIT>' . format ( func . __module__ , func . __name__ ) <EOL> elif hasattr ( func , '<STR_LIT>' ) : <EOL> profiler_name = func . __class__ . __name__ <EOL> else : <EOL> profiler_name = '<STR_LIT>' <EOL> if stats : <EOL> prof = profile_module . Profile ( ) <EOL> with Profiler ( profiler_name , profile_sql = profile_sql ) : <EOL> to_return = prof . runcall ( func , * args , ** kwargs ) <EOL> old_stdout = sys . stdout <EOL> sys . stdout = StringIO ( ) <EOL> prof . print_stats ( ) <EOL> statistics = sys . stdout . getvalue ( ) <EOL> sys . stdout . close ( ) <EOL> sys . stdout = old_stdout <EOL> if stats_buffer is not None : <EOL> stats_buffer . write ( statistics ) <EOL> else : <EOL> logger_name = settings . PROFILING_LOGGER_NAME if settings is not None and hasattr ( settings , '<STR_LIT>' ) else __name__ <EOL> logging . getLogger ( '<STR_LIT>' . format ( logger_name , profiler_name ) ) . info ( statistics ) <EOL> if stats_filename is not None : <EOL> prof . dump_stats ( stats_filename ) <EOL> else : <EOL> with Profiler ( profiler_name , profile_sql = profile_sql ) : <EOL> to_return = func ( * args , ** kwargs ) <EOL> return to_return <EOL> try : <EOL> return functools . update_wrapper ( wrapper , func ) <EOL> except AttributeError : <EOL> return wrapper <EOL> if fn and inspect . isfunction ( fn [ <NUM_LIT:0> ] ) : <EOL> return decorator ( fn [ <NUM_LIT:0> ] ) <EOL> else : <EOL> return decorator </s>

<s> """<STR_LIT>""" <EOL> import datetime <EOL> import time <EOL> from google . appengine . api import apiproxy_stub_map <EOL> from google . appengine . api import datastore <EOL> from google . appengine . api import datastore_errors <EOL> from google . appengine . api import datastore_types <EOL> from google . appengine . api import api_base_pb <EOL> from google . appengine . api . blobstore import blobstore_service_pb <EOL> from google . appengine . runtime import apiproxy_errors <EOL> __all__ = [ '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> ] <EOL> BLOB_INFO_KIND = '<STR_LIT>' <EOL> BLOB_KEY_HEADER = '<STR_LIT>' <EOL> UPLOAD_INFO_CREATION_HEADER = '<STR_LIT>' <EOL> BASE_CREATION_HEADER_FORMAT = '<STR_LIT>' <EOL> class Error ( Exception ) : <EOL> """<STR_LIT>""" <EOL> class InternalError ( Error ) : <EOL> """<STR_LIT>""" <EOL> class CreationFormatError ( Error ) : <EOL> """<STR_LIT>""" <EOL> def _ToBlobstoreError ( error ) : <EOL> """<STR_LIT>""" <EOL> error_map = { <EOL> blobstore_service_pb . BlobstoreServiceError . INTERNAL_ERROR : <EOL> InternalError , <EOL> } <EOL> if error . application_error in error_map : <EOL> return error_map [ error . application_error ] ( error . error_detail ) <EOL> else : <EOL> return error <EOL> def create_upload_url ( success_path , <EOL> _make_sync_call = apiproxy_stub_map . MakeSyncCall ) : <EOL> """<STR_LIT>""" <EOL> request = blobstore_service_pb . CreateUploadURLRequest ( ) <EOL> response = blobstore_service_pb . CreateUploadURLResponse ( ) <EOL> request . set_success_path ( success_path ) <EOL> try : <EOL> _make_sync_call ( '<STR_LIT>' , '<STR_LIT>' , request , response ) <EOL> except apiproxy_errors . ApplicationError , e : <EOL> raise _ToBlobstoreError ( e ) <EOL> return response . url ( ) <EOL> def delete ( blob_keys , _make_sync_call = apiproxy_stub_map . MakeSyncCall ) : <EOL> """<STR_LIT>""" <EOL> if isinstance ( blob_keys , ( basestring , BlobKey ) ) : <EOL> blob_keys = [ blob_keys ] <EOL> request = blobstore_service_pb . DeleteBlobRequest ( ) <EOL> for blob_key in blob_keys : <EOL> request . add_blob_key ( str ( blob_key ) ) <EOL> response = api_base_pb . VoidProto ( ) <EOL> try : <EOL> _make_sync_call ( '<STR_LIT>' , '<STR_LIT>' , request , response ) <EOL> except apiproxy_errors . ApplicationError , e : <EOL> raise _ToBlobstoreError ( e ) <EOL> def parse_creation ( creation_string ) : <EOL> """<STR_LIT>""" <EOL> def split ( string , by , count ) : <EOL> result = string . split ( by , count ) <EOL> if len ( result ) != count + <NUM_LIT:1> : <EOL> raise CreationFormatError ( <EOL> '<STR_LIT>' % creation_string ) <EOL> return result <EOL> timestamp_string , microsecond = split ( creation_string , '<STR_LIT:.>' , <NUM_LIT:1> ) <EOL> try : <EOL> timestamp = time . strptime ( timestamp_string , BASE_CREATION_HEADER_FORMAT ) <EOL> microsecond = int ( microsecond ) <EOL> except ValueError : <EOL> raise CreationFormatError ( '<STR_LIT>' % creation_string ) <EOL> return datetime . datetime ( * timestamp [ : <NUM_LIT:6> ] + tuple ( [ microsecond ] ) ) <EOL> BlobKey = datastore_types . BlobKey </s>

<s> from google . net . proto import ProtocolBuffer <EOL> import array <EOL> import dummy_thread as thread <EOL> __pychecker__ = """<STR_LIT>""" <EOL> class MemcacheServiceError ( ProtocolBuffer . ProtocolMessage ) : <EOL> OK = <NUM_LIT:0> <EOL> UNSPECIFIED_ERROR = <NUM_LIT:1> <EOL> NAMESPACE_NOT_SET = <NUM_LIT:2> <EOL> _ErrorCode_NAMES = { <EOL> <NUM_LIT:0> : "<STR_LIT:OK>" , <EOL> <NUM_LIT:1> : "<STR_LIT>" , <EOL> <NUM_LIT:2> : "<STR_LIT>" , <EOL> } <EOL> def ErrorCode_Name ( cls , x ) : return cls . _ErrorCode_NAMES . get ( x , "<STR_LIT>" ) <EOL> ErrorCode_Name = classmethod ( ErrorCode_Name ) <EOL> def __init__ ( self , contents = None ) : <EOL> pass <EOL> if contents is not None : self . MergeFromString ( contents ) <EOL> def MergeFrom ( self , x ) : <EOL> assert x is not self <EOL> def Equals ( self , x ) : <EOL> if x is self : return <NUM_LIT:1> <EOL> return <NUM_LIT:1> <EOL> def IsInitialized ( self , debug_strs = None ) : <EOL> initialized = <NUM_LIT:1> <EOL> return initialized <EOL> def ByteSize ( self ) : <EOL> n = <NUM_LIT:0> <EOL> return n + <NUM_LIT:0> <EOL> def Clear ( self ) : <EOL> pass <EOL> def OutputUnchecked ( self , out ) : <EOL> pass <EOL> def TryMerge ( self , d ) : <EOL> while d . avail ( ) > <NUM_LIT:0> : <EOL> tt = d . getVarInt32 ( ) <EOL> if ( tt == <NUM_LIT:0> ) : raise ProtocolBuffer . ProtocolBufferDecodeError <EOL> d . skipData ( tt ) <EOL> def __str__ ( self , prefix = "<STR_LIT>" , printElemNumber = <NUM_LIT:0> ) : <EOL> res = "<STR_LIT>" <EOL> return res <EOL> def _BuildTagLookupTable ( sparse , maxtag , default = None ) : <EOL> return tuple ( [ sparse . get ( i , default ) for i in xrange ( <NUM_LIT:0> , <NUM_LIT:1> + maxtag ) ] ) <EOL> _TEXT = _BuildTagLookupTable ( { <EOL> <NUM_LIT:0> : "<STR_LIT>" , <EOL> } , <NUM_LIT:0> ) <EOL> _TYPES = _BuildTagLookupTable ( { <EOL> <NUM_LIT:0> : ProtocolBuffer . Encoder . NUMERIC , <EOL> } , <NUM_LIT:0> , ProtocolBuffer . Encoder . MAX_TYPE ) <EOL> _STYLE = """<STR_LIT>""" <EOL> _STYLE_CONTENT_TYPE = """<STR_LIT>""" <EOL> class MemcacheGetRequest ( ProtocolBuffer . ProtocolMessage ) : <EOL> has_name_space_ = <NUM_LIT:0> <EOL> name_space_ = "<STR_LIT>" <EOL> def __init__ ( self , contents = None ) : <EOL> self . key_ = [ ] <EOL> if contents is not None : self . MergeFromString ( contents ) <EOL> def key_size ( self ) : return len ( self . key_ ) <EOL> def key_list ( self ) : return self . key_ <EOL> def key ( self , i ) : <EOL> return self . key_ [ i ] <EOL> def set_key ( self , i , x ) : <EOL> self . key_ [ i ] = x <EOL> def add_key ( self , x ) : <EOL> self . key_ . append ( x ) <EOL> def clear_key ( self ) : <EOL> self . key_ = [ ] <EOL> def name_space ( self ) : return self . name_space_ <EOL> def set_name_space ( self , x ) : <EOL> self . has_name_space_ = <NUM_LIT:1> <EOL> self . name_space_ = x <EOL> def clear_name_space ( self ) : <EOL> if self . has_name_space_ : <EOL> self . has_name_space_ = <NUM_LIT:0> <EOL> self . name_space_ = "<STR_LIT>" <EOL> def has_name_space ( self ) : return self . has_name_space_ <EOL> def MergeFrom ( self , x ) : <EOL> assert x is not self <EOL> for i in xrange ( x . key_size ( ) ) : self . add_key ( x . key ( i ) ) <EOL> if ( x . has_name_space ( ) ) : self . set_name_space ( x . name_space ( ) ) <EOL> def Equals ( self , x ) : <EOL> if x is self : return <NUM_LIT:1> <EOL> if len ( self . key_ ) != len ( x . key_ ) : return <NUM_LIT:0> <EOL> for e1 , e2 in zip ( self . key_ , x . key_ ) : <EOL> if e1 != e2 : return <NUM_LIT:0> <EOL> if self . has_name_space_ != x . has_name_space_ : return <NUM_LIT:0> <EOL> if self . has_name_space_ and self . name_space_ != x . name_space_ : return <NUM_LIT:0> <EOL> return <NUM_LIT:1> <EOL> def IsInitialized ( self , debug_strs = None ) : <EOL> initialized = <NUM_LIT:1> <EOL> return initialized <EOL> def ByteSize ( self ) : <EOL> n = <NUM_LIT:0> <EOL> n += <NUM_LIT:1> * len ( self . key_ ) <EOL> for i in xrange ( len ( self . key_ ) ) : n += self . lengthString ( len ( self . key_ [ i ] ) ) <EOL> if ( self . has_name_space_ ) : n += <NUM_LIT:1> + self . lengthString ( len ( self . name_space_ ) ) <EOL> return n + <NUM_LIT:0> <EOL> def Clear ( self ) : <EOL> self . clear_key ( ) <EOL> self . clear_name_space ( ) <EOL> def OutputUnchecked ( self , out ) : <EOL> for i in xrange ( len ( self . key_ ) ) : <EOL> out . putVarInt32 ( <NUM_LIT:10> ) <EOL> out . putPrefixedString ( self . key_ [ i ] ) <EOL> if ( self . has_name_space_ ) : <EOL> out . putVarInt32 ( <NUM_LIT> ) <EOL> out . putPrefixedString ( self . name_space_ ) <EOL> def TryMerge ( self , d ) : <EOL> while d . avail ( ) > <NUM_LIT:0> : <EOL> tt = d . getVarInt32 ( ) <EOL> if tt == <NUM_LIT:10> : <EOL> self . add_key ( d . getPrefixedString ( ) ) <EOL> continue <EOL> if tt == <NUM_LIT> : <EOL> self . set_name_space ( d . getPrefixedString ( ) ) <EOL> continue <EOL> if ( tt == <NUM_LIT:0> ) : raise ProtocolBuffer . ProtocolBufferDecodeError <EOL> d . skipData ( tt ) <EOL> def __str__ ( self , prefix = "<STR_LIT>" , printElemNumber = <NUM_LIT:0> ) : <EOL> res = "<STR_LIT>" <EOL> cnt = <NUM_LIT:0> <EOL> for e in self . key_ : <EOL> elm = "<STR_LIT>" <EOL> if printElemNumber : elm = "<STR_LIT>" % cnt <EOL> res += prefix + ( "<STR_LIT>" % ( elm , self . DebugFormatString ( e ) ) ) <EOL> cnt += <NUM_LIT:1> <EOL> if self . has_name_space_ : res += prefix + ( "<STR_LIT>" % self . DebugFormatString ( self . name_space_ ) ) <EOL> return res <EOL> def _BuildTagLookupTable ( sparse , maxtag , default = None ) : <EOL> return tuple ( [ sparse . get ( i , default ) for i in xrange ( <NUM_LIT:0> , <NUM_LIT:1> + maxtag ) ] ) <EOL> kkey = <NUM_LIT:1> <EOL> kname_space = <NUM_LIT:2> <EOL> _TEXT = _BuildTagLookupTable ( { <EOL> <NUM_LIT:0> : "<STR_LIT>" , <EOL> <NUM_LIT:1> : "<STR_LIT:key>" , <EOL> <NUM_LIT:2> : "<STR_LIT>" , <EOL> } , <NUM_LIT:2> ) <EOL> _TYPES = _BuildTagLookupTable ( { <EOL> <NUM_LIT:0> : ProtocolBuffer . Encoder . NUMERIC , <EOL> <NUM_LIT:1> : ProtocolBuffer . Encoder . STRING , <EOL> <NUM_LIT:2> : ProtocolBuffer . Encoder . STRING , <EOL> } , <NUM_LIT:2> , ProtocolBuffer . Encoder . MAX_TYPE ) <EOL> _STYLE = """<STR_LIT>""" <EOL> _STYLE_CONTENT_TYPE = """<STR_LIT>""" <EOL> class MemcacheGetResponse_Item ( ProtocolBuffer . ProtocolMessage ) : <EOL> has_key_ = <NUM_LIT:0> <EOL> key_ = "<STR_LIT>" <EOL> has_value_ = <NUM_LIT:0> <EOL> value_ = "<STR_LIT>" <EOL> has_flags_ = <NUM_LIT:0> <EOL> flags_ = <NUM_LIT:0> <EOL> def __init__ ( self , contents = None ) : <EOL> if contents is not None : self . MergeFromString ( contents ) <EOL> def key ( self ) : return self . key_ <EOL> def set_key ( self , x ) : <EOL> self . has_key_ = <NUM_LIT:1> <EOL> self . key_ = x <EOL> def clear_key ( self ) : <EOL> if self . has_key_ : <EOL> self . has_key_ = <NUM_LIT:0> <EOL> self . key_ = "<STR_LIT>" <EOL> def has_key ( self ) : return self . has_key_ <EOL> def value ( self ) : return self . value_ <EOL> def set_value ( self , x ) : <EOL> self . has_value_ = <NUM_LIT:1> <EOL> self . value_ = x <EOL> def clear_value ( self ) : <EOL> if self . has_value_ : <EOL> self . has_value_ = <NUM_LIT:0> <EOL> self . value_ = "<STR_LIT>" <EOL> def has_value ( self ) : return self . has_value_ <EOL> def flags ( self ) : return self . flags_ <EOL> def set_flags ( self , x ) : <EOL> self . has_flags_ = <NUM_LIT:1> <EOL> self . flags_ = x <EOL> def clear_flags ( self ) : <EOL> if self . has_flags_ : <EOL> self . has_flags_ = <NUM_LIT:0> <EOL> self . flags_ = <NUM_LIT:0> <EOL> def has_flags ( self ) : return self . has_flags_ <EOL> def MergeFrom ( self , x ) : <EOL> assert x is not self <EOL> if ( x . has_key ( ) ) : self . set_key ( x . key ( ) ) <EOL> if ( x . has_value ( ) ) : self . set_value ( x . value ( ) ) <EOL> if ( x . has_flags ( ) ) : self . set_flags ( x . flags ( ) ) <EOL> def Equals ( self , x ) : <EOL> if x is self : return <NUM_LIT:1> <EOL> if self . has_key_ != x . has_key_ : return <NUM_LIT:0> <EOL> if self . has_key_ and self . key_ != x . key_ : return <NUM_LIT:0> <EOL> if self . has_value_ != x . has_value_ : return <NUM_LIT:0> <EOL> if self . has_value_ and self . value_ != x . value_ : return <NUM_LIT:0> <EOL> if self . has_flags_ != x . has_flags_ : return <NUM_LIT:0> <EOL> if self . has_flags_ and self . flags_ != x . flags_ : return <NUM_LIT:0> <EOL> return <NUM_LIT:1> <EOL> def IsInitialized ( self , debug_strs = None ) : <EOL> initialized = <NUM_LIT:1> <EOL> if ( not self . has_key_ ) : <EOL> initialized = <NUM_LIT:0> <EOL> if debug_strs is not None : <EOL> debug_strs . append ( '<STR_LIT>' ) <EOL> if ( not self . has_value_ ) : <EOL> initialized = <NUM_LIT:0> <EOL> if debug_strs is not None : <EOL> debug_strs . append ( '<STR_LIT>' ) <EOL> return initialized <EOL> def ByteSize ( self ) : <EOL> n = <NUM_LIT:0> <EOL> n += self . lengthString ( len ( self . key_ ) ) <EOL> n += self . lengthString ( len ( self . value_ ) ) <EOL> if ( self . has_flags_ ) : n += <NUM_LIT:5> <EOL> return n + <NUM_LIT:2> <EOL> def Clear ( self ) : <EOL> self . clear_key ( ) <EOL> self . clear_value ( ) <EOL> self . clear_flags ( ) <EOL> def OutputUnchecked ( self , out ) : <EOL> out . putVarInt32 ( <NUM_LIT> ) <EOL> out . putPrefixedString ( self . key_ ) <EOL> out . putVarInt32 ( <NUM_LIT> ) <EOL> out . putPrefixedString ( self . value_ ) <EOL> if ( self . has_flags_ ) : <EOL> out . putVarInt32 ( <NUM_LIT> ) <EOL> out . put32 ( self . flags_ ) <EOL> def TryMerge ( self , d ) : <EOL> while <NUM_LIT:1> : <EOL> tt = d . getVarInt32 ( ) <EOL> if tt == <NUM_LIT:12> : break <EOL> if tt == <NUM_LIT> : <EOL> self . set_key ( d . getPrefixedString ( ) ) <EOL> continue <EOL> if tt == <NUM_LIT> : <EOL> self . set_value ( d . getPrefixedString ( ) ) <EOL> continue <EOL> if tt == <NUM_LIT> : <EOL> self . set_flags ( d . get32 ( ) ) <EOL> continue <EOL> if ( tt == <NUM_LIT:0> ) : raise ProtocolBuffer . ProtocolBufferDecodeError <EOL> d . skipData ( tt ) <EOL> def __str__ ( self , prefix = "<STR_LIT>" , printElemNumber = <NUM_LIT:0> ) : <EOL> res = "<STR_LIT>" <EOL> if self . has_key_ : res += prefix + ( "<STR_LIT>" % self . DebugFormatString ( self . key_ ) ) <EOL> if self . has_value_ : res += prefix + ( "<STR_LIT>" % self . DebugFormatString ( self . value_ ) ) <EOL> if self . has_flags_ : res += prefix + ( "<STR_LIT>" % self . DebugFormatFixed32 ( self . flags_ ) ) <EOL> return res <EOL> class MemcacheGetResponse ( ProtocolBuffer . ProtocolMessage ) : <EOL> def __init__ ( self , contents = None ) : <EOL> self . item_ = [ ] <EOL> if contents is not None : self . MergeFromString ( contents ) <EOL> def item_size ( self ) : return len ( self . item_ ) <EOL> def item_list ( self ) : return self . item_ <EOL> def item ( self , i ) : <EOL> return self . item_ [ i ] <EOL> def mutable_item ( self , i ) : <EOL> return self . item_ [ i ] <EOL> def add_item ( self ) : <EOL> x = MemcacheGetResponse_Item ( ) <EOL> self . item_ . append ( x ) <EOL> return x <EOL> def clear_item ( self ) : <EOL> self . item_ = [ ] <EOL> def MergeFrom ( self , x ) : <EOL> assert x is not self <EOL> for i in xrange ( x . item_size ( ) ) : self . add_item ( ) . CopyFrom ( x . item ( i ) ) <EOL> def Equals ( self , x ) : <EOL> if x is self : return <NUM_LIT:1> <EOL> if len ( self . item_ ) != len ( x . item_ ) : return <NUM_LIT:0> <EOL> for e1 , e2 in zip ( self . item_ , x . item_ ) : <EOL> if e1 != e2 : return <NUM_LIT:0> <EOL> return <NUM_LIT:1> <EOL> def IsInitialized ( self , debug_strs = None ) : <EOL> initialized = <NUM_LIT:1> <EOL> for p in self . item_ : <EOL> if not p . IsInitialized ( debug_strs ) : initialized = <NUM_LIT:0> <EOL> return initialized <EOL> def ByteSize ( self ) : <EOL> n = <NUM_LIT:0> <EOL> n += <NUM_LIT:2> * len ( self . item_ ) <EOL> for i in xrange ( len ( self . item_ ) ) : n += self . item_ [ i ] . ByteSize ( ) <EOL> return n + <NUM_LIT:0> <EOL> def Clear ( self ) : <EOL> self . clear_item ( ) <EOL> def OutputUnchecked ( self , out ) : <EOL> for i in xrange ( len ( self . item_ ) ) : <EOL> out . putVarInt32 ( <NUM_LIT:11> ) <EOL> self . item_ [ i ] . OutputUnchecked ( out ) <EOL> out . putVarInt32 ( <NUM_LIT:12> ) <EOL> def TryMerge ( self , d ) : <EOL> while d . avail ( ) > <NUM_LIT:0> : <EOL> tt = d . getVarInt32 ( ) <EOL> if tt == <NUM_LIT:11> : <EOL> self . add_item ( ) . TryMerge ( d ) <EOL> continue <EOL> if ( tt == <NUM_LIT:0> ) : raise ProtocolBuffer . ProtocolBufferDecodeError <EOL> d . skipData ( tt ) <EOL> def __str__ ( self , prefix = "<STR_LIT>" , printElemNumber = <NUM_LIT:0> ) : <EOL> res = "<STR_LIT>" <EOL> cnt = <NUM_LIT:0> <EOL> for e in self . item_ : <EOL> elm = "<STR_LIT>" <EOL> if printElemNumber : elm = "<STR_LIT>" % cnt <EOL> res += prefix + ( "<STR_LIT>" % elm ) <EOL> res += e . __str__ ( prefix + "<STR_LIT:U+0020>" , printElemNumber ) <EOL> res += prefix + "<STR_LIT>" <EOL> cnt += <NUM_LIT:1> <EOL> return res <EOL> def _BuildTagLookupTable ( sparse , maxtag , default = None ) : <EOL> return tuple ( [ sparse . get ( i , default ) for i in xrange ( <NUM_LIT:0> , <NUM_LIT:1> + maxtag ) ] ) <EOL> kItemGroup = <NUM_LIT:1> <EOL> kItemkey = <NUM_LIT:2> <EOL> kItemvalue = <NUM_LIT:3> <EOL> kItemflags = <NUM_LIT:4> <EOL> _TEXT = _BuildTagLookupTable ( { <EOL> <NUM_LIT:0> : "<STR_LIT>" , <EOL> <NUM_LIT:1> : "<STR_LIT>" , <EOL> <NUM_LIT:2> : "<STR_LIT:key>" , <EOL> <NUM_LIT:3> : "<STR_LIT:value>" , <EOL> <NUM_LIT:4> : "<STR_LIT>" , <EOL> } , <NUM_LIT:4> ) <EOL> _TYPES = _BuildTagLookupTable ( { <EOL> <NUM_LIT:0> : ProtocolBuffer . Encoder . NUMERIC , <EOL> <NUM_LIT:1> : ProtocolBuffer . Encoder . STARTGROUP , <EOL> <NUM_LIT:2> : ProtocolBuffer . Encoder . STRING , <EOL> <NUM_LIT:3> : ProtocolBuffer . Encoder . STRING , <EOL> <NUM_LIT:4> : ProtocolBuffer . Encoder . FLOAT , <EOL> } , <NUM_LIT:4> , ProtocolBuffer . Encoder . MAX_TYPE ) <EOL> _STYLE = """<STR_LIT>""" <EOL> _STYLE_CONTENT_TYPE = """<STR_LIT>""" <EOL> class MemcacheSetRequest_Item ( ProtocolBuffer . ProtocolMessage ) : <EOL> has_key_ = <NUM_LIT:0> <EOL> key_ = "<STR_LIT>" <EOL> has_value_ = <NUM_LIT:0> <EOL> value_ = "<STR_LIT>" <EOL> has_flags_ = <NUM_LIT:0> <EOL> flags_ = <NUM_LIT:0> <EOL> has_set_policy_ = <NUM_LIT:0> <EOL> set_policy_ = <NUM_LIT:1> <EOL> has_expiration_time_ = <NUM_LIT:0> <EOL> expiration_time_ = <NUM_LIT:0> <EOL> def __init__ ( self , contents = None ) : <EOL> if contents is not None : self . MergeFromString ( contents ) <EOL> def key ( self ) : return self . key_ <EOL> def set_key ( self , x ) : <EOL> self . has_key_ = <NUM_LIT:1> <EOL> self . key_ = x <EOL> def clear_key ( self ) : <EOL> if self . has_key_ : <EOL> self . has_key_ = <NUM_LIT:0> <EOL> self . key_ = "<STR_LIT>" <EOL> def has_key ( self ) : return self . has_key_ <EOL> def value ( self ) : return self . value_ <EOL> def set_value ( self , x ) : <EOL> self . has_value_ = <NUM_LIT:1> <EOL> self . value_ = x <EOL> def clear_value ( self ) : <EOL> if self . has_value_ : <EOL> self . has_value_ = <NUM_LIT:0> <EOL> self . value_ = "<STR_LIT>" <EOL> def has_value ( self ) : return self . has_value_ <EOL> def flags ( self ) : return self . flags_ <EOL> def set_flags ( self , x ) : <EOL> self . has_flags_ = <NUM_LIT:1> <EOL> self . flags_ = x <EOL> def clear_flags ( self ) : <EOL> if self . has_flags_ : <EOL> self . has_flags_ = <NUM_LIT:0> <EOL> self . flags_ = <NUM_LIT:0> <EOL> def has_flags ( self ) : return self . has_flags_ <EOL> def set_policy ( self ) : return self . set_policy_ <EOL> def set_set_policy ( self , x ) : <EOL> self . has_set_policy_ = <NUM_LIT:1> <EOL> self . set_policy_ = x <EOL> def clear_set_policy ( self ) : <EOL> if self . has_set_policy_ : <EOL> self . has_set_policy_ = <NUM_LIT:0> <EOL> self . set_policy_ = <NUM_LIT:1> <EOL> def has_set_policy ( self ) : return self . has_set_policy_ <EOL> def expiration_time ( self ) : return self . expiration_time_ <EOL> def set_expiration_time ( self , x ) : <EOL> self . has_expiration_time_ = <NUM_LIT:1> <EOL> self . expiration_time_ = x <EOL> def clear_expiration_time ( self ) : <EOL> if self . has_expiration_time_ : <EOL> self . has_expiration_time_ = <NUM_LIT:0> <EOL> self . expiration_time_ = <NUM_LIT:0> <EOL> def has_expiration_time ( self ) : return self . has_expiration_time_ <EOL> def MergeFrom ( self , x ) : <EOL> assert x is not self <EOL> if ( x . has_key ( ) ) : self . set_key ( x . key ( ) ) <EOL> if ( x . has_value ( ) ) : self . set_value ( x . value ( ) ) <EOL> if ( x . has_flags ( ) ) : self . set_flags ( x . flags ( ) ) <EOL> if ( x . has_set_policy ( ) ) : self . set_set_policy ( x . set_policy ( ) ) <EOL> if ( x . has_expiration_time ( ) ) : self . set_expiration_time ( x . expiration_time ( ) ) <EOL> def Equals ( self , x ) : <EOL> if x is self : return <NUM_LIT:1> <EOL> if self . has_key_ != x . has_key_ : return <NUM_LIT:0> <EOL> if self . has_key_ and self . key_ != x . key_ : return <NUM_LIT:0> <EOL> if self . has_value_ != x . has_value_ : return <NUM_LIT:0> <EOL> if self . has_value_ and self . value_ != x . value_ : return <NUM_LIT:0> <EOL> if self . has_flags_ != x . has_flags_ : return <NUM_LIT:0> <EOL> if self . has_flags_ and self . flags_ != x . flags_ : return <NUM_LIT:0> <EOL> if self . has_set_policy_ != x . has_set_policy_ : return <NUM_LIT:0> <EOL> if self . has_set_policy_ and self . set_policy_ != x . set_policy_ : return <NUM_LIT:0> <EOL> if self . has_expiration_time_ != x . has_expiration_time_ : return <NUM_LIT:0> <EOL> if self . has_expiration_time_ and self . expiration_time_ != x . expiration_time_ : return <NUM_LIT:0> <EOL> return <NUM_LIT:1> <EOL> def IsInitialized ( self , debug_strs = None ) : <EOL> initialized = <NUM_LIT:1> <EOL> if ( not self . has_key_ ) : <EOL> initialized = <NUM_LIT:0> <EOL> if debug_strs is not None : <EOL> debug_strs . append ( '<STR_LIT>' ) <EOL> if ( not self . has_value_ ) : <EOL> initialized = <NUM_LIT:0> <EOL> if debug_strs is not None : <EOL> debug_strs . append ( '<STR_LIT>' ) <EOL> return initialized <EOL> def ByteSize ( self ) : <EOL> n = <NUM_LIT:0> <EOL> n += self . lengthString ( len ( self . key_ ) ) <EOL> n += self . lengthString ( len ( self . value_ ) ) <EOL> if ( self . has_flags_ ) : n += <NUM_LIT:5> <EOL> if ( self . has_set_policy_ ) : n += <NUM_LIT:1> + self . lengthVarInt64 ( self . set_policy_ ) <EOL> if ( self . has_expiration_time_ ) : n += <NUM_LIT:5> <EOL> return n + <NUM_LIT:2> <EOL> def Clear ( self ) : <EOL> self . clear_key ( ) <EOL> self . clear_value ( ) <EOL> self . clear_flags ( ) <EOL> self . clear_set_policy ( ) <EOL> self . clear_expiration_time ( ) <EOL> def OutputUnchecked ( self , out ) : <EOL> out . putVarInt32 ( <NUM_LIT> ) <EOL> out . putPrefixedString ( self . key_ ) <EOL> out . putVarInt32 ( <NUM_LIT> ) <EOL> out . putPrefixedString ( self . value_ ) <EOL> if ( self . has_flags_ ) : <EOL> out . putVarInt32 ( <NUM_LIT> ) <EOL> out . put32 ( self . flags_ ) <EOL> if ( self . has_set_policy_ ) : <EOL> out . putVarInt32 ( <NUM_LIT> ) <EOL> out . putVarInt32 ( self . set_policy_ ) <EOL> if ( self . has_expiration_time_ ) : <EOL> out . putVarInt32 ( <NUM_LIT> ) <EOL> out . put32 ( self . expiration_time_ ) <EOL> def TryMerge ( self , d ) : <EOL> while <NUM_LIT:1> : <EOL> tt = d . getVarInt32 ( ) <EOL> if tt == <NUM_LIT:12> : break <EOL> if tt == <NUM_LIT> : <EOL> self . set_key ( d . getPrefixedString ( ) ) <EOL> continue <EOL> if tt == <NUM_LIT> : <EOL> self . set_value ( d . getPrefixedString ( ) ) <EOL> continue <EOL> if tt == <NUM_LIT> : <EOL> self . set_flags ( d . get32 ( ) ) <EOL> continue <EOL> if tt == <NUM_LIT> : <EOL> self . set_set_policy ( d . getVarInt32 ( ) ) <EOL> continue <EOL> if tt == <NUM_LIT> : <EOL> self . set_expiration_time ( d . get32 ( ) ) <EOL> continue <EOL> if ( tt == <NUM_LIT:0> ) : raise ProtocolBuffer . ProtocolBufferDecodeError <EOL> d . skipData ( tt ) <EOL> def __str__ ( self , prefix = "<STR_LIT>" , printElemNumber = <NUM_LIT:0> ) : <EOL> res = "<STR_LIT>" <EOL> if self . has_key_ : res += prefix + ( "<STR_LIT>" % self . DebugFormatString ( self . key_ ) ) <EOL> if self . has_value_ : res += prefix + ( "<STR_LIT>" % self . DebugFormatString ( self . value_ ) ) <EOL> if self . has_flags_ : res += prefix + ( "<STR_LIT>" % self . DebugFormatFixed32 ( self . flags_ ) ) <EOL> if self . has_set_policy_ : res += prefix + ( "<STR_LIT>" % self . DebugFormatInt32 ( self . set_policy_ ) ) <EOL> if self . has_expiration_time_ : res += prefix + ( "<STR_LIT>" % self . DebugFormatFixed32 ( self . expiration_time_ ) ) <EOL> return res <EOL> class MemcacheSetRequest ( ProtocolBuffer . ProtocolMessage ) : <EOL> SET = <NUM_LIT:1> <EOL> ADD = <NUM_LIT:2> <EOL> REPLACE = <NUM_LIT:3> <EOL> _SetPolicy_NAMES = { <EOL> <NUM_LIT:1> : "<STR_LIT>" , <EOL> <NUM_LIT:2> : "<STR_LIT>" , <EOL> <NUM_LIT:3> : "<STR_LIT>" , <EOL> } <EOL> def SetPolicy_Name ( cls , x ) : return cls . _SetPolicy_NAMES . get ( x , "<STR_LIT>" ) <EOL> SetPolicy_Name = classmethod ( SetPolicy_Name ) <EOL> has_name_space_ = <NUM_LIT:0> <EOL> name_space_ = "<STR_LIT>" <EOL> def __init__ ( self , contents = None ) : <EOL> self . item_ = [ ] <EOL> if contents is not None : self . MergeFromString ( contents ) <EOL> def item_size ( self ) : return len ( self . item_ ) <EOL> def item_list ( self ) : return self . item_ <EOL> def item ( self , i ) : <EOL> return self . item_ [ i ] <EOL> def mutable_item ( self , i ) : <EOL> return self . item_ [ i ] <EOL> def add_item ( self ) : <EOL> x = MemcacheSetRequest_Item ( ) <EOL> self . item_ . append ( x ) <EOL> return x <EOL> def clear_item ( self ) : <EOL> self . item_ = [ ] <EOL> def name_space ( self ) : return self . name_space_ <EOL> def set_name_space ( self , x ) : <EOL> self . has_name_space_ = <NUM_LIT:1> <EOL> self . name_space_ = x <EOL> def clear_name_space ( self ) : <EOL> if self . has_name_space_ : <EOL> self . has_name_space_ = <NUM_LIT:0> <EOL> self . name_space_ = "<STR_LIT>" <EOL> def has_name_space ( self ) : return self . has_name_space_ <EOL> def MergeFrom ( self , x ) : <EOL> assert x is not self <EOL> for i in xrange ( x . item_size ( ) ) : self . add_item ( ) . CopyFrom ( x . item ( i ) ) <EOL> if ( x . has_name_space ( ) ) : self . set_name_space ( x . name_space ( ) ) <EOL> def Equals ( self , x ) : <EOL> if x is self : return <NUM_LIT:1> <EOL> if len ( self . item_ ) != len ( x . item_ ) : return <NUM_LIT:0> <EOL> for e1 , e2 in zip ( self . item_ , x . item_ ) : <EOL> if e1 != e2 : return <NUM_LIT:0> <EOL> if self . has_name_space_ != x . has_name_space_ : return <NUM_LIT:0> <EOL> if self . has_name_space_ and self . name_space_ != x . name_space_ : return <NUM_LIT:0> <EOL> return <NUM_LIT:1> <EOL> def IsInitialized ( self , debug_strs = None ) : <EOL> initialized = <NUM_LIT:1> <EOL> for p in self . item_ : <EOL> if not p . IsInitialized ( debug_strs ) : initialized = <NUM_LIT:0> <EOL> return initialized <EOL> def ByteSize ( self ) : <EOL> n = <NUM_LIT:0> <EOL> n += <NUM_LIT:2> * len ( self . item_ ) <EOL> for i in xrange ( len ( self . item_ ) ) : n += self . item_ [ i ] . ByteSize ( ) <EOL> if ( self . has_name_space_ ) : n += <NUM_LIT:1> + self . lengthString ( len ( self . name_space_ ) ) <EOL> return n + <NUM_LIT:0> <EOL> def Clear ( self ) : <EOL> self . clear_item ( ) <EOL> self . clear_name_space ( ) <EOL> def OutputUnchecked ( self , out ) : <EOL> for i in xrange ( len ( self . item_ ) ) : <EOL> out . putVarInt32 ( <NUM_LIT:11> ) <EOL> self . item_ [ i ] . OutputUnchecked ( out ) <EOL> out . putVarInt32 ( <NUM_LIT:12> ) <EOL> if ( self . has_name_space_ ) : <EOL> out . putVarInt32 ( <NUM_LIT> ) <EOL> out . putPrefixedString ( self . name_space_ ) <EOL> def TryMerge ( self , d ) : <EOL> while d . avail ( ) > <NUM_LIT:0> : <EOL> tt = d . getVarInt32 ( ) <EOL> if tt == <NUM_LIT:11> : <EOL> self . add_item ( ) . TryMerge ( d ) <EOL> continue <EOL> if tt == <NUM_LIT> : <EOL> self . set_name_space ( d . getPrefixedString ( ) ) <EOL> continue <EOL> if ( tt == <NUM_LIT:0> ) : raise ProtocolBuffer . ProtocolBufferDecodeError <EOL> d . skipData ( tt ) <EOL> def __str__ ( self , prefix = "<STR_LIT>" , printElemNumber = <NUM_LIT:0> ) : <EOL> res = "<STR_LIT>" <EOL> cnt = <NUM_LIT:0> <EOL> for e in self . item_ : <EOL> elm = "<STR_LIT>" <EOL> if printElemNumber : elm = "<STR_LIT>" % cnt <EOL> res += prefix + ( "<STR_LIT>" % elm ) <EOL> res += e . __str__ ( prefix + "<STR_LIT:U+0020>" , printElemNumber ) <EOL> res += prefix + "<STR_LIT>" <EOL> cnt += <NUM_LIT:1> <EOL> if self . has_name_space_ : res += prefix + ( "<STR_LIT>" % self . DebugFormatString ( self . name_space_ ) ) <EOL> return res <EOL> def _BuildTagLookupTable ( sparse , maxtag , default = None ) : <EOL> return tuple ( [ sparse . get ( i , default ) for i in xrange ( <NUM_LIT:0> , <NUM_LIT:1> + maxtag ) ] ) <EOL> kItemGroup = <NUM_LIT:1> <EOL> kItemkey = <NUM_LIT:2> <EOL> kItemvalue = <NUM_LIT:3> <EOL> kItemflags = <NUM_LIT:4> <EOL> kItemset_policy = <NUM_LIT:5> <EOL> kItemexpiration_time = <NUM_LIT:6> <EOL> kname_space = <NUM_LIT:7> <EOL> _TEXT = _BuildTagLookupTable ( { <EOL> <NUM_LIT:0> : "<STR_LIT>" , <EOL> <NUM_LIT:1> : "<STR_LIT>" , <EOL> <NUM_LIT:2> : "<STR_LIT:key>" , <EOL> <NUM_LIT:3> : "<STR_LIT:value>" , <EOL> <NUM_LIT:4> : "<STR_LIT>" , <EOL> <NUM_LIT:5> : "<STR_LIT>" , <EOL> <NUM_LIT:6> : "<STR_LIT>" , <EOL> <NUM_LIT:7> : "<STR_LIT>" , <EOL> } , <NUM_LIT:7> ) <EOL> _TYPES = _BuildTagLookupTable ( { <EOL> <NUM_LIT:0> : ProtocolBuffer . Encoder . NUMERIC , <EOL> <NUM_LIT:1> : ProtocolBuffer . Encoder . STARTGROUP , <EOL> <NUM_LIT:2> : ProtocolBuffer . Encoder . STRING , <EOL> <NUM_LIT:3> : ProtocolBuffer . Encoder . STRING , <EOL> <NUM_LIT:4> : ProtocolBuffer . Encoder . FLOAT , <EOL> <NUM_LIT:5> : ProtocolBuffer . Encoder . NUMERIC , <EOL> <NUM_LIT:6> : ProtocolBuffer . Encoder . FLOAT , <EOL> <NUM_LIT:7> : ProtocolBuffer . Encoder . STRING , <EOL> } , <NUM_LIT:7> , ProtocolBuffer . Encoder . MAX_TYPE ) <EOL> _STYLE = """<STR_LIT>""" <EOL> _STYLE_CONTENT_TYPE = """<STR_LIT>""" <EOL> class MemcacheSetResponse ( ProtocolBuffer . ProtocolMessage ) : <EOL> STORED = <NUM_LIT:1> <EOL> NOT_STORED = <NUM_LIT:2> <EOL> ERROR = <NUM_LIT:3> <EOL> _SetStatusCode_NAMES = { <EOL> <NUM_LIT:1> : "<STR_LIT>" , <EOL> <NUM_LIT:2> : "<STR_LIT>" , <EOL> <NUM_LIT:3> : "<STR_LIT>" , <EOL> } <EOL> def SetStatusCode_Name ( cls , x ) : return cls . _SetStatusCode_NAMES . get ( x , "<STR_LIT>" ) <EOL> SetStatusCode_Name = classmethod ( SetStatusCode_Name ) <EOL> def __init__ ( self , contents = None ) : <EOL> self . set_status_ = [ ] <EOL> if contents is not None : self . MergeFromString ( contents ) <EOL> def set_status_size ( self ) : return len ( self . set_status_ ) <EOL> def set_status_list ( self ) : return self . set_status_ <EOL> def set_status ( self , i ) : <EOL> return self . set_status_ [ i ] <EOL> def set_set_status ( self , i , x ) : <EOL> self . set_status_ [ i ] = x <EOL> def add_set_status ( self , x ) : <EOL> self . set_status_ . append ( x ) <EOL> def clear_set_status ( self ) : <EOL> self . set_status_ = [ ] <EOL> def MergeFrom ( self , x ) : <EOL> assert x is not self <EOL> for i in xrange ( x . set_status_size ( ) ) : self . add_set_status ( x . set_status ( i ) ) <EOL> def Equals ( self , x ) : <EOL> if x is self : return <NUM_LIT:1> <EOL> if len ( self . set_status_ ) != len ( x . set_status_ ) : return <NUM_LIT:0> <EOL> for e1 , e2 in zip ( self . set_status_ , x . set_status_ ) : <EOL> if e1 != e2 : return <NUM_LIT:0> <EOL> return <NUM_LIT:1> <EOL> def IsInitialized ( self , debug_strs = None ) : <EOL> initialized = <NUM_LIT:1> <EOL> return initialized <EOL> def ByteSize ( self ) : <EOL> n = <NUM_LIT:0> <EOL> n += <NUM_LIT:1> * len ( self . set_status_ ) <EOL> for i in xrange ( len ( self . set_status_ ) ) : n += self . lengthVarInt64 ( self . set_status_ [ i ] ) <EOL> return n + <NUM_LIT:0> <EOL> def Clear ( self ) : <EOL> self . clear_set_status ( ) <EOL> def OutputUnchecked ( self , out ) : <EOL> for i in xrange ( len ( self . set_status_ ) ) : <EOL> out . putVarInt32 ( <NUM_LIT:8> ) <EOL> out . putVarInt32 ( self . set_status_ [ i ] ) <EOL> def TryMerge ( self , d ) : <EOL> while d . avail ( ) > <NUM_LIT:0> : <EOL> tt = d . getVarInt32 ( ) <EOL> if tt == <NUM_LIT:8> : <EOL> self . add_set_status ( d . getVarInt32 ( ) ) <EOL> continue <EOL> if ( tt == <NUM_LIT:0> ) : raise ProtocolBuffer . ProtocolBufferDecodeError <EOL> d . skipData ( tt ) <EOL> def __str__ ( self , prefix = "<STR_LIT>" , printElemNumber = <NUM_LIT:0> ) : <EOL> res = "<STR_LIT>" <EOL> cnt = <NUM_LIT:0> <EOL> for e in self . set_status_ : <EOL> elm = "<STR_LIT>" <EOL> if printElemNumber : elm = "<STR_LIT>" % cnt <EOL> res += prefix + ( "<STR_LIT>" % ( elm , self . DebugFormatInt32 ( e ) ) ) <EOL> cnt += <NUM_LIT:1> <EOL> return res <EOL> def _BuildTagLookupTable ( sparse , maxtag , default = None ) : <EOL> return tuple ( [ sparse . get ( i , default ) for i in xrange ( <NUM_LIT:0> , <NUM_LIT:1> + maxtag ) ] ) <EOL> kset_status = <NUM_LIT:1> <EOL> _TEXT = _BuildTagLookupTable ( { <EOL> <NUM_LIT:0> : "<STR_LIT>" , <EOL> <NUM_LIT:1> : "<STR_LIT>" , <EOL> } , <NUM_LIT:1> ) <EOL> _TYPES = _BuildTagLookupTable ( { <EOL> <NUM_LIT:0> : ProtocolBuffer . Encoder . NUMERIC , <EOL> <NUM_LIT:1> : ProtocolBuffer . Encoder . NUMERIC , <EOL> } , <NUM_LIT:1> , ProtocolBuffer . Encoder . MAX_TYPE ) <EOL> _STYLE = """<STR_LIT>""" <EOL> _STYLE_CONTENT_TYPE = """<STR_LIT>""" <EOL> class MemcacheDeleteRequest_Item ( ProtocolBuffer . ProtocolMessage ) : <EOL> has_key_ = <NUM_LIT:0> <EOL> key_ = "<STR_LIT>" <EOL> has_delete_time_ = <NUM_LIT:0> <EOL> delete_time_ = <NUM_LIT:0> <EOL> def __init__ ( self , contents = None ) : <EOL> if contents is not None : self . MergeFromString ( contents ) <EOL> def key ( self ) : return self . key_ <EOL> def set_key ( self , x ) : <EOL> self . has_key_ = <NUM_LIT:1> <EOL> self . key_ = x <EOL> def clear_key ( self ) : <EOL> if self . has_key_ : <EOL> self . has_key_ = <NUM_LIT:0> <EOL> self . key_ = "<STR_LIT>" <EOL> def has_key ( self ) : return self . has_key_ <EOL> def delete_time ( self ) : return self . delete_time_ <EOL> def set_delete_time ( self , x ) : <EOL> self . has_delete_time_ = <NUM_LIT:1> <EOL> self . delete_time_ = x <EOL> def clear_delete_time ( self ) : <EOL> if self . has_delete_time_ : <EOL> self . has_delete_time_ = <NUM_LIT:0> <EOL> self . delete_time_ = <NUM_LIT:0> <EOL> def has_delete_time ( self ) : return self . has_delete_time_ <EOL> def MergeFrom ( self , x ) : <EOL> assert x is not self <EOL> if ( x . has_key ( ) ) : self . set_key ( x . key ( ) ) <EOL> if ( x . has_delete_time ( ) ) : self . set_delete_time ( x . delete_time ( ) ) <EOL> def Equals ( self , x ) : <EOL> if x is self : return <NUM_LIT:1> <EOL> if self . has_key_ != x . has_key_ : return <NUM_LIT:0> <EOL> if self . has_key_ and self . key_ != x . key_ : return <NUM_LIT:0> <EOL> if self . has_delete_time_ != x . has_delete_time_ : return <NUM_LIT:0> <EOL> if self . has_delete_time_ and self . delete_time_ != x . delete_time_ : return <NUM_LIT:0> <EOL> return <NUM_LIT:1> <EOL> def IsInitialized ( self , debug_strs = None ) : <EOL> initialized = <NUM_LIT:1> <EOL> if ( not self . has_key_ ) : <EOL> initialized = <NUM_LIT:0> <EOL> if debug_strs is not None : <EOL> debug_strs . append ( '<STR_LIT>' ) <EOL> return initialized <EOL> def ByteSize ( self ) : <EOL> n = <NUM_LIT:0> <EOL> n += self . lengthString ( len ( self . key_ ) ) <EOL> if ( self . has_delete_time_ ) : n += <NUM_LIT:5> <EOL> return n + <NUM_LIT:1> <EOL> def Clear ( self ) : <EOL> self . clear_key ( ) <EOL> self . clear_delete_time ( ) <EOL> def OutputUnchecked ( self , out ) : <EOL> out . putVarInt32 ( <NUM_LIT> ) <EOL> out . putPrefixedString ( self . key_ ) <EOL> if ( self . has_delete_time_ ) : <EOL> out . putVarInt32 ( <NUM_LIT> ) <EOL> out . put32 ( self . delete_time_ ) <EOL> def TryMerge ( self , d ) : <EOL> while <NUM_LIT:1> : <EOL> tt = d . getVarInt32 ( ) <EOL> if tt == <NUM_LIT:12> : break <EOL> if tt == <NUM_LIT> : <EOL> self . set_key ( d . getPrefixedString ( ) ) <EOL> continue <EOL> if tt == <NUM_LIT> : <EOL> self . set_delete_time ( d . get32 ( ) ) <EOL> continue <EOL> if ( tt == <NUM_LIT:0> ) : raise ProtocolBuffer . ProtocolBufferDecodeError <EOL> d . skipData ( tt ) <EOL> def __str__ ( self , prefix = "<STR_LIT>" , printElemNumber = <NUM_LIT:0> ) : <EOL> res = "<STR_LIT>" <EOL> if self . has_key_ : res += prefix + ( "<STR_LIT>" % self . DebugFormatString ( self . key_ ) ) <EOL> if self . has_delete_time_ : res += prefix + ( "<STR_LIT>" % self . DebugFormatFixed32 ( self . delete_time_ ) ) <EOL> return res <EOL> class MemcacheDeleteRequest ( ProtocolBuffer . ProtocolMessage ) : <EOL> has_name_space_ = <NUM_LIT:0> <EOL> name_space_ = "<STR_LIT>" <EOL> def __init__ ( self , contents = None ) : <EOL> self . item_ = [ ] <EOL> if contents is not None : self . MergeFromString ( contents ) <EOL> def item_size ( self ) : return len ( self . item_ ) <EOL> def item_list ( self ) : return self . item_ <EOL> def item ( self , i ) : <EOL> return self . item_ [ i ] <EOL> def mutable_item ( self , i ) : <EOL> return self . item_ [ i ] <EOL> def add_item ( self ) : <EOL> x = MemcacheDeleteRequest_Item ( ) <EOL> self . item_ . append ( x ) <EOL> return x <EOL> def clear_item ( self ) : <EOL> self . item_ = [ ] <EOL> def name_space ( self ) : return self . name_space_ <EOL> def set_name_space ( self , x ) : <EOL> self . has_name_space_ = <NUM_LIT:1> <EOL> self . name_space_ = x <EOL> def clear_name_space ( self ) : <EOL> if self . has_name_space_ : <EOL> self . has_name_space_ = <NUM_LIT:0> <EOL> self . name_space_ = "<STR_LIT>" <EOL> def has_name_space ( self ) : return self . has_name_space_ <EOL> def MergeFrom ( self , x ) : <EOL> assert x is not self <EOL> for i in xrange ( x . item_size ( ) ) : self . add_item ( ) . CopyFrom ( x . item ( i ) ) <EOL> if ( x . has_name_space ( ) ) : self . set_name_space ( x . name_space ( ) ) <EOL> def Equals ( self , x ) : <EOL> if x is self : return <NUM_LIT:1> <EOL> if len ( self . item_ ) != len ( x . item_ ) : return <NUM_LIT:0> <EOL> for e1 , e2 in zip ( self . item_ , x . item_ ) : <EOL> if e1 != e2 : return <NUM_LIT:0> <EOL> if self . has_name_space_ != x . has_name_space_ : return <NUM_LIT:0> <EOL> if self . has_name_space_ and self . name_space_ != x . name_space_ : return <NUM_LIT:0> <EOL> return <NUM_LIT:1> <EOL> def IsInitialized ( self , debug_strs = None ) : <EOL> initialized = <NUM_LIT:1> <EOL> for p in self . item_ : <EOL> if not p . IsInitialized ( debug_strs ) : initialized = <NUM_LIT:0> <EOL> return initialized <EOL> def ByteSize ( self ) : <EOL> n = <NUM_LIT:0> <EOL> n += <NUM_LIT:2> * len ( self . item_ ) <EOL> for i in xrange ( len ( self . item_ ) ) : n += self . item_ [ i ] . ByteSize ( ) <EOL> if ( self . has_name_space_ ) : n += <NUM_LIT:1> + self . lengthString ( len ( self . name_space_ ) ) <EOL> return n + <NUM_LIT:0> <EOL> def Clear ( self ) : <EOL> self . clear_item ( ) <EOL> self . clear_name_space ( ) <EOL> def OutputUnchecked ( self , out ) : <EOL> for i in xrange ( len ( self . item_ ) ) : <EOL> out . putVarInt32 ( <NUM_LIT:11> ) <EOL> self . item_ [ i ] . OutputUnchecked ( out ) <EOL> out . putVarInt32 ( <NUM_LIT:12> ) <EOL> if ( self . has_name_space_ ) : <EOL> out . putVarInt32 ( <NUM_LIT> ) <EOL> out . putPrefixedString ( self . name_space_ ) <EOL> def TryMerge ( self , d ) : <EOL> while d . avail ( ) > <NUM_LIT:0> : <EOL> tt = d . getVarInt32 ( ) <EOL> if tt == <NUM_LIT:11> : <EOL> self . add_item ( ) . TryMerge ( d ) <EOL> continue <EOL> if tt == <NUM_LIT> : <EOL> self . set_name_space ( d . getPrefixedString ( ) ) <EOL> continue <EOL> if ( tt == <NUM_LIT:0> ) : raise ProtocolBuffer . ProtocolBufferDecodeError <EOL> d . skipData ( tt ) <EOL> def __str__ ( self , prefix = "<STR_LIT>" , printElemNumber = <NUM_LIT:0> ) : <EOL> res = "<STR_LIT>" <EOL> cnt = <NUM_LIT:0> <EOL> for e in self . item_ : <EOL> elm = "<STR_LIT>" <EOL> if printElemNumber : elm = "<STR_LIT>" % cnt <EOL> res += prefix + ( "<STR_LIT>" % elm ) <EOL> res += e . __str__ ( prefix + "<STR_LIT:U+0020>" , printElemNumber ) <EOL> res += prefix + "<STR_LIT>" <EOL> cnt += <NUM_LIT:1> <EOL> if self . has_name_space_ : res += prefix + ( "<STR_LIT>" % self . DebugFormatString ( self . name_space_ ) ) <EOL> return res <EOL> def _BuildTagLookupTable ( sparse , maxtag , default = None ) : <EOL> return tuple ( [ sparse . get ( i , default ) for i in xrange ( <NUM_LIT:0> , <NUM_LIT:1> + maxtag ) ] ) <EOL> kItemGroup = <NUM_LIT:1> <EOL> kItemkey = <NUM_LIT:2> <EOL> kItemdelete_time = <NUM_LIT:3> <EOL> kname_space = <NUM_LIT:4> <EOL> _TEXT = _BuildTagLookupTable ( { <EOL> <NUM_LIT:0> : "<STR_LIT>" , <EOL> <NUM_LIT:1> : "<STR_LIT>" , <EOL> <NUM_LIT:2> : "<STR_LIT:key>" , <EOL> <NUM_LIT:3> : "<STR_LIT>" , <EOL> <NUM_LIT:4> : "<STR_LIT>" , <EOL> } , <NUM_LIT:4> ) <EOL> _TYPES = _BuildTagLookupTable ( { <EOL> <NUM_LIT:0> : ProtocolBuffer . Encoder . NUMERIC , <EOL> <NUM_LIT:1> : ProtocolBuffer . Encoder . STARTGROUP , <EOL> <NUM_LIT:2> : ProtocolBuffer . Encoder . STRING , <EOL> <NUM_LIT:3> : ProtocolBuffer . Encoder . FLOAT , <EOL> <NUM_LIT:4> : ProtocolBuffer . Encoder . STRING , <EOL> } , <NUM_LIT:4> , ProtocolBuffer . Encoder . MAX_TYPE ) <EOL> _STYLE = """<STR_LIT>""" <EOL> _STYLE_CONTENT_TYPE = """<STR_LIT>""" <EOL> class MemcacheDeleteResponse ( ProtocolBuffer . ProtocolMessage ) : <EOL> DELETED = <NUM_LIT:1> <EOL> NOT_FOUND = <NUM_LIT:2> <EOL> _DeleteStatusCode_NAMES = { <EOL> <NUM_LIT:1> : "<STR_LIT>" , <EOL> <NUM_LIT:2> : "<STR_LIT>" , <EOL> } <EOL> def DeleteStatusCode_Name ( cls , x ) : return cls . _DeleteStatusCode_NAMES . get ( x , "<STR_LIT>" ) <EOL> DeleteStatusCode_Name = classmethod ( DeleteStatusCode_Name ) <EOL> def __init__ ( self , contents = None ) : <EOL> self . delete_status_ = [ ] <EOL> if contents is not None : self . MergeFromString ( contents ) <EOL> def delete_status_size ( self ) : return len ( self . delete_status_ ) <EOL> def delete_status_list ( self ) : return self . delete_status_ <EOL> def delete_status ( self , i ) : <EOL> return self . delete_status_ [ i ] <EOL> def set_delete_status ( self , i , x ) : <EOL> self . delete_status_ [ i ] = x <EOL> def add_delete_status ( self , x ) : <EOL> self . delete_status_ . append ( x ) <EOL> def clear_delete_status ( self ) : <EOL> self . delete_status_ = [ ] <EOL> def MergeFrom ( self , x ) : <EOL> assert x is not self <EOL> for i in xrange ( x . delete_status_size ( ) ) : self . add_delete_status ( x . delete_status ( i ) ) <EOL> def Equals ( self , x ) : <EOL> if x is self : return <NUM_LIT:1> <EOL> if len ( self . delete_status_ ) != len ( x . delete_status_ ) : return <NUM_LIT:0> <EOL> for e1 , e2 in zip ( self . delete_status_ , x . delete_status_ ) : <EOL> if e1 != e2 : return <NUM_LIT:0> <EOL> return <NUM_LIT:1> <EOL> def IsInitialized ( self , debug_strs = None ) : <EOL> initialized = <NUM_LIT:1> <EOL> return initialized <EOL> def ByteSize ( self ) : <EOL> n = <NUM_LIT:0> <EOL> n += <NUM_LIT:1> * len ( self . delete_status_ ) <EOL> for i in xrange ( len ( self . delete_status_ ) ) : n += self . lengthVarInt64 ( self . delete_status_ [ i ] ) <EOL> return n + <NUM_LIT:0> <EOL> def Clear ( self ) : <EOL> self . clear_delete_status ( ) <EOL> def OutputUnchecked ( self , out ) : <EOL> for i in xrange ( len ( self . delete_status_ ) ) : <EOL> out . putVarInt32 ( <NUM_LIT:8> ) <EOL> out . putVarInt32 ( self . delete_status_ [ i ] ) <EOL> def TryMerge ( self , d ) : <EOL> while d . avail ( ) > <NUM_LIT:0> : <EOL> tt = d . getVarInt32 ( ) <EOL> if tt == <NUM_LIT:8> : <EOL> self . add_delete_status ( d . getVarInt32 ( ) ) <EOL> continue <EOL> if ( tt == <NUM_LIT:0> ) : raise ProtocolBuffer . ProtocolBufferDecodeError <EOL> d . skipData ( tt ) <EOL> def __str__ ( self , prefix = "<STR_LIT>" , printElemNumber = <NUM_LIT:0> ) : <EOL> res = "<STR_LIT>" <EOL> cnt = <NUM_LIT:0> <EOL> for e in self . delete_status_ : <EOL> elm = "<STR_LIT>" <EOL> if printElemNumber : elm = "<STR_LIT>" % cnt <EOL> res += prefix + ( "<STR_LIT>" % ( elm , self . DebugFormatInt32 ( e ) ) ) <EOL> cnt += <NUM_LIT:1> <EOL> return res <EOL> def _BuildTagLookupTable ( sparse , maxtag , default = None ) : <EOL> return tuple ( [ sparse . get ( i , default ) for i in xrange ( <NUM_LIT:0> , <NUM_LIT:1> + maxtag ) ] ) <EOL> kdelete_status = <NUM_LIT:1> <EOL> _TEXT = _BuildTagLookupTable ( { <EOL> <NUM_LIT:0> : "<STR_LIT>" , <EOL> <NUM_LIT:1> : "<STR_LIT>" , <EOL> } , <NUM_LIT:1> ) <EOL> _TYPES = _BuildTagLookupTable ( { <EOL> <NUM_LIT:0> : ProtocolBuffer . Encoder . NUMERIC , <EOL> <NUM_LIT:1> : ProtocolBuffer . Encoder . NUMERIC , <EOL> } , <NUM_LIT:1> , ProtocolBuffer . Encoder . MAX_TYPE ) <EOL> _STYLE = """<STR_LIT>""" <EOL> _STYLE_CONTENT_TYPE = """<STR_LIT>""" <EOL> class MemcacheIncrementRequest ( ProtocolBuffer . ProtocolMessage ) : <EOL> INCREMENT = <NUM_LIT:1> <EOL> DECREMENT = <NUM_LIT:2> <EOL> _Direction_NAMES = { <EOL> <NUM_LIT:1> : "<STR_LIT>" , <EOL> <NUM_LIT:2> : "<STR_LIT>" , <EOL> } <EOL> def Direction_Name ( cls , x ) : return cls . _Direction_NAMES . get ( x , "<STR_LIT>" ) <EOL> Direction_Name = classmethod ( Direction_Name ) <EOL> has_key_ = <NUM_LIT:0> <EOL> key_ = "<STR_LIT>" <EOL> has_name_space_ = <NUM_LIT:0> <EOL> name_space_ = "<STR_LIT>" <EOL> has_delta_ = <NUM_LIT:0> <EOL> delta_ = <NUM_LIT:1> <EOL> has_direction_ = <NUM_LIT:0> <EOL> direction_ = <NUM_LIT:1> <EOL> has_initial_value_ = <NUM_LIT:0> <EOL> initial_value_ = <NUM_LIT:0> <EOL> has_initial_flags_ = <NUM_LIT:0> <EOL> initial_flags_ = <NUM_LIT:0> <EOL> def __init__ ( self , contents = None ) : <EOL> if contents is not None : self . MergeFromString ( contents ) <EOL> def key ( self ) : return self . key_ <EOL> def set_key ( self , x ) : <EOL> self . has_key_ = <NUM_LIT:1> <EOL> self . key_ = x <EOL> def clear_key ( self ) : <EOL> if self . has_key_ : <EOL> self . has_key_ = <NUM_LIT:0> <EOL> self . key_ = "<STR_LIT>" <EOL> def has_key ( self ) : return self . has_key_ <EOL> def name_space ( self ) : return self . name_space_ <EOL> def set_name_space ( self , x ) : <EOL> self . has_name_space_ = <NUM_LIT:1> <EOL> self . name_space_ = x <EOL> def clear_name_space ( self ) : <EOL> if self . has_name_space_ : <EOL> self . has_name_space_ = <NUM_LIT:0> <EOL> self . name_space_ = "<STR_LIT>" <EOL> def has_name_space ( self ) : return self . has_name_space_ <EOL> def delta ( self ) : return self . delta_ <EOL> def set_delta ( self , x ) : <EOL> self . has_delta_ = <NUM_LIT:1> <EOL> self . delta_ = x <EOL> def clear_delta ( self ) : <EOL> if self . has_delta_ : <EOL> self . has_delta_ = <NUM_LIT:0> <EOL> self . delta_ = <NUM_LIT:1> <EOL> def has_delta ( self ) : return self . has_delta_ <EOL> def direction ( self ) : return self . direction_ <EOL> def set_direction ( self , x ) : <EOL> self . has_direction_ = <NUM_LIT:1> <EOL> self . direction_ = x <EOL> def clear_direction ( self ) : <EOL> if self . has_direction_ : <EOL> self . has_direction_ = <NUM_LIT:0> <EOL> self . direction_ = <NUM_LIT:1> <EOL> def has_direction ( self ) : return self . has_direction_ <EOL> def initial_value ( self ) : return self . initial_value_ <EOL> def set_initial_value ( self , x ) : <EOL> self . has_initial_value_ = <NUM_LIT:1> <EOL> self . initial_value_ = x <EOL> def clear_initial_value ( self ) : <EOL> if self . has_initial_value_ : <EOL> self . has_initial_value_ = <NUM_LIT:0> <EOL> self . initial_value_ = <NUM_LIT:0> <EOL> def has_initial_value ( self ) : return self . has_initial_value_ <EOL> def initial_flags ( self ) : return self . initial_flags_ <EOL> def set_initial_flags ( self , x ) : <EOL> self . has_initial_flags_ = <NUM_LIT:1> <EOL> self . initial_flags_ = x <EOL> def clear_initial_flags ( self ) : <EOL> if self . has_initial_flags_ : <EOL> self . has_initial_flags_ = <NUM_LIT:0> <EOL> self . initial_flags_ = <NUM_LIT:0> <EOL> def has_initial_flags ( self ) : return self . has_initial_flags_ <EOL> def MergeFrom ( self , x ) : <EOL> assert x is not self <EOL> if ( x . has_key ( ) ) : self . set_key ( x . key ( ) ) <EOL> if ( x . has_name_space ( ) ) : self . set_name_space ( x . name_space ( ) ) <EOL> if ( x . has_delta ( ) ) : self . set_delta ( x . delta ( ) ) <EOL> if ( x . has_direction ( ) ) : self . set_direction ( x . direction ( ) ) <EOL> if ( x . has_initial_value ( ) ) : self . set_initial_value ( x . initial_value ( ) ) <EOL> if ( x . has_initial_flags ( ) ) : self . set_initial_flags ( x . initial_flags ( ) ) <EOL> def Equals ( self , x ) : <EOL> if x is self : return <NUM_LIT:1> <EOL> if self . has_key_ != x . has_key_ : return <NUM_LIT:0> <EOL> if self . has_key_ and self . key_ != x . key_ : return <NUM_LIT:0> <EOL> if self . has_name_space_ != x . has_name_space_ : return <NUM_LIT:0> <EOL> if self . has_name_space_ and self . name_space_ != x . name_space_ : return <NUM_LIT:0> <EOL> if self . has_delta_ != x . has_delta_ : return <NUM_LIT:0> <EOL> if self . has_delta_ and self . delta_ != x . delta_ : return <NUM_LIT:0> <EOL> if self . has_direction_ != x . has_direction_ : return <NUM_LIT:0> <EOL> if self . has_direction_ and self . direction_ != x . direction_ : return <NUM_LIT:0> <EOL> if self . has_initial_value_ != x . has_initial_value_ : return <NUM_LIT:0> <EOL> if self . has_initial_value_ and self . initial_value_ != x . initial_value_ : return <NUM_LIT:0> <EOL> if self . has_initial_flags_ != x . has_initial_flags_ : return <NUM_LIT:0> <EOL> if self . has_initial_flags_ and self . initial_flags_ != x . initial_flags_ : return <NUM_LIT:0> <EOL> return <NUM_LIT:1> <EOL> def IsInitialized ( self , debug_strs = None ) : <EOL> initialized = <NUM_LIT:1> <EOL> if ( not self . has_key_ ) : <EOL> initialized = <NUM_LIT:0> <EOL> if debug_strs is not None : <EOL> debug_strs . append ( '<STR_LIT>' ) <EOL> return initialized <EOL> def ByteSize ( self ) : <EOL> n = <NUM_LIT:0> <EOL> n += self . lengthString ( len ( self . key_ ) ) <EOL> if ( self . has_name_space_ ) : n += <NUM_LIT:1> + self . lengthString ( len ( self . name_space_ ) ) <EOL> if ( self . has_delta_ ) : n += <NUM_LIT:1> + self . lengthVarInt64 ( self . delta_ ) <EOL> if ( self . has_direction_ ) : n += <NUM_LIT:1> + self . lengthVarInt64 ( self . direction_ ) <EOL> if ( self . has_initial_value_ ) : n += <NUM_LIT:1> + self . lengthVarInt64 ( self . initial_value_ ) <EOL> if ( self . has_initial_flags_ ) : n += <NUM_LIT:5> <EOL> return n + <NUM_LIT:1> <EOL> def Clear ( self ) : <EOL> self . clear_key ( ) <EOL> self . clear_name_space ( ) <EOL> self . clear_delta ( ) <EOL> self . clear_direction ( ) <EOL> self . clear_initial_value ( ) <EOL> self . clear_initial_flags ( ) <EOL> def OutputUnchecked ( self , out ) : <EOL> out . putVarInt32 ( <NUM_LIT:10> ) <EOL> out . putPrefixedString ( self . key_ ) <EOL> if ( self . has_delta_ ) : <EOL> out . putVarInt32 ( <NUM_LIT:16> ) <EOL> out . putVarUint64 ( self . delta_ ) <EOL> if ( self . has_direction_ ) : <EOL> out . putVarInt32 ( <NUM_LIT> ) <EOL> out . putVarInt32 ( self . direction_ ) <EOL> if ( self . has_name_space_ ) : <EOL> out . putVarInt32 ( <NUM_LIT> ) <EOL> out . putPrefixedString ( self . name_space_ ) <EOL> if ( self . has_initial_value_ ) : <EOL> out . putVarInt32 ( <NUM_LIT> ) <EOL> out . putVarUint64 ( self . initial_value_ ) <EOL> if ( self . has_initial_flags_ ) : <EOL> out . putVarInt32 ( <NUM_LIT> ) <EOL> out . put32 ( self . initial_flags_ ) <EOL> def TryMerge ( self , d ) : <EOL> while d . avail ( ) > <NUM_LIT:0> : <EOL> tt = d . getVarInt32 ( ) <EOL> if tt == <NUM_LIT:10> : <EOL> self . set_key ( d . getPrefixedString ( ) ) <EOL> continue <EOL> if tt == <NUM_LIT:16> : <EOL> self . set_delta ( d . getVarUint64 ( ) ) <EOL> continue <EOL> if tt == <NUM_LIT> : <EOL> self . set_direction ( d . getVarInt32 ( ) ) <EOL> continue <EOL> if tt == <NUM_LIT> : <EOL> self . set_name_space ( d . getPrefixedString ( ) ) <EOL> continue <EOL> if tt == <NUM_LIT> : <EOL> self . set_initial_value ( d . getVarUint64 ( ) ) <EOL> continue <EOL> if tt == <NUM_LIT> : <EOL> self . set_initial_flags ( d . get32 ( ) ) <EOL> continue <EOL> if ( tt == <NUM_LIT:0> ) : raise ProtocolBuffer . ProtocolBufferDecodeError <EOL> d . skipData ( tt ) <EOL> def __str__ ( self , prefix = "<STR_LIT>" , printElemNumber = <NUM_LIT:0> ) : <EOL> res = "<STR_LIT>" <EOL> if self . has_key_ : res += prefix + ( "<STR_LIT>" % self . DebugFormatString ( self . key_ ) ) <EOL> if self . has_name_space_ : res += prefix + ( "<STR_LIT>" % self . DebugFormatString ( self . name_space_ ) ) <EOL> if self . has_delta_ : res += prefix + ( "<STR_LIT>" % self . DebugFormatInt64 ( self . delta_ ) ) <EOL> if self . has_direction_ : res += prefix + ( "<STR_LIT>" % self . DebugFormatInt32 ( self . direction_ ) ) <EOL> if self . has_initial_value_ : res += prefix + ( "<STR_LIT>" % self . DebugFormatInt64 ( self . initial_value_ ) ) <EOL> if self . has_initial_flags_ : res += prefix + ( "<STR_LIT>" % self . DebugFormatFixed32 ( self . initial_flags_ ) ) <EOL> return res <EOL> def _BuildTagLookupTable ( sparse , maxtag , default = None ) : <EOL> return tuple ( [ sparse . get ( i , default ) for i in xrange ( <NUM_LIT:0> , <NUM_LIT:1> + maxtag ) ] ) <EOL> kkey = <NUM_LIT:1> <EOL> kname_space = <NUM_LIT:4> <EOL> kdelta = <NUM_LIT:2> <EOL> kdirection = <NUM_LIT:3> <EOL> kinitial_value = <NUM_LIT:5> <EOL> kinitial_flags = <NUM_LIT:6> <EOL> _TEXT = _BuildTagLookupTable ( { <EOL> <NUM_LIT:0> : "<STR_LIT>" , <EOL> <NUM_LIT:1> : "<STR_LIT:key>" , <EOL> <NUM_LIT:2> : "<STR_LIT>" , <EOL> <NUM_LIT:3> : "<STR_LIT>" , <EOL> <NUM_LIT:4> : "<STR_LIT>" , <EOL> <NUM_LIT:5> : "<STR_LIT>" , <EOL> <NUM_LIT:6> : "<STR_LIT>" , <EOL> } , <NUM_LIT:6> ) <EOL> _TYPES = _BuildTagLookupTable ( { <EOL> <NUM_LIT:0> : ProtocolBuffer . Encoder . NUMERIC , <EOL> <NUM_LIT:1> : ProtocolBuffer . Encoder . STRING , <EOL> <NUM_LIT:2> : ProtocolBuffer . Encoder . NUMERIC , <EOL> <NUM_LIT:3> : ProtocolBuffer . Encoder . NUMERIC , <EOL> <NUM_LIT:4> : ProtocolBuffer . Encoder . STRING , <EOL> <NUM_LIT:5> : ProtocolBuffer . Encoder . NUMERIC , <EOL> <NUM_LIT:6> : ProtocolBuffer . Encoder . FLOAT , <EOL> } , <NUM_LIT:6> , ProtocolBuffer . Encoder . MAX_TYPE ) <EOL> _STYLE = """<STR_LIT>""" <EOL> _STYLE_CONTENT_TYPE = """<STR_LIT>""" <EOL> class MemcacheIncrementResponse ( ProtocolBuffer . ProtocolMessage ) : <EOL> OK = <NUM_LIT:1> <EOL> NOT_CHANGED = <NUM_LIT:2> <EOL> ERROR = <NUM_LIT:3> <EOL> _IncrementStatusCode_NAMES = { <EOL> <NUM_LIT:1> : "<STR_LIT:OK>" , <EOL> <NUM_LIT:2> : "<STR_LIT>" , <EOL> <NUM_LIT:3> : "<STR_LIT>" , <EOL> } <EOL> def IncrementStatusCode_Name ( cls , x ) : return cls . _IncrementStatusCode_NAMES . get ( x , "<STR_LIT>" ) <EOL> IncrementStatusCode_Name = classmethod ( IncrementStatusCode_Name ) <EOL> has_new_value_ = <NUM_LIT:0> <EOL> new_value_ = <NUM_LIT:0> <EOL> has_increment_status_ = <NUM_LIT:0> <EOL> increment_status_ = <NUM_LIT:0> <EOL> def __init__ ( self , contents = None ) : <EOL> if contents is not None : self . MergeFromString ( contents ) <EOL> def new_value ( self ) : return self . new_value_ <EOL> def set_new_value ( self , x ) : <EOL> self . has_new_value_ = <NUM_LIT:1> <EOL> self . new_value_ = x <EOL> def clear_new_value ( self ) : <EOL> if self . has_new_value_ : <EOL> self . has_new_value_ = <NUM_LIT:0> <EOL> self . new_value_ = <NUM_LIT:0> <EOL> def has_new_value ( self ) : return self . has_new_value_ <EOL> def increment_status ( self ) : return self . increment_status_ <EOL> def set_increment_status ( self , x ) : <EOL> self . has_increment_status_ = <NUM_LIT:1> <EOL> self . increment_status_ = x <EOL> def clear_increment_status ( self ) : <EOL> if self . has_increment_status_ : <EOL> self . has_increment_status_ = <NUM_LIT:0> <EOL> self . increment_status_ = <NUM_LIT:0> <EOL> def has_increment_status ( self ) : return self . has_increment_status_ <EOL> def MergeFrom ( self , x ) : <EOL> assert x is not self <EOL> if ( x . has_new_value ( ) ) : self . set_new_value ( x . new_value ( ) ) <EOL> if ( x . has_increment_status ( ) ) : self . set_increment_status ( x . increment_status ( ) ) <EOL> def Equals ( self , x ) : <EOL> if x is self : return <NUM_LIT:1> <EOL> if self . has_new_value_ != x . has_new_value_ : return <NUM_LIT:0> <EOL> if self . has_new_value_ and self . new_value_ != x . new_value_ : return <NUM_LIT:0> <EOL> if self . has_increment_status_ != x . has_increment_status_ : return <NUM_LIT:0> <EOL> if self . has_increment_status_ and self . increment_status_ != x . increment_status_ : return <NUM_LIT:0> <EOL> return <NUM_LIT:1> <EOL> def IsInitialized ( self , debug_strs = None ) : <EOL> initialized = <NUM_LIT:1> <EOL> return initialized <EOL> def ByteSize ( self ) : <EOL> n = <NUM_LIT:0> <EOL> if ( self . has_new_value_ ) : n += <NUM_LIT:1> + self . lengthVarInt64 ( self . new_value_ ) <EOL> if ( self . has_increment_status_ ) : n += <NUM_LIT:1> + self . lengthVarInt64 ( self . increment_status_ ) <EOL> return n + <NUM_LIT:0> <EOL> def Clear ( self ) : <EOL> self . clear_new_value ( ) <EOL> self . clear_increment_status ( ) <EOL> def OutputUnchecked ( self , out ) : <EOL> if ( self . has_new_value_ ) : <EOL> out . putVarInt32 ( <NUM_LIT:8> ) <EOL> out . putVarUint64 ( self . new_value_ ) <EOL> if ( self . has_increment_status_ ) : <EOL> out . putVarInt32 ( <NUM_LIT:16> ) <EOL> out . putVarInt32 ( self . increment_status_ ) <EOL> def TryMerge ( self , d ) : <EOL> while d . avail ( ) > <NUM_LIT:0> : <EOL> tt = d . getVarInt32 ( ) <EOL> if tt == <NUM_LIT:8> : <EOL> self . set_new_value ( d . getVarUint64 ( ) ) <EOL> continue <EOL> if tt == <NUM_LIT:16> : <EOL> self . set_increment_status ( d . getVarInt32 ( ) ) <EOL> continue <EOL> if ( tt == <NUM_LIT:0> ) : raise ProtocolBuffer . ProtocolBufferDecodeError <EOL> d . skipData ( tt ) <EOL> def __str__ ( self , prefix = "<STR_LIT>" , printElemNumber = <NUM_LIT:0> ) : <EOL> res = "<STR_LIT>" <EOL> if self . has_new_value_ : res += prefix + ( "<STR_LIT>" % self . DebugFormatInt64 ( self . new_value_ ) ) <EOL> if self . has_increment_status_ : res += prefix + ( "<STR_LIT>" % self . DebugFormatInt32 ( self . increment_status_ ) ) <EOL> return res <EOL> def _BuildTagLookupTable ( sparse , maxtag , default = None ) : <EOL> return tuple ( [ sparse . get ( i , default ) for i in xrange ( <NUM_LIT:0> , <NUM_LIT:1> + maxtag ) ] ) <EOL> knew_value = <NUM_LIT:1> <EOL> kincrement_status = <NUM_LIT:2> <EOL> _TEXT = _BuildTagLookupTable ( { <EOL> <NUM_LIT:0> : "<STR_LIT>" , <EOL> <NUM_LIT:1> : "<STR_LIT>" , <EOL> <NUM_LIT:2> : "<STR_LIT>" , <EOL> } , <NUM_LIT:2> ) <EOL> _TYPES = _BuildTagLookupTable ( { <EOL> <NUM_LIT:0> : ProtocolBuffer . Encoder . NUMERIC , <EOL> <NUM_LIT:1> : ProtocolBuffer . Encoder . NUMERIC , <EOL> <NUM_LIT:2> : ProtocolBuffer . Encoder . NUMERIC , <EOL> } , <NUM_LIT:2> , ProtocolBuffer . Encoder . MAX_TYPE ) <EOL> _STYLE = """<STR_LIT>""" <EOL> _STYLE_CONTENT_TYPE = """<STR_LIT>""" <EOL> class MemcacheBatchIncrementRequest ( ProtocolBuffer . ProtocolMessage ) : <EOL> has_name_space_ = <NUM_LIT:0> <EOL> name_space_ = "<STR_LIT>" <EOL> def __init__ ( self , contents = None ) : <EOL> self . item_ = [ ] <EOL> if contents is not None : self . MergeFromString ( contents ) <EOL> def name_space ( self ) : return self . name_space_ <EOL> def set_name_space ( self , x ) : <EOL> self . has_name_space_ = <NUM_LIT:1> <EOL> self . name_space_ = x <EOL> def clear_name_space ( self ) : <EOL> if self . has_name_space_ : <EOL> self . has_name_space_ = <NUM_LIT:0> <EOL> self . name_space_ = "<STR_LIT>" <EOL> def has_name_space ( self ) : return self . has_name_space_ <EOL> def item_size ( self ) : return len ( self . item_ ) <EOL> def item_list ( self ) : return self . item_ <EOL> def item ( self , i ) : <EOL> return self . item_ [ i ] <EOL> def mutable_item ( self , i ) : <EOL> return self . item_ [ i ] <EOL> def add_item ( self ) : <EOL> x = MemcacheIncrementRequest ( ) <EOL> self . item_ . append ( x ) <EOL> return x <EOL> def clear_item ( self ) : <EOL> self . item_ = [ ] <EOL> def MergeFrom ( self , x ) : <EOL> assert x is not self <EOL> if ( x . has_name_space ( ) ) : self . set_name_space ( x . name_space ( ) ) <EOL> for i in xrange ( x . item_size ( ) ) : self . add_item ( ) . CopyFrom ( x . item ( i ) ) <EOL> def Equals ( self , x ) : <EOL> if x is self : return <NUM_LIT:1> <EOL> if self . has_name_space_ != x . has_name_space_ : return <NUM_LIT:0> <EOL> if self . has_name_space_ and self . name_space_ != x . name_space_ : return <NUM_LIT:0> <EOL> if len ( self . item_ ) != len ( x . item_ ) : return <NUM_LIT:0> <EOL> for e1 , e2 in zip ( self . item_ , x . item_ ) : <EOL> if e1 != e2 : return <NUM_LIT:0> <EOL> return <NUM_LIT:1> <EOL> def IsInitialized ( self , debug_strs = None ) : <EOL> initialized = <NUM_LIT:1> <EOL> for p in self . item_ : <EOL> if not p . IsInitialized ( debug_strs ) : initialized = <NUM_LIT:0> <EOL> return initialized <EOL> def ByteSize ( self ) : <EOL> n = <NUM_LIT:0> <EOL> if ( self . has_name_space_ ) : n += <NUM_LIT:1> + self . lengthString ( len ( self . name_space_ ) ) <EOL> n += <NUM_LIT:1> * len ( self . item_ ) <EOL> for i in xrange ( len ( self . item_ ) ) : n += self . lengthString ( self . item_ [ i ] . ByteSize ( ) ) <EOL> return n + <NUM_LIT:0> <EOL> def Clear ( self ) : <EOL> self . clear_name_space ( ) <EOL> self . clear_item ( ) <EOL> def OutputUnchecked ( self , out ) : <EOL> if ( self . has_name_space_ ) : <EOL> out . putVarInt32 ( <NUM_LIT:10> ) <EOL> out . putPrefixedString ( self . name_space_ ) <EOL> for i in xrange ( len ( self . item_ ) ) : <EOL> out . putVarInt32 ( <NUM_LIT> ) <EOL> out . putVarInt32 ( self . item_ [ i ] . ByteSize ( ) ) <EOL> self . item_ [ i ] . OutputUnchecked ( out ) <EOL> def TryMerge ( self , d ) : <EOL> while d . avail ( ) > <NUM_LIT:0> : <EOL> tt = d . getVarInt32 ( ) <EOL> if tt == <NUM_LIT:10> : <EOL> self . set_name_space ( d . getPrefixedString ( ) ) <EOL> continue <EOL> if tt == <NUM_LIT> : <EOL> length = d . getVarInt32 ( ) <EOL> tmp = ProtocolBuffer . Decoder ( d . buffer ( ) , d . pos ( ) , d . pos ( ) + length ) <EOL> d . skip ( length ) <EOL> self . add_item ( ) . TryMerge ( tmp ) <EOL> continue <EOL> if ( tt == <NUM_LIT:0> ) : raise ProtocolBuffer . ProtocolBufferDecodeError <EOL> d . skipData ( tt ) <EOL> def __str__ ( self , prefix = "<STR_LIT>" , printElemNumber = <NUM_LIT:0> ) : <EOL> res = "<STR_LIT>" <EOL> if self . has_name_space_ : res += prefix + ( "<STR_LIT>" % self . DebugFormatString ( self . name_space_ ) ) <EOL> cnt = <NUM_LIT:0> <EOL> for e in self . item_ : <EOL> elm = "<STR_LIT>" <EOL> if printElemNumber : elm = "<STR_LIT>" % cnt <EOL> res += prefix + ( "<STR_LIT>" % elm ) <EOL> res += e . __str__ ( prefix + "<STR_LIT:U+0020>" , printElemNumber ) <EOL> res += prefix + "<STR_LIT>" <EOL> cnt += <NUM_LIT:1> <EOL> return res <EOL> def _BuildTagLookupTable ( sparse , maxtag , default = None ) : <EOL> return tuple ( [ sparse . get ( i , default ) for i in xrange ( <NUM_LIT:0> , <NUM_LIT:1> + maxtag ) ] ) <EOL> kname_space = <NUM_LIT:1> <EOL> kitem = <NUM_LIT:2> <EOL> _TEXT = _BuildTagLookupTable ( { <EOL> <NUM_LIT:0> : "<STR_LIT>" , <EOL> <NUM_LIT:1> : "<STR_LIT>" , <EOL> <NUM_LIT:2> : "<STR_LIT>" , <EOL> } , <NUM_LIT:2> ) <EOL> _TYPES = _BuildTagLookupTable ( { <EOL> <NUM_LIT:0> : ProtocolBuffer . Encoder . NUMERIC , <EOL> <NUM_LIT:1> : ProtocolBuffer . Encoder . STRING , <EOL> <NUM_LIT:2> : ProtocolBuffer . Encoder . STRING , <EOL> } , <NUM_LIT:2> , ProtocolBuffer . Encoder . MAX_TYPE ) <EOL> _STYLE = """<STR_LIT>""" <EOL> _STYLE_CONTENT_TYPE = """<STR_LIT>""" <EOL> class MemcacheBatchIncrementResponse ( ProtocolBuffer . ProtocolMessage ) : <EOL> def __init__ ( self , contents = None ) : <EOL> self . item_ = [ ] <EOL> if contents is not None : self . MergeFromString ( contents ) <EOL> def item_size ( self ) : return len ( self . item_ ) <EOL> def item_list ( self ) : return self . item_ <EOL> def item ( self , i ) : <EOL> return self . item_ [ i ] <EOL> def mutable_item ( self , i ) : <EOL> return self . item_ [ i ] <EOL> def add_item ( self ) : <EOL> x = MemcacheIncrementResponse ( ) <EOL> self . item_ . append ( x ) <EOL> return x <EOL> def clear_item ( self ) : <EOL> self . item_ = [ ] <EOL> def MergeFrom ( self , x ) : <EOL> assert x is not self <EOL> for i in xrange ( x . item_size ( ) ) : self . add_item ( ) . CopyFrom ( x . item ( i ) ) <EOL> def Equals ( self , x ) : <EOL> if x is self : return <NUM_LIT:1> <EOL> if len ( self . item_ ) != len ( x . item_ ) : return <NUM_LIT:0> <EOL> for e1 , e2 in zip ( self . item_ , x . item_ ) : <EOL> if e1 != e2 : return <NUM_LIT:0> <EOL> return <NUM_LIT:1> <EOL> def IsInitialized ( self , debug_strs = None ) : <EOL> initialized = <NUM_LIT:1> <EOL> for p in self . item_ : <EOL> if not p . IsInitialized ( debug_strs ) : initialized = <NUM_LIT:0> <EOL> return initialized <EOL> def ByteSize ( self ) : <EOL> n = <NUM_LIT:0> <EOL> n += <NUM_LIT:1> * len ( self . item_ ) <EOL> for i in xrange ( len ( self . item_ ) ) : n += self . lengthString ( self . item_ [ i ] . ByteSize ( ) ) <EOL> return n + <NUM_LIT:0> <EOL> def Clear ( self ) : <EOL> self . clear_item ( ) <EOL> def OutputUnchecked ( self , out ) : <EOL> for i in xrange ( len ( self . item_ ) ) : <EOL> out . putVarInt32 ( <NUM_LIT:10> ) <EOL> out . putVarInt32 ( self . item_ [ i ] . ByteSize ( ) ) <EOL> self . item_ [ i ] . OutputUnchecked ( out ) <EOL> def TryMerge ( self , d ) : <EOL> while d . avail ( ) > <NUM_LIT:0> : <EOL> tt = d . getVarInt32 ( ) <EOL> if tt == <NUM_LIT:10> : <EOL> length = d . getVarInt32 ( ) <EOL> tmp = ProtocolBuffer . Decoder ( d . buffer ( ) , d . pos ( ) , d . pos ( ) + length ) <EOL> d . skip ( length ) <EOL> self . add_item ( ) . TryMerge ( tmp ) <EOL> continue <EOL> if ( tt == <NUM_LIT:0> ) : raise ProtocolBuffer . ProtocolBufferDecodeError <EOL> d . skipData ( tt ) <EOL> def __str__ ( self , prefix = "<STR_LIT>" , printElemNumber = <NUM_LIT:0> ) : <EOL> res = "<STR_LIT>" <EOL> cnt = <NUM_LIT:0> <EOL> for e in self . item_ : <EOL> elm = "<STR_LIT>" <EOL> if printElemNumber : elm = "<STR_LIT>" % cnt <EOL> res += prefix + ( "<STR_LIT>" % elm ) <EOL> res += e . __str__ ( prefix + "<STR_LIT:U+0020>" , printElemNumber ) <EOL> res += prefix + "<STR_LIT>" <EOL> cnt += <NUM_LIT:1> <EOL> return res <EOL> def _BuildTagLookupTable ( sparse , maxtag , default = None ) : <EOL> return tuple ( [ sparse . get ( i , default ) for i in xrange ( <NUM_LIT:0> , <NUM_LIT:1> + maxtag ) ] ) <EOL> kitem = <NUM_LIT:1> <EOL> _TEXT = _BuildTagLookupTable ( { <EOL> <NUM_LIT:0> : "<STR_LIT>" , <EOL> <NUM_LIT:1> : "<STR_LIT>" , <EOL> } , <NUM_LIT:1> ) <EOL> _TYPES = _BuildTagLookupTable ( { <EOL> <NUM_LIT:0> : ProtocolBuffer . Encoder . NUMERIC , <EOL> <NUM_LIT:1> : ProtocolBuffer . Encoder . STRING , <EOL> } , <NUM_LIT:1> , ProtocolBuffer . Encoder . MAX_TYPE ) <EOL> _STYLE = """<STR_LIT>""" <EOL> _STYLE_CONTENT_TYPE = """<STR_LIT>""" <EOL> class MemcacheFlushRequest ( ProtocolBuffer . ProtocolMessage ) : <EOL> def __init__ ( self , contents = None ) : <EOL> pass <EOL> if contents is not None : self . MergeFromString ( contents ) <EOL> def MergeFrom ( self , x ) : <EOL> assert x is not self <EOL> def Equals ( self , x ) : <EOL> if x is self : return <NUM_LIT:1> <EOL> return <NUM_LIT:1> <EOL> def IsInitialized ( self , debug_strs = None ) : <EOL> initialized = <NUM_LIT:1> <EOL> return initialized <EOL> def ByteSize ( self ) : <EOL> n = <NUM_LIT:0> <EOL> return n + <NUM_LIT:0> <EOL> def Clear ( self ) : <EOL> pass <EOL> def OutputUnchecked ( self , out ) : <EOL> pass <EOL> def TryMerge ( self , d ) : <EOL> while d . avail ( ) > <NUM_LIT:0> : <EOL> tt = d . getVarInt32 ( ) <EOL> if ( tt == <NUM_LIT:0> ) : raise ProtocolBuffer . ProtocolBufferDecodeError <EOL> d . skipData ( tt ) <EOL> def __str__ ( self , prefix = "<STR_LIT>" , printElemNumber = <NUM_LIT:0> ) : <EOL> res = "<STR_LIT>" <EOL> return res <EOL> def _BuildTagLookupTable ( sparse , maxtag , default = None ) : <EOL> return tuple ( [ sparse . get ( i , default ) for i in xrange ( <NUM_LIT:0> , <NUM_LIT:1> + maxtag ) ] ) <EOL> _TEXT = _BuildTagLookupTable ( { <EOL> <NUM_LIT:0> : "<STR_LIT>" , <EOL> } , <NUM_LIT:0> ) <EOL> _TYPES = _BuildTagLookupTable ( { <EOL> <NUM_LIT:0> : ProtocolBuffer . Encoder . NUMERIC , <EOL> } , <NUM_LIT:0> , ProtocolBuffer . Encoder . MAX_TYPE ) <EOL> _STYLE = """<STR_LIT>""" <EOL> _STYLE_CONTENT_TYPE = """<STR_LIT>""" <EOL> class MemcacheFlushResponse ( ProtocolBuffer . ProtocolMessage ) : <EOL> def __init__ ( self , contents = None ) : <EOL> pass <EOL> if contents is not None : self . MergeFromString ( contents ) <EOL> def MergeFrom ( self , x ) : <EOL> assert x is not self <EOL> def Equals ( self , x ) : <EOL> if x is self : return <NUM_LIT:1> <EOL> return <NUM_LIT:1> <EOL> def IsInitialized ( self , debug_strs = None ) : <EOL> initialized = <NUM_LIT:1> <EOL> return initialized <EOL> def ByteSize ( self ) : <EOL> n = <NUM_LIT:0> <EOL> return n + <NUM_LIT:0> <EOL> def Clear ( self ) : <EOL> pass <EOL> def OutputUnchecked ( self , out ) : <EOL> pass <EOL> def TryMerge ( self , d ) : <EOL> while d . avail ( ) > <NUM_LIT:0> : <EOL> tt = d . getVarInt32 ( ) <EOL> if ( tt == <NUM_LIT:0> ) : raise ProtocolBuffer . ProtocolBufferDecodeError <EOL> d . skipData ( tt ) <EOL> def __str__ ( self , prefix = "<STR_LIT>" , printElemNumber = <NUM_LIT:0> ) : <EOL> res = "<STR_LIT>" <EOL> return res <EOL> def _BuildTagLookupTable ( sparse , maxtag , default = None ) : <EOL> return tuple ( [ sparse . get ( i , default ) for i in xrange ( <NUM_LIT:0> , <NUM_LIT:1> + maxtag ) ] ) <EOL> _TEXT = _BuildTagLookupTable ( { <EOL> <NUM_LIT:0> : "<STR_LIT>" , <EOL> } , <NUM_LIT:0> ) <EOL> _TYPES = _BuildTagLookupTable ( { <EOL> <NUM_LIT:0> : ProtocolBuffer . Encoder . NUMERIC , <EOL> } , <NUM_LIT:0> , ProtocolBuffer . Encoder . MAX_TYPE ) <EOL> _STYLE = """<STR_LIT>""" <EOL> _STYLE_CONTENT_TYPE = """<STR_LIT>""" <EOL> class MemcacheStatsRequest ( ProtocolBuffer . ProtocolMessage ) : <EOL> def __init__ ( self , contents = None ) : <EOL> pass <EOL> if contents is not None : self . MergeFromString ( contents ) <EOL> def MergeFrom ( self , x ) : <EOL> assert x is not self <EOL> def Equals ( self , x ) : <EOL> if x is self : return <NUM_LIT:1> <EOL> return <NUM_LIT:1> <EOL> def IsInitialized ( self , debug_strs = None ) : <EOL> initialized = <NUM_LIT:1> <EOL> return initialized <EOL> def ByteSize ( self ) : <EOL> n = <NUM_LIT:0> <EOL> return n + <NUM_LIT:0> <EOL> def Clear ( self ) : <EOL> pass <EOL> def OutputUnchecked ( self , out ) : <EOL> pass <EOL> def TryMerge ( self , d ) : <EOL> while d . avail ( ) > <NUM_LIT:0> : <EOL> tt = d . getVarInt32 ( ) <EOL> if ( tt == <NUM_LIT:0> ) : raise ProtocolBuffer . ProtocolBufferDecodeError <EOL> d . skipData ( tt ) <EOL> def __str__ ( self , prefix = "<STR_LIT>" , printElemNumber = <NUM_LIT:0> ) : <EOL> res = "<STR_LIT>" <EOL> return res <EOL> def _BuildTagLookupTable ( sparse , maxtag , default = None ) : <EOL> return tuple ( [ sparse . get ( i , default ) for i in xrange ( <NUM_LIT:0> , <NUM_LIT:1> + maxtag ) ] ) <EOL> _TEXT = _BuildTagLookupTable ( { <EOL> <NUM_LIT:0> : "<STR_LIT>" , <EOL> } , <NUM_LIT:0> ) <EOL> _TYPES = _BuildTagLookupTable ( { <EOL> <NUM_LIT:0> : ProtocolBuffer . Encoder . NUMERIC , <EOL> } , <NUM_LIT:0> , ProtocolBuffer . Encoder . MAX_TYPE ) <EOL> _STYLE = """<STR_LIT>""" <EOL> _STYLE_CONTENT_TYPE = """<STR_LIT>""" <EOL> class MergedNamespaceStats ( ProtocolBuffer . ProtocolMessage ) : <EOL> has_hits_ = <NUM_LIT:0> <EOL> hits_ = <NUM_LIT:0> <EOL> has_misses_ = <NUM_LIT:0> <EOL> misses_ = <NUM_LIT:0> <EOL> has_byte_hits_ = <NUM_LIT:0> <EOL> byte_hits_ = <NUM_LIT:0> <EOL> has_items_ = <NUM_LIT:0> <EOL> items_ = <NUM_LIT:0> <EOL> has_bytes_ = <NUM_LIT:0> <EOL> bytes_ = <NUM_LIT:0> <EOL> has_oldest_item_age_ = <NUM_LIT:0> <EOL> oldest_item_age_ = <NUM_LIT:0> <EOL> def __init__ ( self , contents = None ) : <EOL> if contents is not None : self . MergeFromString ( contents ) <EOL> def hits ( self ) : return self . hits_ <EOL> def set_hits ( self , x ) : <EOL> self . has_hits_ = <NUM_LIT:1> <EOL> self . hits_ = x <EOL> def clear_hits ( self ) : <EOL> if self . has_hits_ : <EOL> self . has_hits_ = <NUM_LIT:0> <EOL> self . hits_ = <NUM_LIT:0> <EOL> def has_hits ( self ) : return self . has_hits_ <EOL> def misses ( self ) : return self . misses_ <EOL> def set_misses ( self , x ) : <EOL> self . has_misses_ = <NUM_LIT:1> <EOL> self . misses_ = x <EOL> def clear_misses ( self ) : <EOL> if self . has_misses_ : <EOL> self . has_misses_ = <NUM_LIT:0> <EOL> self . misses_ = <NUM_LIT:0> <EOL> def has_misses ( self ) : return self . has_misses_ <EOL> def byte_hits ( self ) : return self . byte_hits_ <EOL> def set_byte_hits ( self , x ) : <EOL> self . has_byte_hits_ = <NUM_LIT:1> <EOL> self . byte_hits_ = x <EOL> def clear_byte_hits ( self ) : <EOL> if self . has_byte_hits_ : <EOL> self . has_byte_hits_ = <NUM_LIT:0> <EOL> self . byte_hits_ = <NUM_LIT:0> <EOL> def has_byte_hits ( self ) : return self . has_byte_hits_ <EOL> def items ( self ) : return self . items_ <EOL> def set_items ( self , x ) : <EOL> self . has_items_ = <NUM_LIT:1> <EOL> self . items_ = x <EOL> def clear_items ( self ) : <EOL> if self . has_items_ : <EOL> self . has_items_ = <NUM_LIT:0> <EOL> self . items_ = <NUM_LIT:0> <EOL> def has_items ( self ) : return self . has_items_ <EOL> def bytes ( self ) : return self . bytes_ <EOL> def set_bytes ( self , x ) : <EOL> self . has_bytes_ = <NUM_LIT:1> <EOL> self . bytes_ = x <EOL> def clear_bytes ( self ) : <EOL> if self . has_bytes_ : <EOL> self . has_bytes_ = <NUM_LIT:0> <EOL> self . bytes_ = <NUM_LIT:0> <EOL> def has_bytes ( self ) : return self . has_bytes_ <EOL> def oldest_item_age ( self ) : return self . oldest_item_age_ <EOL> def set_oldest_item_age ( self , x ) : <EOL> self . has_oldest_item_age_ = <NUM_LIT:1> <EOL> self . oldest_item_age_ = x <EOL> def clear_oldest_item_age ( self ) : <EOL> if self . has_oldest_item_age_ : <EOL> self . has_oldest_item_age_ = <NUM_LIT:0> <EOL> self . oldest_item_age_ = <NUM_LIT:0> <EOL> def has_oldest_item_age ( self ) : return self . has_oldest_item_age_ <EOL> def MergeFrom ( self , x ) : <EOL> assert x is not self <EOL> if ( x . has_hits ( ) ) : self . set_hits ( x . hits ( ) ) <EOL> if ( x . has_misses ( ) ) : self . set_misses ( x . misses ( ) ) <EOL> if ( x . has_byte_hits ( ) ) : self . set_byte_hits ( x . byte_hits ( ) ) <EOL> if ( x . has_items ( ) ) : self . set_items ( x . items ( ) ) <EOL> if ( x . has_bytes ( ) ) : self . set_bytes ( x . bytes ( ) ) <EOL> if ( x . has_oldest_item_age ( ) ) : self . set_oldest_item_age ( x . oldest_item_age ( ) ) <EOL> def Equals ( self , x ) : <EOL> if x is self : return <NUM_LIT:1> <EOL> if self . has_hits_ != x . has_hits_ : return <NUM_LIT:0> <EOL> if self . has_hits_ and self . hits_ != x . hits_ : return <NUM_LIT:0> <EOL> if self . has_misses_ != x . has_misses_ : return <NUM_LIT:0> <EOL> if self . has_misses_ and self . misses_ != x . misses_ : return <NUM_LIT:0> <EOL> if self . has_byte_hits_ != x . has_byte_hits_ : return <NUM_LIT:0> <EOL> if self . has_byte_hits_ and self . byte_hits_ != x . byte_hits_ : return <NUM_LIT:0> <EOL> if self . has_items_ != x . has_items_ : return <NUM_LIT:0> <EOL> if self . has_items_ and self . items_ != x . items_ : return <NUM_LIT:0> <EOL> if self . has_bytes_ != x . has_bytes_ : return <NUM_LIT:0> <EOL> if self . has_bytes_ and self . bytes_ != x . bytes_ : return <NUM_LIT:0> <EOL> if self . has_oldest_item_age_ != x . has_oldest_item_age_ : return <NUM_LIT:0> <EOL> if self . has_oldest_item_age_ and self . oldest_item_age_ != x . oldest_item_age_ : return <NUM_LIT:0> <EOL> return <NUM_LIT:1> <EOL> def IsInitialized ( self , debug_strs = None ) : <EOL> initialized = <NUM_LIT:1> <EOL> if ( not self . has_hits_ ) : <EOL> initialized = <NUM_LIT:0> <EOL> if debug_strs is not None : <EOL> debug_strs . append ( '<STR_LIT>' ) <EOL> if ( not self . has_misses_ ) : <EOL> initialized = <NUM_LIT:0> <EOL> if debug_strs is not None : <EOL> debug_strs . append ( '<STR_LIT>' ) <EOL> if ( not self . has_byte_hits_ ) : <EOL> initialized = <NUM_LIT:0> <EOL> if debug_strs is not None : <EOL> debug_strs . append ( '<STR_LIT>' ) <EOL> if ( not self . has_items_ ) : <EOL> initialized = <NUM_LIT:0> <EOL> if debug_strs is not None : <EOL> debug_strs . append ( '<STR_LIT>' ) <EOL> if ( not self . has_bytes_ ) : <EOL> initialized = <NUM_LIT:0> <EOL> if debug_strs is not None : <EOL> debug_strs . append ( '<STR_LIT>' ) <EOL> if ( not self . has_oldest_item_age_ ) : <EOL> initialized = <NUM_LIT:0> <EOL> if debug_strs is not None : <EOL> debug_strs . append ( '<STR_LIT>' ) <EOL> return initialized <EOL> def ByteSize ( self ) : <EOL> n = <NUM_LIT:0> <EOL> n += self . lengthVarInt64 ( self . hits_ ) <EOL> n += self . lengthVarInt64 ( self . misses_ ) <EOL> n += self . lengthVarInt64 ( self . byte_hits_ ) <EOL> n += self . lengthVarInt64 ( self . items_ ) <EOL> n += self . lengthVarInt64 ( self . bytes_ ) <EOL> return n + <NUM_LIT:10> <EOL> def Clear ( self ) : <EOL> self . clear_hits ( ) <EOL> self . clear_misses ( ) <EOL> self . clear_byte_hits ( ) <EOL> self . clear_items ( ) <EOL> self . clear_bytes ( ) <EOL> self . clear_oldest_item_age ( ) <EOL> def OutputUnchecked ( self , out ) : <EOL> out . putVarInt32 ( <NUM_LIT:8> ) <EOL> out . putVarUint64 ( self . hits_ ) <EOL> out . putVarInt32 ( <NUM_LIT:16> ) <EOL> out . putVarUint64 ( self . misses_ ) <EOL> out . putVarInt32 ( <NUM_LIT> ) <EOL> out . putVarUint64 ( self . byte_hits_ ) <EOL> out . putVarInt32 ( <NUM_LIT:32> ) <EOL> out . putVarUint64 ( self . items_ ) <EOL> out . putVarInt32 ( <NUM_LIT> ) <EOL> out . putVarUint64 ( self . bytes_ ) <EOL> out . putVarInt32 ( <NUM_LIT> ) <EOL> out . put32 ( self . oldest_item_age_ ) <EOL> def TryMerge ( self , d ) : <EOL> while d . avail ( ) > <NUM_LIT:0> : <EOL> tt = d . getVarInt32 ( ) <EOL> if tt == <NUM_LIT:8> : <EOL> self . set_hits ( d . getVarUint64 ( ) ) <EOL> continue <EOL> if tt == <NUM_LIT:16> : <EOL> self . set_misses ( d . getVarUint64 ( ) ) <EOL> continue <EOL> if tt == <NUM_LIT> : <EOL> self . set_byte_hits ( d . getVarUint64 ( ) ) <EOL> continue <EOL> if tt == <NUM_LIT:32> : <EOL> self . set_items ( d . getVarUint64 ( ) ) <EOL> continue <EOL> if tt == <NUM_LIT> : <EOL> self . set_bytes ( d . getVarUint64 ( ) ) <EOL> continue <EOL> if tt == <NUM_LIT> : <EOL> self . set_oldest_item_age ( d . get32 ( ) ) <EOL> continue <EOL> if ( tt == <NUM_LIT:0> ) : raise ProtocolBuffer . ProtocolBufferDecodeError <EOL> d . skipData ( tt ) <EOL> def __str__ ( self , prefix = "<STR_LIT>" , printElemNumber = <NUM_LIT:0> ) : <EOL> res = "<STR_LIT>" <EOL> if self . has_hits_ : res += prefix + ( "<STR_LIT>" % self . DebugFormatInt64 ( self . hits_ ) ) <EOL> if self . has_misses_ : res += prefix + ( "<STR_LIT>" % self . DebugFormatInt64 ( self . misses_ ) ) <EOL> if self . has_byte_hits_ : res += prefix + ( "<STR_LIT>" % self . DebugFormatInt64 ( self . byte_hits_ ) ) <EOL> if self . has_items_ : res += prefix + ( "<STR_LIT>" % self . DebugFormatInt64 ( self . items_ ) ) <EOL> if self . has_bytes_ : res += prefix + ( "<STR_LIT>" % self . DebugFormatInt64 ( self . bytes_ ) ) <EOL> if self . has_oldest_item_age_ : res += prefix + ( "<STR_LIT>" % self . DebugFormatFixed32 ( self . oldest_item_age_ ) ) <EOL> return res <EOL> def _BuildTagLookupTable ( sparse , maxtag , default = None ) : <EOL> return tuple ( [ sparse . get ( i , default ) for i in xrange ( <NUM_LIT:0> , <NUM_LIT:1> + maxtag ) ] ) <EOL> khits = <NUM_LIT:1> <EOL> kmisses = <NUM_LIT:2> <EOL> kbyte_hits = <NUM_LIT:3> <EOL> kitems = <NUM_LIT:4> <EOL> kbytes = <NUM_LIT:5> <EOL> koldest_item_age = <NUM_LIT:6> <EOL> _TEXT = _BuildTagLookupTable ( { <EOL> <NUM_LIT:0> : "<STR_LIT>" , <EOL> <NUM_LIT:1> : "<STR_LIT>" , <EOL> <NUM_LIT:2> : "<STR_LIT>" , <EOL> <NUM_LIT:3> : "<STR_LIT>" , <EOL> <NUM_LIT:4> : "<STR_LIT>" , <EOL> <NUM_LIT:5> : "<STR_LIT>" , <EOL> <NUM_LIT:6> : "<STR_LIT>" , <EOL> } , <NUM_LIT:6> ) <EOL> _TYPES = _BuildTagLookupTable ( { <EOL> <NUM_LIT:0> : ProtocolBuffer . Encoder . NUMERIC , <EOL> <NUM_LIT:1> : ProtocolBuffer . Encoder . NUMERIC , <EOL> <NUM_LIT:2> : ProtocolBuffer . Encoder . NUMERIC , <EOL> <NUM_LIT:3> : ProtocolBuffer . Encoder . NUMERIC , <EOL> <NUM_LIT:4> : ProtocolBuffer . Encoder . NUMERIC , <EOL> <NUM_LIT:5> : ProtocolBuffer . Encoder . NUMERIC , <EOL> <NUM_LIT:6> : ProtocolBuffer . Encoder . FLOAT , <EOL> } , <NUM_LIT:6> , ProtocolBuffer . Encoder . MAX_TYPE ) <EOL> _STYLE = """<STR_LIT>""" <EOL> _STYLE_CONTENT_TYPE = """<STR_LIT>""" <EOL> class MemcacheStatsResponse ( ProtocolBuffer . ProtocolMessage ) : <EOL> has_stats_ = <NUM_LIT:0> <EOL> stats_ = None <EOL> def __init__ ( self , contents = None ) : <EOL> self . lazy_init_lock_ = thread . allocate_lock ( ) <EOL> if contents is not None : self . MergeFromString ( contents ) <EOL> def stats ( self ) : <EOL> if self . stats_ is None : <EOL> self . lazy_init_lock_ . acquire ( ) <EOL> try : <EOL> if self . stats_ is None : self . stats_ = MergedNamespaceStats ( ) <EOL> finally : <EOL> self . lazy_init_lock_ . release ( ) <EOL> return self . stats_ <EOL> def mutable_stats ( self ) : self . has_stats_ = <NUM_LIT:1> ; return self . stats ( ) <EOL> def clear_stats ( self ) : <EOL> if self . has_stats_ : <EOL> self . has_stats_ = <NUM_LIT:0> ; <EOL> if self . stats_ is not None : self . stats_ . Clear ( ) <EOL> def has_stats ( self ) : return self . has_stats_ <EOL> def MergeFrom ( self , x ) : <EOL> assert x is not self <EOL> if ( x . has_stats ( ) ) : self . mutable_stats ( ) . MergeFrom ( x . stats ( ) ) <EOL> def Equals ( self , x ) : <EOL> if x is self : return <NUM_LIT:1> <EOL> if self . has_stats_ != x . has_stats_ : return <NUM_LIT:0> <EOL> if self . has_stats_ and self . stats_ != x . stats_ : return <NUM_LIT:0> <EOL> return <NUM_LIT:1> <EOL> def IsInitialized ( self , debug_strs = None ) : <EOL> initialized = <NUM_LIT:1> <EOL> if ( self . has_stats_ and not self . stats_ . IsInitialized ( debug_strs ) ) : initialized = <NUM_LIT:0> <EOL> return initialized <EOL> def ByteSize ( self ) : <EOL> n = <NUM_LIT:0> <EOL> if ( self . has_stats_ ) : n += <NUM_LIT:1> + self . lengthString ( self . stats_ . ByteSize ( ) ) <EOL> return n + <NUM_LIT:0> <EOL> def Clear ( self ) : <EOL> self . clear_stats ( ) <EOL> def OutputUnchecked ( self , out ) : <EOL> if ( self . has_stats_ ) : <EOL> out . putVarInt32 ( <NUM_LIT:10> ) <EOL> out . putVarInt32 ( self . stats_ . ByteSize ( ) ) <EOL> self . stats_ . OutputUnchecked ( out ) <EOL> def TryMerge ( self , d ) : <EOL> while d . avail ( ) > <NUM_LIT:0> : <EOL> tt = d . getVarInt32 ( ) <EOL> if tt == <NUM_LIT:10> : <EOL> length = d . getVarInt32 ( ) <EOL> tmp = ProtocolBuffer . Decoder ( d . buffer ( ) , d . pos ( ) , d . pos ( ) + length ) <EOL> d . skip ( length ) <EOL> self . mutable_stats ( ) . TryMerge ( tmp ) <EOL> continue <EOL> if ( tt == <NUM_LIT:0> ) : raise ProtocolBuffer . ProtocolBufferDecodeError <EOL> d . skipData ( tt ) <EOL> def __str__ ( self , prefix = "<STR_LIT>" , printElemNumber = <NUM_LIT:0> ) : <EOL> res = "<STR_LIT>" <EOL> if self . has_stats_ : <EOL> res += prefix + "<STR_LIT>" <EOL> res += self . stats_ . __str__ ( prefix + "<STR_LIT:U+0020>" , printElemNumber ) <EOL> res += prefix + "<STR_LIT>" <EOL> return res <EOL> def _BuildTagLookupTable ( sparse , maxtag , default = None ) : <EOL> return tuple ( [ sparse . get ( i , default ) for i in xrange ( <NUM_LIT:0> , <NUM_LIT:1> + maxtag ) ] ) <EOL> kstats = <NUM_LIT:1> <EOL> _TEXT = _BuildTagLookupTable ( { <EOL> <NUM_LIT:0> : "<STR_LIT>" , <EOL> <NUM_LIT:1> : "<STR_LIT>" , <EOL> } , <NUM_LIT:1> ) <EOL> _TYPES = _BuildTagLookupTable ( { <EOL> <NUM_LIT:0> : ProtocolBuffer . Encoder . NUMERIC , <EOL> <NUM_LIT:1> : ProtocolBuffer . Encoder . STRING , <EOL> } , <NUM_LIT:1> , ProtocolBuffer . Encoder . MAX_TYPE ) <EOL> _STYLE = """<STR_LIT>""" <EOL> _STYLE_CONTENT_TYPE = """<STR_LIT>""" <EOL> class MemcacheGrabTailRequest ( ProtocolBuffer . ProtocolMessage ) : <EOL> has_item_count_ = <NUM_LIT:0> <EOL> item_count_ = <NUM_LIT:0> <EOL> has_name_space_ = <NUM_LIT:0> <EOL> name_space_ = "<STR_LIT>" <EOL> def __init__ ( self , contents = None ) : <EOL> if contents is not None : self . MergeFromString ( contents ) <EOL> def item_count ( self ) : return self . item_count_ <EOL> def set_item_count ( self , x ) : <EOL> self . has_item_count_ = <NUM_LIT:1> <EOL> self . item_count_ = x <EOL> def clear_item_count ( self ) : <EOL> if self . has_item_count_ : <EOL> self . has_item_count_ = <NUM_LIT:0> <EOL> self . item_count_ = <NUM_LIT:0> <EOL> def has_item_count ( self ) : return self . has_item_count_ <EOL> def name_space ( self ) : return self . name_space_ <EOL> def set_name_space ( self , x ) : <EOL> self . has_name_space_ = <NUM_LIT:1> <EOL> self . name_space_ = x <EOL> def clear_name_space ( self ) : <EOL> if self . has_name_space_ : <EOL> self . has_name_space_ = <NUM_LIT:0> <EOL> self . name_space_ = "<STR_LIT>" <EOL> def has_name_space ( self ) : return self . has_name_space_ <EOL> def MergeFrom ( self , x ) : <EOL> assert x is not self <EOL> if ( x . has_item_count ( ) ) : self . set_item_count ( x . item_count ( ) ) <EOL> if ( x . has_name_space ( ) ) : self . set_name_space ( x . name_space ( ) ) <EOL> def Equals ( self , x ) : <EOL> if x is self : return <NUM_LIT:1> <EOL> if self . has_item_count_ != x . has_item_count_ : return <NUM_LIT:0> <EOL> if self . has_item_count_ and self . item_count_ != x . item_count_ : return <NUM_LIT:0> <EOL> if self . has_name_space_ != x . has_name_space_ : return <NUM_LIT:0> <EOL> if self . has_name_space_ and self . name_space_ != x . name_space_ : return <NUM_LIT:0> <EOL> return <NUM_LIT:1> <EOL> def IsInitialized ( self , debug_strs = None ) : <EOL> initialized = <NUM_LIT:1> <EOL> if ( not self . has_item_count_ ) : <EOL> initialized = <NUM_LIT:0> <EOL> if debug_strs is not None : <EOL> debug_strs . append ( '<STR_LIT>' ) <EOL> return initialized <EOL> def ByteSize ( self ) : <EOL> n = <NUM_LIT:0> <EOL> n += self . lengthVarInt64 ( self . item_count_ ) <EOL> if ( self . has_name_space_ ) : n += <NUM_LIT:1> + self . lengthString ( len ( self . name_space_ ) ) <EOL> return n + <NUM_LIT:1> <EOL> def Clear ( self ) : <EOL> self . clear_item_count ( ) <EOL> self . clear_name_space ( ) <EOL> def OutputUnchecked ( self , out ) : <EOL> out . putVarInt32 ( <NUM_LIT:8> ) <EOL> out . putVarInt32 ( self . item_count_ ) <EOL> if ( self . has_name_space_ ) : <EOL> out . putVarInt32 ( <NUM_LIT> ) <EOL> out . putPrefixedString ( self . name_space_ ) <EOL> def TryMerge ( self , d ) : <EOL> while d . avail ( ) > <NUM_LIT:0> : <EOL> tt = d . getVarInt32 ( ) <EOL> if tt == <NUM_LIT:8> : <EOL> self . set_item_count ( d . getVarInt32 ( ) ) <EOL> continue <EOL> if tt == <NUM_LIT> : <EOL> self . set_name_space ( d . getPrefixedString ( ) ) <EOL> continue <EOL> if ( tt == <NUM_LIT:0> ) : raise ProtocolBuffer . ProtocolBufferDecodeError <EOL> d . skipData ( tt ) <EOL> def __str__ ( self , prefix = "<STR_LIT>" , printElemNumber = <NUM_LIT:0> ) : <EOL> res = "<STR_LIT>" <EOL> if self . has_item_count_ : res += prefix + ( "<STR_LIT>" % self . DebugFormatInt32 ( self . item_count_ ) ) <EOL> if self . has_name_space_ : res += prefix + ( "<STR_LIT>" % self . DebugFormatString ( self . name_space_ ) ) <EOL> return res <EOL> def _BuildTagLookupTable ( sparse , maxtag , default = None ) : <EOL> return tuple ( [ sparse . get ( i , default ) for i in xrange ( <NUM_LIT:0> , <NUM_LIT:1> + maxtag ) ] ) <EOL> kitem_count = <NUM_LIT:1> <EOL> kname_space = <NUM_LIT:2> <EOL> _TEXT = _BuildTagLookupTable ( { <EOL> <NUM_LIT:0> : "<STR_LIT>" , <EOL> <NUM_LIT:1> : "<STR_LIT>" , <EOL> <NUM_LIT:2> : "<STR_LIT>" , <EOL> } , <NUM_LIT:2> ) <EOL> _TYPES = _BuildTagLookupTable ( { <EOL> <NUM_LIT:0> : ProtocolBuffer . Encoder . NUMERIC , <EOL> <NUM_LIT:1> : ProtocolBuffer . Encoder . NUMERIC , <EOL> <NUM_LIT:2> : ProtocolBuffer . Encoder . STRING , <EOL> } , <NUM_LIT:2> , ProtocolBuffer . Encoder . MAX_TYPE ) <EOL> _STYLE = """<STR_LIT>""" <EOL> _STYLE_CONTENT_TYPE = """<STR_LIT>""" <EOL> class MemcacheGrabTailResponse_Item ( ProtocolBuffer . ProtocolMessage ) : <EOL> has_value_ = <NUM_LIT:0> <EOL> value_ = "<STR_LIT>" <EOL> has_flags_ = <NUM_LIT:0> <EOL> flags_ = <NUM_LIT:0> <EOL> def __init__ ( self , contents = None ) : <EOL> if contents is not None : self . MergeFromString ( contents ) <EOL> def value ( self ) : return self . value_ <EOL> def set_value ( self , x ) : <EOL> self . has_value_ = <NUM_LIT:1> <EOL> self . value_ = x <EOL> def clear_value ( self ) : <EOL> if self . has_value_ : <EOL> self . has_value_ = <NUM_LIT:0> <EOL> self . value_ = "<STR_LIT>" <EOL> def has_value ( self ) : return self . has_value_ <EOL> def flags ( self ) : return self . flags_ <EOL> def set_flags ( self , x ) : <EOL> self . has_flags_ = <NUM_LIT:1> <EOL> self . flags_ = x <EOL> def clear_flags ( self ) : <EOL> if self . has_flags_ : <EOL> self . has_flags_ = <NUM_LIT:0> <EOL> self . flags_ = <NUM_LIT:0> <EOL> def has_flags ( self ) : return self . has_flags_ <EOL> def MergeFrom ( self , x ) : <EOL> assert x is not self <EOL> if ( x . has_value ( ) ) : self . set_value ( x . value ( ) ) <EOL> if ( x . has_flags ( ) ) : self . set_flags ( x . flags ( ) ) <EOL> def Equals ( self , x ) : <EOL> if x is self : return <NUM_LIT:1> <EOL> if self . has_value_ != x . has_value_ : return <NUM_LIT:0> <EOL> if self . has_value_ and self . value_ != x . value_ : return <NUM_LIT:0> <EOL> if self . has_flags_ != x . has_flags_ : return <NUM_LIT:0> <EOL> if self . has_flags_ and self . flags_ != x . flags_ : return <NUM_LIT:0> <EOL> return <NUM_LIT:1> <EOL> def IsInitialized ( self , debug_strs = None ) : <EOL> initialized = <NUM_LIT:1> <EOL> if ( not self . has_value_ ) : <EOL> initialized = <NUM_LIT:0> <EOL> if debug_strs is not None : <EOL> debug_strs . append ( '<STR_LIT>' ) <EOL> return initialized <EOL> def ByteSize ( self ) : <EOL> n = <NUM_LIT:0> <EOL> n += self . lengthString ( len ( self . value_ ) ) <EOL> if ( self . has_flags_ ) : n += <NUM_LIT:5> <EOL> return n + <NUM_LIT:1> <EOL> def Clear ( self ) : <EOL> self . clear_value ( ) <EOL> self . clear_flags ( ) <EOL> def OutputUnchecked ( self , out ) : <EOL> out . putVarInt32 ( <NUM_LIT> ) <EOL> out . putPrefixedString ( self . value_ ) <EOL> if ( self . has_flags_ ) : <EOL> out . putVarInt32 ( <NUM_LIT> ) <EOL> out . put32 ( self . flags_ ) <EOL> def TryMerge ( self , d ) : <EOL> while <NUM_LIT:1> : <EOL> tt = d . getVarInt32 ( ) <EOL> if tt == <NUM_LIT:12> : break <EOL> if tt == <NUM_LIT> : <EOL> self . set_value ( d . getPrefixedString ( ) ) <EOL> continue <EOL> if tt == <NUM_LIT> : <EOL> self . set_flags ( d . get32 ( ) ) <EOL> continue <EOL> if ( tt == <NUM_LIT:0> ) : raise ProtocolBuffer . ProtocolBufferDecodeError <EOL> d . skipData ( tt ) <EOL> def __str__ ( self , prefix = "<STR_LIT>" , printElemNumber = <NUM_LIT:0> ) : <EOL> res = "<STR_LIT>" <EOL> if self . has_value_ : res += prefix + ( "<STR_LIT>" % self . DebugFormatString ( self . value_ ) ) <EOL> if self . has_flags_ : res += prefix + ( "<STR_LIT>" % self . DebugFormatFixed32 ( self . flags_ ) ) <EOL> return res <EOL> class MemcacheGrabTailResponse ( ProtocolBuffer . ProtocolMessage ) : <EOL> def __init__ ( self , contents = None ) : <EOL> self . item_ = [ ] <EOL> if contents is not None : self . MergeFromString ( contents ) <EOL> def item_size ( self ) : return len ( self . item_ ) <EOL> def item_list ( self ) : return self . item_ <EOL> def item ( self , i ) : <EOL> return self . item_ [ i ] <EOL> def mutable_item ( self , i ) : <EOL> return self . item_ [ i ] <EOL> def add_item ( self ) : <EOL> x = MemcacheGrabTailResponse_Item ( ) <EOL> self . item_ . append ( x ) <EOL> return x <EOL> def clear_item ( self ) : <EOL> self . item_ = [ ] <EOL> def MergeFrom ( self , x ) : <EOL> assert x is not self <EOL> for i in xrange ( x . item_size ( ) ) : self . add_item ( ) . CopyFrom ( x . item ( i ) ) <EOL> def Equals ( self , x ) : <EOL> if x is self : return <NUM_LIT:1> <EOL> if len ( self . item_ ) != len ( x . item_ ) : return <NUM_LIT:0> <EOL> for e1 , e2 in zip ( self . item_ , x . item_ ) : <EOL> if e1 != e2 : return <NUM_LIT:0> <EOL> return <NUM_LIT:1> <EOL> def IsInitialized ( self , debug_strs = None ) : <EOL> initialized = <NUM_LIT:1> <EOL> for p in self . item_ : <EOL> if not p . IsInitialized ( debug_strs ) : initialized = <NUM_LIT:0> <EOL> return initialized <EOL> def ByteSize ( self ) : <EOL> n = <NUM_LIT:0> <EOL> n += <NUM_LIT:2> * len ( self . item_ ) <EOL> for i in xrange ( len ( self . item_ ) ) : n += self . item_ [ i ] . ByteSize ( ) <EOL> return n + <NUM_LIT:0> <EOL> def Clear ( self ) : <EOL> self . clear_item ( ) <EOL> def OutputUnchecked ( self , out ) : <EOL> for i in xrange ( len ( self . item_ ) ) : <EOL> out . putVarInt32 ( <NUM_LIT:11> ) <EOL> self . item_ [ i ] . OutputUnchecked ( out ) <EOL> out . putVarInt32 ( <NUM_LIT:12> ) <EOL> def TryMerge ( self , d ) : <EOL> while d . avail ( ) > <NUM_LIT:0> : <EOL> tt = d . getVarInt32 ( ) <EOL> if tt == <NUM_LIT:11> : <EOL> self . add_item ( ) . TryMerge ( d ) <EOL> continue <EOL> if ( tt == <NUM_LIT:0> ) : raise ProtocolBuffer . ProtocolBufferDecodeError <EOL> d . skipData ( tt ) <EOL> def __str__ ( self , prefix = "<STR_LIT>" , printElemNumber = <NUM_LIT:0> ) : <EOL> res = "<STR_LIT>" <EOL> cnt = <NUM_LIT:0> <EOL> for e in self . item_ : <EOL> elm = "<STR_LIT>" <EOL> if printElemNumber : elm = "<STR_LIT>" % cnt <EOL> res += prefix + ( "<STR_LIT>" % elm ) <EOL> res += e . __str__ ( prefix + "<STR_LIT:U+0020>" , printElemNumber ) <EOL> res += prefix + "<STR_LIT>" <EOL> cnt += <NUM_LIT:1> <EOL> return res <EOL> def _BuildTagLookupTable ( sparse , maxtag , default = None ) : <EOL> return tuple ( [ sparse . get ( i , default ) for i in xrange ( <NUM_LIT:0> , <NUM_LIT:1> + maxtag ) ] ) <EOL> kItemGroup = <NUM_LIT:1> <EOL> kItemvalue = <NUM_LIT:2> <EOL> kItemflags = <NUM_LIT:3> <EOL> _TEXT = _BuildTagLookupTable ( { <EOL> <NUM_LIT:0> : "<STR_LIT>" , <EOL> <NUM_LIT:1> : "<STR_LIT>" , <EOL> <NUM_LIT:2> : "<STR_LIT:value>" , <EOL> <NUM_LIT:3> : "<STR_LIT>" , <EOL> } , <NUM_LIT:3> ) <EOL> _TYPES = _BuildTagLookupTable ( { <EOL> <NUM_LIT:0> : ProtocolBuffer . Encoder . NUMERIC , <EOL> <NUM_LIT:1> : ProtocolBuffer . Encoder . STARTGROUP , <EOL> <NUM_LIT:2> : ProtocolBuffer . Encoder . STRING , <EOL> <NUM_LIT:3> : ProtocolBuffer . Encoder . FLOAT , <EOL> } , <NUM_LIT:3> , ProtocolBuffer . Encoder . MAX_TYPE ) <EOL> _STYLE = """<STR_LIT>""" <EOL> _STYLE_CONTENT_TYPE = """<STR_LIT>""" <EOL> __all__ = [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] </s>

<s> """<STR_LIT>""" <EOL> import calendar <EOL> import datetime <EOL> import logging <EOL> import re <EOL> import time <EOL> from google . appengine . api import datastore <EOL> from google . appengine . api import datastore_errors <EOL> from google . appengine . api import datastore_types <EOL> from google . appengine . api import users <EOL> MultiQuery = datastore . MultiQuery <EOL> LOG_LEVEL = logging . DEBUG - <NUM_LIT:1> <EOL> _EPOCH = datetime . datetime . utcfromtimestamp ( <NUM_LIT:0> ) <EOL> def Execute ( query_string , * args , ** keyword_args ) : <EOL> """<STR_LIT>""" <EOL> app = keyword_args . pop ( '<STR_LIT>' , None ) <EOL> proto_query = GQL ( query_string , _app = app ) <EOL> return proto_query . Bind ( args , keyword_args ) . Run ( ) <EOL> class GQL ( object ) : <EOL> """<STR_LIT>""" <EOL> TOKENIZE_REGEX = re . compile ( r"""<STR_LIT>""" , re . VERBOSE | re . IGNORECASE ) <EOL> MAX_ALLOWABLE_QUERIES = datastore . MAX_ALLOWABLE_QUERIES <EOL> __ANCESTOR = - <NUM_LIT:1> <EOL> def __init__ ( self , query_string , _app = None , _auth_domain = None ) : <EOL> """<STR_LIT>""" <EOL> self . _entity = '<STR_LIT>' <EOL> self . __filters = { } <EOL> self . __has_ancestor = False <EOL> self . __orderings = [ ] <EOL> self . __offset = - <NUM_LIT:1> <EOL> self . __limit = - <NUM_LIT:1> <EOL> self . __hint = '<STR_LIT>' <EOL> self . __app = _app <EOL> self . __auth_domain = _auth_domain <EOL> self . __symbols = self . TOKENIZE_REGEX . findall ( query_string ) <EOL> self . __next_symbol = <NUM_LIT:0> <EOL> if not self . __Select ( ) : <EOL> raise datastore_errors . BadQueryError ( <EOL> '<STR_LIT>' ) <EOL> else : <EOL> pass <EOL> def Bind ( self , args , keyword_args ) : <EOL> """<STR_LIT>""" <EOL> num_args = len ( args ) <EOL> input_args = frozenset ( xrange ( num_args ) ) <EOL> used_args = set ( ) <EOL> queries = [ ] <EOL> enumerated_queries = self . EnumerateQueries ( used_args , args , keyword_args ) <EOL> if enumerated_queries : <EOL> query_count = len ( enumerated_queries ) <EOL> else : <EOL> query_count = <NUM_LIT:1> <EOL> for i in xrange ( query_count ) : <EOL> queries . append ( datastore . Query ( self . _entity , _app = self . __app , <EOL> keys_only = self . _keys_only ) ) <EOL> logging . log ( LOG_LEVEL , <EOL> '<STR_LIT>' <EOL> , len ( args ) , args , len ( keyword_args ) , keyword_args ) <EOL> for ( ( identifier , condition ) , value_list ) in self . __filters . iteritems ( ) : <EOL> for ( operator , params ) in value_list : <EOL> value = self . __Operate ( args , keyword_args , used_args , operator , params ) <EOL> if not self . __IsMultiQuery ( condition ) : <EOL> for query in queries : <EOL> self . __AddFilterToQuery ( identifier , condition , value , query ) <EOL> unused_args = input_args - used_args <EOL> if unused_args : <EOL> unused_values = [ unused_arg + <NUM_LIT:1> for unused_arg in unused_args ] <EOL> raise datastore_errors . BadArgumentError ( '<STR_LIT>' % <EOL> unused_values ) <EOL> if enumerated_queries : <EOL> logging . log ( LOG_LEVEL , <EOL> '<STR_LIT>' , <EOL> enumerated_queries ) <EOL> for ( query , enumerated_query ) in zip ( queries , enumerated_queries ) : <EOL> query . update ( enumerated_query ) <EOL> if self . __orderings : <EOL> for query in queries : <EOL> query . Order ( * tuple ( self . __orderings ) ) <EOL> if query_count > <NUM_LIT:1> : <EOL> return MultiQuery ( queries , self . __orderings ) <EOL> else : <EOL> return queries [ <NUM_LIT:0> ] <EOL> def EnumerateQueries ( self , used_args , args , keyword_args ) : <EOL> """<STR_LIT>""" <EOL> enumerated_queries = [ ] <EOL> for ( ( identifier , condition ) , value_list ) in self . __filters . iteritems ( ) : <EOL> for ( operator , params ) in value_list : <EOL> value = self . __Operate ( args , keyword_args , used_args , operator , params ) <EOL> self . __AddMultiQuery ( identifier , condition , value , enumerated_queries ) <EOL> return enumerated_queries <EOL> def __CastError ( self , operator , values , error_message ) : <EOL> """<STR_LIT>""" <EOL> raise datastore_errors . BadQueryError ( <EOL> '<STR_LIT>' % <EOL> ( values , operator . upper ( ) , error_message ) ) <EOL> def __CastNop ( self , values ) : <EOL> """<STR_LIT>""" <EOL> if len ( values ) != <NUM_LIT:1> : <EOL> self . __CastError ( values , '<STR_LIT>' , '<STR_LIT>' ) <EOL> else : <EOL> return values [ <NUM_LIT:0> ] <EOL> def __CastList ( self , values ) : <EOL> """<STR_LIT>""" <EOL> if values : <EOL> return values <EOL> else : <EOL> return None <EOL> def __CastKey ( self , values ) : <EOL> """<STR_LIT>""" <EOL> if not len ( values ) % <NUM_LIT:2> : <EOL> return datastore_types . Key . from_path ( _app = self . __app , * values ) <EOL> elif len ( values ) == <NUM_LIT:1> and isinstance ( values [ <NUM_LIT:0> ] , basestring ) : <EOL> return datastore_types . Key ( values [ <NUM_LIT:0> ] ) <EOL> else : <EOL> self . __CastError ( '<STR_LIT>' , values , <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' ) <EOL> def __CastGeoPt ( self , values ) : <EOL> """<STR_LIT>""" <EOL> if len ( values ) != <NUM_LIT:2> : <EOL> self . __CastError ( '<STR_LIT>' , values , '<STR_LIT>' ) <EOL> return datastore_types . GeoPt ( * values ) <EOL> def __CastUser ( self , values ) : <EOL> """<STR_LIT>""" <EOL> if len ( values ) != <NUM_LIT:1> : <EOL> self . __CastError ( '<STR_LIT:user>' , values , '<STR_LIT>' ) <EOL> elif values [ <NUM_LIT:0> ] is None : <EOL> self . __CastError ( '<STR_LIT:user>' , values , '<STR_LIT>' ) <EOL> else : <EOL> return users . User ( email = values [ <NUM_LIT:0> ] , _auth_domain = self . __auth_domain ) <EOL> def __EncodeIfNeeded ( self , value ) : <EOL> """<STR_LIT>""" <EOL> if isinstance ( value , unicode ) : <EOL> return value . encode ( '<STR_LIT:utf8>' ) <EOL> else : <EOL> return value <EOL> def __CastDate ( self , values ) : <EOL> """<STR_LIT>""" <EOL> if len ( values ) == <NUM_LIT:1> : <EOL> value = self . __EncodeIfNeeded ( values [ <NUM_LIT:0> ] ) <EOL> if isinstance ( value , str ) : <EOL> try : <EOL> time_tuple = time . strptime ( value , '<STR_LIT>' ) [ <NUM_LIT:0> : <NUM_LIT:6> ] <EOL> except ValueError , err : <EOL> self . __CastError ( '<STR_LIT>' , values , err ) <EOL> else : <EOL> self . __CastError ( '<STR_LIT>' , values , '<STR_LIT>' ) <EOL> elif len ( values ) == <NUM_LIT:3> : <EOL> time_tuple = ( values [ <NUM_LIT:0> ] , values [ <NUM_LIT:1> ] , values [ <NUM_LIT:2> ] , <NUM_LIT:0> , <NUM_LIT:0> , <NUM_LIT:0> ) <EOL> else : <EOL> self . __CastError ( '<STR_LIT>' , values , <EOL> '<STR_LIT>' ) <EOL> try : <EOL> return datetime . datetime ( * time_tuple ) <EOL> except ValueError , err : <EOL> self . __CastError ( '<STR_LIT>' , values , err ) <EOL> def __CastTime ( self , values ) : <EOL> """<STR_LIT>""" <EOL> if len ( values ) == <NUM_LIT:1> : <EOL> value = self . __EncodeIfNeeded ( values [ <NUM_LIT:0> ] ) <EOL> if isinstance ( value , str ) : <EOL> try : <EOL> time_tuple = time . strptime ( value , '<STR_LIT>' ) <EOL> except ValueError , err : <EOL> self . __CastError ( '<STR_LIT>' , values , err ) <EOL> time_tuple = ( <NUM_LIT> , <NUM_LIT:1> , <NUM_LIT:1> ) + time_tuple [ <NUM_LIT:3> : ] <EOL> time_tuple = time_tuple [ <NUM_LIT:0> : <NUM_LIT:6> ] <EOL> elif isinstance ( value , int ) : <EOL> time_tuple = ( <NUM_LIT> , <NUM_LIT:1> , <NUM_LIT:1> , value ) <EOL> else : <EOL> self . __CastError ( '<STR_LIT>' , values , <EOL> '<STR_LIT>' ) <EOL> elif len ( values ) <= <NUM_LIT:4> : <EOL> time_tuple = ( <NUM_LIT> , <NUM_LIT:1> , <NUM_LIT:1> ) + tuple ( values ) <EOL> else : <EOL> self . __CastError ( '<STR_LIT>' , values , <EOL> '<STR_LIT>' ) <EOL> try : <EOL> return datetime . datetime ( * time_tuple ) <EOL> except ValueError , err : <EOL> self . __CastError ( '<STR_LIT>' , values , err ) <EOL> def __CastDatetime ( self , values ) : <EOL> """<STR_LIT>""" <EOL> if len ( values ) == <NUM_LIT:1> : <EOL> value = self . __EncodeIfNeeded ( values [ <NUM_LIT:0> ] ) <EOL> if isinstance ( value , str ) : <EOL> try : <EOL> time_tuple = time . strptime ( str ( value ) , '<STR_LIT>' ) [ <NUM_LIT:0> : <NUM_LIT:6> ] <EOL> except ValueError , err : <EOL> self . __CastError ( '<STR_LIT>' , values , err ) <EOL> else : <EOL> self . __CastError ( '<STR_LIT>' , values , '<STR_LIT>' ) <EOL> else : <EOL> time_tuple = values <EOL> try : <EOL> return datetime . datetime ( * time_tuple ) <EOL> except ValueError , err : <EOL> self . __CastError ( '<STR_LIT>' , values , err ) <EOL> def __Operate ( self , args , keyword_args , used_args , operator , params ) : <EOL> """<STR_LIT>""" <EOL> if not params : <EOL> return None <EOL> param_values = [ ] <EOL> for param in params : <EOL> if isinstance ( param , Literal ) : <EOL> value = param . Get ( ) <EOL> else : <EOL> value = self . __GetParam ( param , args , keyword_args ) <EOL> if isinstance ( param , int ) : <EOL> used_args . add ( param - <NUM_LIT:1> ) <EOL> logging . log ( LOG_LEVEL , '<STR_LIT>' , <EOL> param , value ) <EOL> param_values . append ( value ) <EOL> logging . log ( LOG_LEVEL , '<STR_LIT>' , <EOL> operator , repr ( param_values ) ) <EOL> if operator in self . __cast_operators : <EOL> result = self . __cast_operators [ operator ] ( self , param_values ) <EOL> else : <EOL> self . __Error ( '<STR_LIT>' % operator ) <EOL> return result <EOL> def __IsMultiQuery ( self , condition ) : <EOL> """<STR_LIT>""" <EOL> return condition . lower ( ) in ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> def __GetParam ( self , reference , args , keyword_args ) : <EOL> """<STR_LIT>""" <EOL> num_args = len ( args ) <EOL> if isinstance ( reference , int ) : <EOL> if reference <= num_args : <EOL> return args [ reference - <NUM_LIT:1> ] <EOL> else : <EOL> raise datastore_errors . BadArgumentError ( <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' % ( reference , num_args ) ) <EOL> elif isinstance ( reference , basestring ) : <EOL> if reference in keyword_args : <EOL> return keyword_args [ reference ] <EOL> else : <EOL> raise datastore_errors . BadArgumentError ( <EOL> '<STR_LIT>' % <EOL> reference ) <EOL> else : <EOL> assert False , '<STR_LIT>' % reference <EOL> def __AddMultiQuery ( self , identifier , condition , value , enumerated_queries ) : <EOL> """<STR_LIT>""" <EOL> if condition . lower ( ) in ( '<STR_LIT>' , '<STR_LIT>' ) and self . _keys_only : <EOL> raise datastore_errors . BadQueryError ( <EOL> '<STR_LIT>' ) <EOL> def CloneQueries ( queries , n ) : <EOL> """<STR_LIT>""" <EOL> if not enumerated_queries : <EOL> for i in xrange ( n ) : <EOL> queries . append ( { } ) <EOL> return <NUM_LIT:1> <EOL> else : <EOL> old_size = len ( queries ) <EOL> tmp_queries = [ ] <EOL> for i in xrange ( n - <NUM_LIT:1> ) : <EOL> [ tmp_queries . append ( filter_map . copy ( ) ) for filter_map in queries ] <EOL> queries . extend ( tmp_queries ) <EOL> queries . sort ( ) <EOL> return old_size <EOL> if condition == '<STR_LIT>' : <EOL> if len ( enumerated_queries ) * <NUM_LIT:2> > self . MAX_ALLOWABLE_QUERIES : <EOL> raise datastore_errors . BadArgumentError ( <EOL> '<STR_LIT>' ) <EOL> num_iterations = CloneQueries ( enumerated_queries , <NUM_LIT:2> ) <EOL> for i in xrange ( num_iterations ) : <EOL> enumerated_queries [ <NUM_LIT:2> * i ] [ '<STR_LIT>' % identifier ] = value <EOL> enumerated_queries [ <NUM_LIT:2> * i + <NUM_LIT:1> ] [ '<STR_LIT>' % identifier ] = value <EOL> elif condition . lower ( ) == '<STR_LIT>' : <EOL> if not isinstance ( value , list ) : <EOL> raise datastore_errors . BadArgumentError ( '<STR_LIT>' ) <EOL> in_list_size = len ( value ) <EOL> if len ( enumerated_queries ) * in_list_size > self . MAX_ALLOWABLE_QUERIES : <EOL> raise datastore_errors . BadArgumentError ( <EOL> '<STR_LIT>' ) <EOL> num_iterations = CloneQueries ( enumerated_queries , in_list_size ) <EOL> for clone_num in xrange ( num_iterations ) : <EOL> for value_num in xrange ( len ( value ) ) : <EOL> list_val = value [ value_num ] <EOL> query_num = in_list_size * clone_num + value_num <EOL> filt = '<STR_LIT>' % identifier <EOL> enumerated_queries [ query_num ] [ filt ] = list_val <EOL> def __AddFilterToQuery ( self , identifier , condition , value , query ) : <EOL> """<STR_LIT>""" <EOL> if identifier != self . __ANCESTOR : <EOL> filter_condition = '<STR_LIT>' % ( identifier , condition ) <EOL> logging . log ( LOG_LEVEL , '<STR_LIT>' , <EOL> filter_condition , value . __class__ ) <EOL> datastore . _AddOrAppend ( query , filter_condition , value ) <EOL> else : <EOL> logging . log ( LOG_LEVEL , '<STR_LIT>' , value ) <EOL> query . Ancestor ( value ) <EOL> def Run ( self , * args , ** keyword_args ) : <EOL> """<STR_LIT>""" <EOL> bind_results = self . Bind ( args , keyword_args ) <EOL> offset = <NUM_LIT:0> <EOL> if self . __offset != - <NUM_LIT:1> : <EOL> offset = self . __offset <EOL> if self . __limit == - <NUM_LIT:1> : <EOL> it = bind_results . Run ( ) <EOL> try : <EOL> for i in xrange ( offset ) : <EOL> it . next ( ) <EOL> except StopIteration : <EOL> pass <EOL> return it <EOL> else : <EOL> res = bind_results . Get ( self . __limit , offset ) <EOL> return res <EOL> def filters ( self ) : <EOL> """<STR_LIT>""" <EOL> return self . __filters <EOL> def hint ( self ) : <EOL> """<STR_LIT>""" <EOL> return self . __hint <EOL> def limit ( self ) : <EOL> """<STR_LIT>""" <EOL> return self . __limit <EOL> def orderings ( self ) : <EOL> """<STR_LIT>""" <EOL> return self . __orderings <EOL> def is_keys_only ( self ) : <EOL> """<STR_LIT>""" <EOL> return self . _keys_only <EOL> __iter__ = Run <EOL> __result_type_regex = re . compile ( r'<STR_LIT>' ) <EOL> __quoted_string_regex = re . compile ( r'<STR_LIT>' ) <EOL> __ordinal_regex = re . compile ( r'<STR_LIT>' ) <EOL> __named_regex = re . compile ( r'<STR_LIT>' ) <EOL> __identifier_regex = re . compile ( r'<STR_LIT>' ) <EOL> __conditions_regex = re . compile ( r'<STR_LIT>' , re . IGNORECASE ) <EOL> __number_regex = re . compile ( r'<STR_LIT>' ) <EOL> __cast_regex = re . compile ( <EOL> r'<STR_LIT>' , re . IGNORECASE ) <EOL> __cast_operators = { <EOL> '<STR_LIT>' : __CastGeoPt , <EOL> '<STR_LIT:user>' : __CastUser , <EOL> '<STR_LIT:key>' : __CastKey , <EOL> '<STR_LIT>' : __CastDatetime , <EOL> '<STR_LIT:date>' : __CastDate , <EOL> '<STR_LIT:time>' : __CastTime , <EOL> '<STR_LIT:list>' : __CastList , <EOL> '<STR_LIT>' : __CastNop , <EOL> } <EOL> def __Error ( self , error_message ) : <EOL> """<STR_LIT>""" <EOL> if self . __next_symbol >= len ( self . __symbols ) : <EOL> raise datastore_errors . BadQueryError ( <EOL> '<STR_LIT>' % error_message ) <EOL> else : <EOL> raise datastore_errors . BadQueryError ( <EOL> '<STR_LIT>' % <EOL> ( error_message , self . __symbols [ self . __next_symbol ] ) ) <EOL> def __Accept ( self , symbol_string ) : <EOL> """<STR_LIT>""" <EOL> if self . __next_symbol < len ( self . __symbols ) : <EOL> logging . log ( LOG_LEVEL , '<STR_LIT>' , self . __symbols ) <EOL> logging . log ( LOG_LEVEL , '<STR_LIT>' , <EOL> symbol_string , self . __symbols [ self . __next_symbol ] . upper ( ) ) <EOL> if self . __symbols [ self . __next_symbol ] . upper ( ) == symbol_string : <EOL> self . __next_symbol += <NUM_LIT:1> <EOL> return True <EOL> return False <EOL> def __Expect ( self , symbol_string ) : <EOL> """<STR_LIT>""" <EOL> if not self . __Accept ( symbol_string ) : <EOL> self . __Error ( '<STR_LIT>' % symbol_string ) <EOL> def __AcceptRegex ( self , regex ) : <EOL> """<STR_LIT>""" <EOL> if self . __next_symbol < len ( self . __symbols ) : <EOL> match_symbol = self . __symbols [ self . __next_symbol ] <EOL> logging . log ( LOG_LEVEL , '<STR_LIT>' , regex , match_symbol ) <EOL> match = regex . match ( match_symbol ) <EOL> if match : <EOL> self . __next_symbol += <NUM_LIT:1> <EOL> if match . groups ( ) : <EOL> matched_string = match . group ( <NUM_LIT:1> ) <EOL> logging . log ( LOG_LEVEL , '<STR_LIT>' , matched_string ) <EOL> return matched_string <EOL> return None <EOL> def __AcceptTerminal ( self ) : <EOL> """<STR_LIT>""" <EOL> if self . __next_symbol < len ( self . __symbols ) : <EOL> self . __Error ( '<STR_LIT>' ) <EOL> return True <EOL> def __Select ( self ) : <EOL> """<STR_LIT>""" <EOL> self . __Expect ( '<STR_LIT>' ) <EOL> result_type = self . __AcceptRegex ( self . __result_type_regex ) <EOL> self . _keys_only = ( result_type == '<STR_LIT>' ) <EOL> return self . __From ( ) <EOL> def __From ( self ) : <EOL> """<STR_LIT>""" <EOL> if self . __Accept ( '<STR_LIT>' ) : <EOL> kind = self . __AcceptRegex ( self . __identifier_regex ) <EOL> if kind : <EOL> self . _entity = kind <EOL> else : <EOL> self . __Error ( '<STR_LIT>' ) <EOL> return False <EOL> else : <EOL> self . _entity = None <EOL> return self . __Where ( ) <EOL> def __Where ( self ) : <EOL> """<STR_LIT>""" <EOL> if self . __Accept ( '<STR_LIT>' ) : <EOL> return self . __FilterList ( ) <EOL> return self . __OrderBy ( ) <EOL> def __FilterList ( self ) : <EOL> """<STR_LIT>""" <EOL> identifier = self . __AcceptRegex ( self . __identifier_regex ) <EOL> if not identifier : <EOL> self . __Error ( '<STR_LIT>' ) <EOL> return False <EOL> condition = self . __AcceptRegex ( self . __conditions_regex ) <EOL> if not condition : <EOL> self . __Error ( '<STR_LIT>' ) <EOL> return False <EOL> self . __CheckFilterSyntax ( identifier , condition ) <EOL> if not self . __AddSimpleFilter ( identifier , condition , self . __Reference ( ) ) : <EOL> if not self . __AddSimpleFilter ( identifier , condition , self . __Literal ( ) ) : <EOL> type_cast = self . __TypeCast ( ) <EOL> if ( not type_cast or <EOL> not self . __AddProcessedParameterFilter ( identifier , condition , <EOL> * type_cast ) ) : <EOL> self . __Error ( '<STR_LIT>' ) <EOL> if self . __Accept ( '<STR_LIT>' ) : <EOL> return self . __FilterList ( ) <EOL> return self . __OrderBy ( ) <EOL> def __GetValueList ( self ) : <EOL> """<STR_LIT>""" <EOL> params = [ ] <EOL> while True : <EOL> reference = self . __Reference ( ) <EOL> if reference : <EOL> params . append ( reference ) <EOL> else : <EOL> literal = self . __Literal ( ) <EOL> if literal : <EOL> params . append ( literal ) <EOL> else : <EOL> self . __Error ( '<STR_LIT>' ) <EOL> if not self . __Accept ( '<STR_LIT:U+002C>' ) : <EOL> break <EOL> return params <EOL> def __CheckFilterSyntax ( self , identifier , condition ) : <EOL> """<STR_LIT>""" <EOL> if identifier . lower ( ) == '<STR_LIT>' : <EOL> if condition . lower ( ) == '<STR_LIT>' : <EOL> if self . __has_ancestor : <EOL> self . __Error ( '<STR_LIT>' ) <EOL> else : <EOL> self . __Error ( '<STR_LIT>' ) <EOL> elif condition . lower ( ) == '<STR_LIT>' : <EOL> self . __Error ( '<STR_LIT>' ) <EOL> def __AddProcessedParameterFilter ( self , identifier , condition , <EOL> operator , parameters ) : <EOL> """<STR_LIT>""" <EOL> if parameters is None : <EOL> return False <EOL> if parameters [ <NUM_LIT:0> ] is None : <EOL> return False <EOL> logging . log ( LOG_LEVEL , '<STR_LIT>' , <EOL> identifier , condition , repr ( parameters ) ) <EOL> filter_rule = ( identifier , condition ) <EOL> if identifier . lower ( ) == '<STR_LIT>' : <EOL> self . __has_ancestor = True <EOL> filter_rule = ( self . __ANCESTOR , '<STR_LIT>' ) <EOL> assert condition . lower ( ) == '<STR_LIT>' <EOL> if operator == '<STR_LIT:list>' and condition . lower ( ) != '<STR_LIT>' : <EOL> self . __Error ( '<STR_LIT>' ) <EOL> self . __filters . setdefault ( filter_rule , [ ] ) . append ( ( operator , parameters ) ) <EOL> return True <EOL> def __AddSimpleFilter ( self , identifier , condition , parameter ) : <EOL> """<STR_LIT>""" <EOL> return self . __AddProcessedParameterFilter ( identifier , condition , <EOL> '<STR_LIT>' , [ parameter ] ) <EOL> def __Reference ( self ) : <EOL> """<STR_LIT>""" <EOL> logging . log ( LOG_LEVEL , '<STR_LIT>' ) <EOL> reference = self . __AcceptRegex ( self . __ordinal_regex ) <EOL> if reference : <EOL> return int ( reference ) <EOL> else : <EOL> reference = self . __AcceptRegex ( self . __named_regex ) <EOL> if reference : <EOL> return reference <EOL> return None <EOL> def __Literal ( self ) : <EOL> """<STR_LIT>""" <EOL> logging . log ( LOG_LEVEL , '<STR_LIT>' ) <EOL> literal = None <EOL> try : <EOL> literal = int ( self . __symbols [ self . __next_symbol ] ) <EOL> except ValueError : <EOL> pass <EOL> else : <EOL> self . __next_symbol += <NUM_LIT:1> <EOL> if literal is None : <EOL> try : <EOL> literal = float ( self . __symbols [ self . __next_symbol ] ) <EOL> except ValueError : <EOL> pass <EOL> else : <EOL> self . __next_symbol += <NUM_LIT:1> <EOL> if literal is None : <EOL> literal = self . __AcceptRegex ( self . __quoted_string_regex ) <EOL> if literal : <EOL> literal = literal [ <NUM_LIT:1> : - <NUM_LIT:1> ] . replace ( "<STR_LIT>" , "<STR_LIT:'>" ) <EOL> if literal is None : <EOL> if self . __Accept ( '<STR_LIT>' ) : <EOL> literal = True <EOL> elif self . __Accept ( '<STR_LIT>' ) : <EOL> literal = False <EOL> if literal is not None : <EOL> return Literal ( literal ) <EOL> if self . __Accept ( '<STR_LIT>' ) : <EOL> return Literal ( None ) <EOL> else : <EOL> return None <EOL> def __TypeCast ( self ) : <EOL> """<STR_LIT>""" <EOL> logging . log ( LOG_LEVEL , '<STR_LIT>' ) <EOL> cast_op = self . __AcceptRegex ( self . __cast_regex ) <EOL> if not cast_op : <EOL> if self . __Accept ( '<STR_LIT:(>' ) : <EOL> cast_op = '<STR_LIT:list>' <EOL> else : <EOL> return None <EOL> else : <EOL> cast_op = cast_op . lower ( ) <EOL> self . __Expect ( '<STR_LIT:(>' ) <EOL> params = self . __GetValueList ( ) <EOL> self . __Expect ( '<STR_LIT:)>' ) <EOL> logging . log ( LOG_LEVEL , '<STR_LIT>' , <EOL> cast_op , repr ( params ) ) <EOL> return ( cast_op , params ) <EOL> def __OrderBy ( self ) : <EOL> """<STR_LIT>""" <EOL> if self . __Accept ( '<STR_LIT>' ) : <EOL> self . __Expect ( '<STR_LIT>' ) <EOL> return self . __OrderList ( ) <EOL> return self . __Limit ( ) <EOL> def __OrderList ( self ) : <EOL> """<STR_LIT>""" <EOL> identifier = self . __AcceptRegex ( self . __identifier_regex ) <EOL> if identifier : <EOL> if self . __Accept ( '<STR_LIT>' ) : <EOL> self . __orderings . append ( ( identifier , datastore . Query . DESCENDING ) ) <EOL> elif self . __Accept ( '<STR_LIT>' ) : <EOL> self . __orderings . append ( ( identifier , datastore . Query . ASCENDING ) ) <EOL> else : <EOL> self . __orderings . append ( ( identifier , datastore . Query . ASCENDING ) ) <EOL> else : <EOL> self . __Error ( '<STR_LIT>' ) <EOL> logging . log ( LOG_LEVEL , self . __orderings ) <EOL> if self . __Accept ( '<STR_LIT:U+002C>' ) : <EOL> return self . __OrderList ( ) <EOL> return self . __Limit ( ) <EOL> def __Limit ( self ) : <EOL> """<STR_LIT>""" <EOL> if self . __Accept ( '<STR_LIT>' ) : <EOL> maybe_limit = self . __AcceptRegex ( self . __number_regex ) <EOL> if maybe_limit : <EOL> if self . __Accept ( '<STR_LIT:U+002C>' ) : <EOL> self . __offset = int ( maybe_limit ) <EOL> if self . __offset < <NUM_LIT:0> : <EOL> self . __Error ( '<STR_LIT>' ) <EOL> else : <EOL> logging . log ( LOG_LEVEL , '<STR_LIT>' , self . __offset ) <EOL> maybe_limit = self . __AcceptRegex ( self . __number_regex ) <EOL> self . __limit = int ( maybe_limit ) <EOL> if self . __limit < <NUM_LIT:1> : <EOL> self . __Error ( '<STR_LIT>' ) <EOL> else : <EOL> logging . log ( LOG_LEVEL , '<STR_LIT>' , self . __limit ) <EOL> else : <EOL> self . __Error ( '<STR_LIT>' ) <EOL> return self . __Offset ( ) <EOL> def __Offset ( self ) : <EOL> """<STR_LIT>""" <EOL> if self . __Accept ( '<STR_LIT>' ) : <EOL> if self . __offset != - <NUM_LIT:1> : <EOL> self . __Error ( '<STR_LIT>' ) <EOL> offset = self . __AcceptRegex ( self . __number_regex ) <EOL> if offset : <EOL> self . __offset = int ( offset ) <EOL> if self . __offset < <NUM_LIT:0> : <EOL> self . __Error ( '<STR_LIT>' ) <EOL> else : <EOL> logging . log ( LOG_LEVEL , '<STR_LIT>' , self . __offset ) <EOL> else : <EOL> self . __Error ( '<STR_LIT>' ) <EOL> return self . __Hint ( ) <EOL> def __Hint ( self ) : <EOL> """<STR_LIT>""" <EOL> if self . __Accept ( '<STR_LIT>' ) : <EOL> if self . __Accept ( '<STR_LIT>' ) : <EOL> self . __hint = '<STR_LIT>' <EOL> elif self . __Accept ( '<STR_LIT>' ) : <EOL> self . __hint = '<STR_LIT>' <EOL> elif self . __Accept ( '<STR_LIT>' ) : <EOL> self . __hint = '<STR_LIT>' <EOL> else : <EOL> self . __Error ( '<STR_LIT>' ) <EOL> return False <EOL> return self . __AcceptTerminal ( ) <EOL> class Literal ( object ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , value ) : <EOL> self . __value = value <EOL> def Get ( self ) : <EOL> """<STR_LIT>""" <EOL> return self . __value <EOL> def __repr__ ( self ) : <EOL> return '<STR_LIT>' % repr ( self . __value ) </s>

<s> """<STR_LIT>""" <EOL> import os <EOL> import logging <EOL> from google . appengine . api import apiproxy_stub_map <EOL> from google . appengine . api import datastore_admin <EOL> from google . appengine . api import yaml_errors <EOL> from google . appengine . datastore import datastore_index <EOL> import yaml <EOL> AUTO_MARKER = '<STR_LIT>' <EOL> AUTO_COMMENT = '''<STR_LIT>''' <EOL> def GenerateIndexFromHistory ( query_history , <EOL> all_indexes = None , manual_indexes = None ) : <EOL> """<STR_LIT>""" <EOL> all_keys = datastore_index . IndexDefinitionsToKeys ( all_indexes ) <EOL> manual_keys = datastore_index . IndexDefinitionsToKeys ( manual_indexes ) <EOL> indexes = dict ( ( key , <NUM_LIT:0> ) for key in all_keys - manual_keys ) <EOL> for query , count in query_history . iteritems ( ) : <EOL> required , kind , ancestor , props , num_eq_filters = datastore_index . CompositeIndexForQuery ( query ) <EOL> if required : <EOL> key = ( kind , ancestor , props ) <EOL> if key not in manual_keys : <EOL> if key in indexes : <EOL> indexes [ key ] += count <EOL> else : <EOL> indexes [ key ] = count <EOL> res = [ ] <EOL> for ( kind , ancestor , props ) , count in sorted ( indexes . iteritems ( ) ) : <EOL> res . append ( '<STR_LIT>' ) <EOL> res . append ( datastore_index . IndexYamlForQuery ( kind , ancestor , props ) ) <EOL> res . append ( '<STR_LIT>' ) <EOL> return '<STR_LIT:\n>' . join ( res ) <EOL> class IndexYamlUpdater ( object ) : <EOL> """<STR_LIT>""" <EOL> index_yaml_is_manual = False <EOL> index_yaml_mtime = <NUM_LIT:0> <EOL> last_history_size = <NUM_LIT:0> <EOL> def __init__ ( self , root_path ) : <EOL> """<STR_LIT>""" <EOL> self . root_path = root_path <EOL> def UpdateIndexYaml ( self , openfile = open ) : <EOL> """<STR_LIT>""" <EOL> index_yaml_file = os . path . join ( self . root_path , '<STR_LIT>' ) <EOL> try : <EOL> index_yaml_mtime = os . path . getmtime ( index_yaml_file ) <EOL> except os . error : <EOL> index_yaml_mtime = None <EOL> index_yaml_changed = ( index_yaml_mtime != self . index_yaml_mtime ) <EOL> self . index_yaml_mtime = index_yaml_mtime <EOL> datastore_stub = apiproxy_stub_map . apiproxy . GetStub ( '<STR_LIT>' ) <EOL> query_history = datastore_stub . QueryHistory ( ) <EOL> history_changed = ( len ( query_history ) != self . last_history_size ) <EOL> self . last_history_size = len ( query_history ) <EOL> if not ( index_yaml_changed or history_changed ) : <EOL> logging . debug ( '<STR_LIT>' ) <EOL> return <EOL> if self . index_yaml_is_manual and not index_yaml_changed : <EOL> logging . debug ( '<STR_LIT>' ) <EOL> return <EOL> if index_yaml_mtime is None : <EOL> index_yaml_data = None <EOL> else : <EOL> try : <EOL> fh = open ( index_yaml_file , '<STR_LIT:r>' ) <EOL> except IOError : <EOL> index_yaml_data = None <EOL> else : <EOL> try : <EOL> index_yaml_data = fh . read ( ) <EOL> finally : <EOL> fh . close ( ) <EOL> self . index_yaml_is_manual = ( index_yaml_data is not None and <EOL> AUTO_MARKER not in index_yaml_data ) <EOL> if self . index_yaml_is_manual : <EOL> logging . info ( '<STR_LIT>' ) <EOL> return <EOL> if index_yaml_data is None : <EOL> all_indexes = None <EOL> else : <EOL> try : <EOL> all_indexes = datastore_index . ParseIndexDefinitions ( index_yaml_data ) <EOL> except yaml_errors . EventListenerError , e : <EOL> logging . error ( '<STR_LIT>' , index_yaml_file , e ) <EOL> return <EOL> except Exception , err : <EOL> logging . error ( '<STR_LIT>' , index_yaml_file , <EOL> err . __class__ . __module__ , err . __class__ . __name__ , err ) <EOL> return <EOL> if index_yaml_data is None : <EOL> manual_part , automatic_part = '<STR_LIT>' , '<STR_LIT>' <EOL> manual_indexes = None <EOL> else : <EOL> manual_part , automatic_part = index_yaml_data . split ( AUTO_MARKER , <NUM_LIT:1> ) <EOL> try : <EOL> manual_indexes = datastore_index . ParseIndexDefinitions ( manual_part ) <EOL> except Exception , err : <EOL> logging . error ( '<STR_LIT>' , <EOL> index_yaml_file , err ) <EOL> return <EOL> automatic_part = GenerateIndexFromHistory ( query_history , <EOL> all_indexes , manual_indexes ) <EOL> try : <EOL> fh = openfile ( index_yaml_file , '<STR_LIT:w>' ) <EOL> except IOError , err : <EOL> logging . error ( '<STR_LIT>' , err ) <EOL> return <EOL> try : <EOL> logging . info ( '<STR_LIT>' , index_yaml_file ) <EOL> fh . write ( manual_part ) <EOL> fh . write ( AUTO_MARKER ) <EOL> fh . write ( AUTO_COMMENT ) <EOL> fh . write ( automatic_part ) <EOL> finally : <EOL> fh . close ( ) <EOL> try : <EOL> self . index_yaml_mtime = os . path . getmtime ( index_yaml_file ) <EOL> except os . error , err : <EOL> logging . error ( '<STR_LIT>' , err ) <EOL> self . index_yaml_mtime = None <EOL> def SetupIndexes ( app_id , root_path ) : <EOL> """<STR_LIT>""" <EOL> index_yaml_file = os . path . join ( root_path , '<STR_LIT>' ) <EOL> try : <EOL> fh = open ( index_yaml_file , '<STR_LIT:r>' ) <EOL> except IOError : <EOL> index_yaml_data = None <EOL> else : <EOL> try : <EOL> index_yaml_data = fh . read ( ) <EOL> finally : <EOL> fh . close ( ) <EOL> indexes = [ ] <EOL> if index_yaml_data is not None : <EOL> index_defs = datastore_index . ParseIndexDefinitions ( index_yaml_data ) <EOL> if index_defs is not None : <EOL> indexes = index_defs . indexes <EOL> if indexes is None : <EOL> indexes = [ ] <EOL> requested_indexes = datastore_index . IndexDefinitionsToProtos ( app_id , indexes ) <EOL> existing_indexes = datastore_admin . GetIndices ( app_id ) <EOL> requested = dict ( ( x . definition ( ) . Encode ( ) , x ) for x in requested_indexes ) <EOL> existing = dict ( ( x . definition ( ) . Encode ( ) , x ) for x in existing_indexes ) <EOL> created = <NUM_LIT:0> <EOL> for key , index in requested . iteritems ( ) : <EOL> if key not in existing : <EOL> datastore_admin . CreateIndex ( index ) <EOL> created += <NUM_LIT:1> <EOL> deleted = <NUM_LIT:0> <EOL> for key , index in existing . iteritems ( ) : <EOL> if key not in requested : <EOL> datastore_admin . DeleteIndex ( index ) <EOL> deleted += <NUM_LIT:1> <EOL> if created or deleted : <EOL> logging . info ( "<STR_LIT>" , <EOL> created , deleted , len ( requested ) ) </s>

<s> """<STR_LIT>""" <EOL> from django . db import models <EOL> class Empty ( models . Model ) : <EOL> pass <EOL> __test__ = { '<STR_LIT>' : """<STR_LIT>""" } </s>

<s> """<STR_LIT>""" <EOL> from django . db import models <EOL> class Thing ( models . Model ) : <EOL> when = models . CharField ( maxlength = <NUM_LIT:1> , primary_key = True ) <EOL> join = models . CharField ( maxlength = <NUM_LIT:1> ) <EOL> like = models . CharField ( maxlength = <NUM_LIT:1> ) <EOL> drop = models . CharField ( maxlength = <NUM_LIT:1> ) <EOL> alter = models . CharField ( maxlength = <NUM_LIT:1> ) <EOL> having = models . CharField ( maxlength = <NUM_LIT:1> ) <EOL> where = models . DateField ( maxlength = <NUM_LIT:1> ) <EOL> has_hyphen = models . CharField ( maxlength = <NUM_LIT:1> , db_column = '<STR_LIT>' ) <EOL> class Meta : <EOL> db_table = '<STR_LIT>' <EOL> def __str__ ( self ) : <EOL> return self . when <EOL> __test__ = { '<STR_LIT>' : """<STR_LIT>""" } </s>

<s> from django . template import Template , Context , add_to_builtins <EOL> import re <EOL> import unittest <EOL> add_to_builtins ( '<STR_LIT>' ) <EOL> class Templates ( unittest . TestCase ) : <EOL> def test_textile ( self ) : <EOL> try : <EOL> import textile <EOL> except ImportError : <EOL> textile = None <EOL> textile_content = """<STR_LIT>""" <EOL> t = Template ( "<STR_LIT>" ) <EOL> rendered = t . render ( Context ( locals ( ) ) ) . strip ( ) <EOL> if textile : <EOL> self . assertEqual ( rendered , """<STR_LIT>""" ) <EOL> else : <EOL> self . assertEqual ( rendered , textile_content ) <EOL> def test_markdown ( self ) : <EOL> try : <EOL> import markdown <EOL> except ImportError : <EOL> markdown = None <EOL> markdown_content = """<STR_LIT>""" <EOL> t = Template ( "<STR_LIT>" ) <EOL> rendered = t . render ( Context ( locals ( ) ) ) . strip ( ) <EOL> if markdown : <EOL> pattern = re . compile ( """<STR_LIT>""" ) <EOL> self . assert_ ( pattern . match ( rendered ) ) <EOL> else : <EOL> self . assertEqual ( rendered , markdown_content ) <EOL> def test_docutils ( self ) : <EOL> try : <EOL> import docutils <EOL> except ImportError : <EOL> docutils = None <EOL> rest_content = """<STR_LIT>""" <EOL> t = Template ( "<STR_LIT>" ) <EOL> rendered = t . render ( Context ( locals ( ) ) ) . strip ( ) <EOL> if docutils : <EOL> self . assertEqual ( rendered , """<STR_LIT>""" ) <EOL> else : <EOL> self . assertEqual ( rendered , rest_content ) <EOL> if __name__ == '<STR_LIT:__main__>' : <EOL> unittest . main ( ) </s>

<s> """<STR_LIT>""" <EOL> import logging <EOL> import os <EOL> import re <EOL> import sys <EOL> import unittest <EOL> import zipfile <EOL> DIR_PATH = os . path . abspath ( os . path . dirname ( __file__ ) ) <EOL> PARENT_DIR = os . path . dirname ( DIR_PATH ) <EOL> if PARENT_DIR . endswith ( "<STR_LIT>" ) : <EOL> PARENT_DIR = os . path . dirname ( PARENT_DIR ) <EOL> sys . path = [ PARENT_DIR , ] + sys . path <EOL> have_django_zip = False <EOL> django_zip_path = os . path . join ( PARENT_DIR , '<STR_LIT>' ) <EOL> appid = None <EOL> have_appserver = False <EOL> __all__ = ( "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" , <EOL> "<STR_LIT>" , "<STR_LIT>" ) <EOL> INCOMPATIBLE_COMMANDS = [ "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" , <EOL> "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" ] <EOL> def FixPython26Logging ( ) : <EOL> import logging <EOL> logging . logMultiprocessing = <NUM_LIT:0> <EOL> def LoadSdk ( ) : <EOL> try : <EOL> from google . appengine . api import apiproxy_stub_map <EOL> except ImportError , e : <EOL> paths = [ os . path . join ( PARENT_DIR , '<STR_LIT>' ) , <EOL> os . path . join ( PARENT_DIR , '<STR_LIT>' ) , <EOL> '<STR_LIT>' ] <EOL> for path in os . environ . get ( '<STR_LIT>' , '<STR_LIT>' ) . split ( '<STR_LIT:;>' ) : <EOL> path = path . rstrip ( '<STR_LIT:\\>' ) <EOL> if path . endswith ( '<STR_LIT>' ) : <EOL> paths . append ( path ) <EOL> try : <EOL> from win32com . shell import shell <EOL> from win32com . shell import shellcon <EOL> id_list = shell . SHGetSpecialFolderLocation ( <EOL> <NUM_LIT:0> , shellcon . CSIDL_PROGRAM_FILES ) <EOL> program_files = shell . SHGetPathFromIDList ( id_list ) <EOL> paths . append ( os . path . join ( program_files , '<STR_LIT>' , <EOL> '<STR_LIT>' ) ) <EOL> except ImportError , e : <EOL> pass <EOL> SDK_PATH = None <EOL> for sdk_path in paths : <EOL> if os . path . exists ( sdk_path ) : <EOL> SDK_PATH = os . path . realpath ( sdk_path ) <EOL> break <EOL> if SDK_PATH is None : <EOL> sys . stderr . write ( "<STR_LIT>" ) <EOL> sys . stderr . write ( "<STR_LIT>" ) <EOL> sys . exit ( <NUM_LIT:1> ) <EOL> if SDK_PATH == os . path . join ( PARENT_DIR , '<STR_LIT>' ) : <EOL> logging . warn ( '<STR_LIT>' <EOL> '<STR_LIT>' ) <EOL> logging . warn ( '<STR_LIT>' <EOL> '<STR_LIT>' ) <EOL> logging . warn ( '<STR_LIT>' ) <EOL> EXTRA_PATHS = [ <EOL> SDK_PATH , <EOL> os . path . join ( SDK_PATH , '<STR_LIT>' , '<STR_LIT>' ) , <EOL> os . path . join ( SDK_PATH , '<STR_LIT>' , '<STR_LIT>' ) , <EOL> os . path . join ( SDK_PATH , '<STR_LIT>' , '<STR_LIT>' ) , <EOL> os . path . join ( SDK_PATH , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ) , <EOL> ] <EOL> sys . path = sys . path [ <NUM_LIT:0> : <NUM_LIT:1> ] + EXTRA_PATHS + sys . path [ <NUM_LIT:1> : ] <EOL> def LoadDjango ( version = None ) : <EOL> global have_django_zip <EOL> from google . appengine . dist import use_library <EOL> from google . appengine . dist . _library import UnacceptableVersionError <EOL> os . environ [ '<STR_LIT>' ] = '<STR_LIT>' <EOL> if version : <EOL> use_library ( '<STR_LIT>' , version ) <EOL> return <EOL> if os . path . exists ( django_zip_path ) : <EOL> have_django_zip = True <EOL> sys . path . insert ( <NUM_LIT:1> , django_zip_path ) <EOL> if have_django_zip or os . path . exists ( os . path . join ( PARENT_DIR , '<STR_LIT>' ) ) : <EOL> for k in [ k for k in sys . modules if k . startswith ( '<STR_LIT>' ) ] : <EOL> del sys . modules [ k ] <EOL> return <EOL> for check_version in ( '<STR_LIT>' , '<STR_LIT:1.0>' ) : <EOL> try : <EOL> use_library ( '<STR_LIT>' , check_version ) <EOL> return <EOL> except UnacceptableVersionError : <EOL> pass <EOL> raise UnacceptableVersionError ( ) <EOL> def LoadAppengineEnvironment ( ) : <EOL> """<STR_LIT>""" <EOL> global appid , have_appserver <EOL> from google . appengine . api import yaml_errors <EOL> from google . appengine . api import apiproxy_stub_map <EOL> have_appserver = False <EOL> stub = apiproxy_stub_map . apiproxy . GetStub ( "<STR_LIT>" ) <EOL> if stub : <EOL> have_appserver = True <EOL> if have_appserver : <EOL> appid = os . environ . get ( "<STR_LIT>" , "<STR_LIT>" ) <EOL> else : <EOL> try : <EOL> from google . appengine . tools import dev_appserver <EOL> appconfig , unused_matcher = dev_appserver . LoadAppConfig ( PARENT_DIR , { } ) <EOL> appid = appconfig . application <EOL> except ( ImportError , yaml_errors . EventListenerYAMLError ) , e : <EOL> logging . warn ( "<STR_LIT>" <EOL> "<STR_LIT>" ) <EOL> appid = "<STR_LIT>" <EOL> logging . debug ( "<STR_LIT>" % <EOL> ( appid , have_appserver and "<STR_LIT>" or "<STR_LIT>" ) ) <EOL> def InstallAppengineDatabaseBackend ( ) : <EOL> """<STR_LIT>""" <EOL> from appengine_django import db <EOL> sys . modules [ '<STR_LIT>' ] = db <EOL> logging . debug ( "<STR_LIT>" ) <EOL> def InstallGoogleMemcache ( ) : <EOL> """<STR_LIT>""" <EOL> from google . appengine . api import memcache <EOL> sys . modules [ '<STR_LIT>' ] = memcache <EOL> logging . debug ( "<STR_LIT>" ) <EOL> def InstallDjangoModuleReplacements ( ) : <EOL> """<STR_LIT>""" <EOL> try : <EOL> from django . contrib import sessions <EOL> orig_path = sessions . __path__ [ <NUM_LIT:0> ] <EOL> sessions . __path__ . insert ( <NUM_LIT:0> , os . path . join ( DIR_PATH , '<STR_LIT>' ) ) <EOL> from django . contrib . sessions import backends <EOL> backends . __path__ . append ( os . path . join ( orig_path , '<STR_LIT>' ) ) <EOL> except ImportError : <EOL> logging . debug ( "<STR_LIT>" ) <EOL> import django . core . signals <EOL> import django . db <EOL> import django . dispatch . dispatcher <EOL> try : <EOL> from django . dispatch import errors <EOL> CheckedException = errors . DispatcherKeyError <EOL> def _disconnectSignal ( ) : <EOL> django . dispatch . dispatcher . disconnc ( <EOL> django . db . _rollback_on_exception , <EOL> django . core . signals . got_request_exception ) <EOL> except ImportError : <EOL> CheckedException = KeyError <EOL> def _disconnectSignal ( ) : <EOL> django . core . signals . got_request_exception . disconnect ( <EOL> django . db . _rollback_on_exception ) <EOL> try : <EOL> _disconnectSignal ( ) <EOL> except CheckedException , e : <EOL> logging . debug ( "<STR_LIT>" ) <EOL> def PatchDjangoSerializationModules ( settings ) : <EOL> """<STR_LIT>""" <EOL> from django . core . serializers import python <EOL> from appengine_django . serializer . python import Deserializer <EOL> if not hasattr ( settings , "<STR_LIT>" ) : <EOL> settings . SERIALIZATION_MODULES = { } <EOL> base_module = "<STR_LIT>" <EOL> settings . SERIALIZATION_MODULES [ "<STR_LIT>" ] = "<STR_LIT>" % base_module <EOL> python . Deserializer = Deserializer <EOL> PatchDeserializedObjectClass ( ) <EOL> DisableModelValidation ( ) <EOL> logging . debug ( "<STR_LIT>" ) <EOL> def PatchDeserializedObjectClass ( ) : <EOL> """<STR_LIT>""" <EOL> from django . core . serializers import base <EOL> class NewDeserializedObject ( base . DeserializedObject ) : <EOL> def save ( self , save_m2m = True ) : <EOL> self . object . save ( ) <EOL> self . object . _parent = None <EOL> base . DeserializedObject = NewDeserializedObject <EOL> logging . debug ( "<STR_LIT>" ) <EOL> def DisableModelValidation ( ) : <EOL> """<STR_LIT>""" <EOL> from django . core . management import validation <EOL> validation . get_validation_errors = lambda x , y = <NUM_LIT:0> : <NUM_LIT:0> <EOL> logging . debug ( "<STR_LIT>" ) <EOL> def CleanupDjangoSettings ( settings ) : <EOL> """<STR_LIT>""" <EOL> apps = getattr ( settings , "<STR_LIT>" , ( ) ) <EOL> found = False <EOL> for app in apps : <EOL> if app . endswith ( "<STR_LIT>" ) : <EOL> found = True <EOL> break <EOL> if not found : <EOL> logging . warn ( "<STR_LIT>" ) <EOL> apps += ( "<STR_LIT>" , ) <EOL> setattr ( settings , "<STR_LIT>" , apps ) <EOL> logging . info ( "<STR_LIT>" ) <EOL> dbe = getattr ( settings , "<STR_LIT>" , "<STR_LIT>" ) <EOL> if dbe != "<STR_LIT>" : <EOL> settings . DATABASE_ENGINE = "<STR_LIT>" <EOL> logging . warn ( "<STR_LIT>" <EOL> "<STR_LIT>" ) <EOL> for var in [ "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" ] : <EOL> val = getattr ( settings , "<STR_LIT>" % var , "<STR_LIT>" ) <EOL> if val : <EOL> setattr ( settings , "<STR_LIT>" % var , "<STR_LIT>" ) <EOL> logging . warn ( "<STR_LIT>" ) <EOL> mw_mods = list ( getattr ( settings , "<STR_LIT>" , ( ) ) ) <EOL> disallowed_middleware_mods = ( <EOL> '<STR_LIT>' , ) <EOL> for modname in mw_mods [ : ] : <EOL> if modname in disallowed_middleware_mods : <EOL> mw_mods . remove ( modname ) <EOL> logging . warn ( "<STR_LIT>" % <EOL> modname ) <EOL> setattr ( settings , "<STR_LIT>" , tuple ( mw_mods ) ) <EOL> app_mods = list ( getattr ( settings , "<STR_LIT>" , ( ) ) ) <EOL> disallowed_apps = ( <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , ) <EOL> for app in app_mods [ : ] : <EOL> if app in disallowed_apps : <EOL> app_mods . remove ( app ) <EOL> logging . warn ( "<STR_LIT>" % app ) <EOL> setattr ( settings , "<STR_LIT>" , tuple ( app_mods ) ) <EOL> session_backend = getattr ( settings , "<STR_LIT>" , "<STR_LIT>" ) <EOL> if session_backend . endswith ( "<STR_LIT:file>" ) : <EOL> logging . warn ( "<STR_LIT>" <EOL> "<STR_LIT>" ) <EOL> setattr ( settings , "<STR_LIT>" , "<STR_LIT>" ) <EOL> def ModifyAvailableCommands ( ) : <EOL> """<STR_LIT>""" <EOL> if have_appserver : <EOL> return <EOL> from django . core import management <EOL> project_directory = os . path . join ( __path__ [ <NUM_LIT:0> ] , "<STR_LIT>" ) <EOL> if have_django_zip : <EOL> FindCommandsInZipfile . orig = management . find_commands <EOL> management . find_commands = FindCommandsInZipfile <EOL> management . get_commands ( ) <EOL> from appengine_django . management . commands . startapp import ProjectCommand <EOL> management . _commands [ '<STR_LIT>' ] = ProjectCommand ( project_directory ) <EOL> RemoveCommands ( management . _commands ) <EOL> logging . debug ( "<STR_LIT>" ) <EOL> def FindCommandsInZipfile ( management_dir ) : <EOL> """<STR_LIT>""" <EOL> zip_marker = "<STR_LIT>" % os . sep <EOL> if zip_marker not in management_dir : <EOL> return FindCommandsInZipfile . orig ( management_dir ) <EOL> filename , path = management_dir . split ( zip_marker ) <EOL> zipinfo = zipfile . ZipFile ( "<STR_LIT>" % filename ) <EOL> path = os . path . join ( path , "<STR_LIT>" ) <EOL> path_normalise = re . compile ( r"<STR_LIT>" ) <EOL> path = path_normalise . sub ( "<STR_LIT:#>" , path ) <EOL> def _IsCmd ( t ) : <EOL> """<STR_LIT>""" <EOL> filename = os . path . basename ( t ) <EOL> t = path_normalise . sub ( "<STR_LIT:#>" , t ) <EOL> if not t . startswith ( path ) : <EOL> return False <EOL> if filename . startswith ( "<STR_LIT:_>" ) or not t . endswith ( "<STR_LIT>" ) : <EOL> return False <EOL> return True <EOL> return [ os . path . basename ( f ) [ : - <NUM_LIT:3> ] for f in zipinfo . namelist ( ) if _IsCmd ( f ) ] <EOL> def RemoveCommands ( command_dict ) : <EOL> """<STR_LIT>""" <EOL> for cmd in command_dict . keys ( ) : <EOL> if cmd . startswith ( "<STR_LIT>" ) : <EOL> del command_dict [ cmd ] <EOL> elif cmd in INCOMPATIBLE_COMMANDS : <EOL> del command_dict [ cmd ] <EOL> def InstallReplacementImpModule ( ) : <EOL> """<STR_LIT>""" <EOL> if not have_appserver : <EOL> return <EOL> modname = '<STR_LIT>' <EOL> imp_mod = __import__ ( modname , { } , [ ] , [ '<STR_LIT>' ] ) <EOL> sys . modules [ '<STR_LIT>' ] = imp_mod <EOL> logging . debug ( "<STR_LIT>" ) <EOL> def InstallReplacementThreadingModule ( ) : <EOL> """<STR_LIT>""" <EOL> try : <EOL> from django . utils . _threading_local import local <EOL> import threading <EOL> threading . local = local <EOL> except ImportError : <EOL> pass <EOL> logging . debug ( "<STR_LIT>" ) <EOL> def InstallAppengineHelperForDjango ( version = None ) : <EOL> """<STR_LIT>""" <EOL> FixPython26Logging ( ) <EOL> LoadSdk ( ) <EOL> LoadDjango ( version ) <EOL> from django import VERSION <EOL> from django . conf import settings <EOL> os . environ [ '<STR_LIT>' ] = '<STR_LIT>' <EOL> if VERSION < ( <NUM_LIT:1> , <NUM_LIT:0> , None ) : <EOL> logging . error ( "<STR_LIT>" ) <EOL> sys . exit ( <NUM_LIT:1> ) <EOL> if os . getenv ( "<STR_LIT>" ) : <EOL> logging . getLogger ( ) . setLevel ( logging . DEBUG ) <EOL> else : <EOL> logging . getLogger ( ) . setLevel ( logging . INFO ) <EOL> logging . debug ( "<STR_LIT>" ) <EOL> settings . _target = None <EOL> LoadAppengineEnvironment ( ) <EOL> InstallReplacementImpModule ( ) <EOL> InstallReplacementThreadingModule ( ) <EOL> InstallAppengineDatabaseBackend ( ) <EOL> InstallModelForm ( ) <EOL> InstallGoogleMemcache ( ) <EOL> InstallDjangoModuleReplacements ( ) <EOL> PatchDjangoSerializationModules ( settings ) <EOL> CleanupDjangoSettings ( settings ) <EOL> ModifyAvailableCommands ( ) <EOL> InstallGoogleSMTPConnection ( ) <EOL> InstallAuthentication ( settings ) <EOL> logging . debug ( "<STR_LIT>" ) <EOL> def InstallGoogleSMTPConnection ( ) : <EOL> from appengine_django import mail as gmail <EOL> from django . core import mail <EOL> logging . debug ( "<STR_LIT>" ) <EOL> mail . SMTPConnection = gmail . GoogleSMTPConnection <EOL> mail . mail_admins = gmail . mail_admins <EOL> mail . mail_managers = gmail . mail_managers <EOL> def InstallAuthentication ( settings ) : <EOL> if "<STR_LIT>" not in settings . INSTALLED_APPS : <EOL> return <EOL> try : <EOL> from appengine_django . auth import models as helper_models <EOL> from django . contrib . auth import models <EOL> models . User = helper_models . User <EOL> models . Group = helper_models . Group <EOL> models . Permission = helper_models . Permission <EOL> models . Message = helper_models . Message <EOL> from django . contrib . auth import middleware as django_middleware <EOL> from appengine_django . auth . middleware import AuthenticationMiddleware <EOL> django_middleware . AuthenticationMiddleware = AuthenticationMiddleware <EOL> from django . contrib . auth import decorators as django_decorators <EOL> from appengine_django . auth . decorators import login_required <EOL> django_decorators . login_required = login_required <EOL> from django . contrib import auth as django_auth <EOL> from django . contrib . auth import tests as django_tests <EOL> django_auth . suite = unittest . TestSuite <EOL> django_tests . suite = unittest . TestSuite <EOL> logging . debug ( "<STR_LIT>" ) <EOL> except ImportError : <EOL> logging . debug ( "<STR_LIT>" ) <EOL> def InstallModelForm ( ) : <EOL> """<STR_LIT>""" <EOL> from google . appengine . ext . db import djangoforms as aeforms <EOL> try : <EOL> from django import newforms as forms <EOL> except ImportError : <EOL> from django import forms <EOL> forms . ModelForm = aeforms . ModelForm <EOL> from google . appengine . ext . db import EmailProperty <EOL> def get_form_field ( self , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> defaults = { '<STR_LIT>' : forms . EmailField } <EOL> defaults . update ( kwargs ) <EOL> return super ( EmailProperty , self ) . get_form_field ( ** defaults ) <EOL> EmailProperty . get_form_field = get_form_field </s>

<s> """<STR_LIT>""" <EOL> import os <EOL> import re <EOL> import signal <EOL> import subprocess <EOL> import tempfile <EOL> import time <EOL> import unittest <EOL> from django . db . models import get_models <EOL> from google . appengine . ext import db <EOL> from appengine_django . models import BaseModel <EOL> from appengine_django . models import ModelManager <EOL> from appengine_django . models import ModelOptions <EOL> from appengine_django . models import RegistrationTestModel <EOL> class CommandsTest ( unittest . TestCase ) : <EOL> """<STR_LIT>""" <EOL> COMMAND_TIMEOUT = <NUM_LIT:10> <EOL> def runCommand ( self , command , args = None , int_after = None , input = None ) : <EOL> """<STR_LIT>""" <EOL> if not args : <EOL> args = [ ] <EOL> start = time . time ( ) <EOL> int_sent = False <EOL> fd = subprocess . PIPE <EOL> child = subprocess . Popen ( [ "<STR_LIT>" , command ] + args , stdin = fd , <EOL> stdout = fd , stderr = fd , cwd = os . getcwdu ( ) ) <EOL> if input : <EOL> child . stdin . write ( input ) <EOL> child . stdin . close ( ) <EOL> while <NUM_LIT:1> : <EOL> rc = child . poll ( ) <EOL> if rc is not None : <EOL> break <EOL> elapsed = time . time ( ) - start <EOL> if int_after and int_after > <NUM_LIT:0> and elapsed > int_after and not int_sent : <EOL> os . kill ( child . pid , signal . SIGINT ) <EOL> start = time . time ( ) <EOL> int_sent = True <EOL> continue <EOL> if elapsed < self . COMMAND_TIMEOUT : <EOL> continue <EOL> os . kill ( child . pid , signal . SIGKILL ) <EOL> time . sleep ( <NUM_LIT:2> ) <EOL> break <EOL> return rc , child . stdout . read ( ) , child . stderr . read ( ) <EOL> def assertCommandSucceeds ( self , command , * args , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> rc , stdout , stderr = self . runCommand ( command , * args , ** kwargs ) <EOL> fd , tempname = tempfile . mkstemp ( ) <EOL> os . write ( fd , stdout ) <EOL> os . close ( fd ) <EOL> self . assertEquals ( <NUM_LIT:0> , rc , <EOL> "<STR_LIT>" % <EOL> ( command , rc , tempname ) ) <EOL> os . unlink ( tempname ) <EOL> def getCommands ( self ) : <EOL> """<STR_LIT>""" <EOL> rc , stdout , stderr = self . runCommand ( "<STR_LIT>" ) <EOL> parts = re . split ( "<STR_LIT>" , stderr ) <EOL> if len ( parts ) < <NUM_LIT:2> : <EOL> return [ ] <EOL> return [ t . strip ( ) for t in parts [ - <NUM_LIT:1> ] . split ( "<STR_LIT:\n>" ) if t . strip ( ) ] <EOL> def testDiffSettings ( self ) : <EOL> """<STR_LIT>""" <EOL> self . assertCommandSucceeds ( "<STR_LIT>" ) <EOL> def testDumpData ( self ) : <EOL> """<STR_LIT>""" <EOL> self . assertCommandSucceeds ( "<STR_LIT>" ) <EOL> def testFlush ( self ) : <EOL> """<STR_LIT>""" <EOL> self . assertCommandSucceeds ( "<STR_LIT>" ) <EOL> def testLoadData ( self ) : <EOL> """<STR_LIT>""" <EOL> self . assertCommandSucceeds ( "<STR_LIT>" ) <EOL> def testLoadData ( self ) : <EOL> """<STR_LIT>""" <EOL> self . assertCommandSucceeds ( "<STR_LIT>" ) <EOL> def testReset ( self ) : <EOL> """<STR_LIT>""" <EOL> self . assertCommandSucceeds ( "<STR_LIT>" , [ "<STR_LIT>" ] ) <EOL> def testRunserver ( self ) : <EOL> """<STR_LIT>""" <EOL> self . assertCommandSucceeds ( "<STR_LIT>" , int_after = <NUM_LIT> ) <EOL> def testShell ( self ) : <EOL> """<STR_LIT>""" <EOL> self . assertCommandSucceeds ( "<STR_LIT>" , input = "<STR_LIT>" ) <EOL> def testUpdate ( self ) : <EOL> """<STR_LIT>""" <EOL> cmd_list = self . getCommands ( ) <EOL> self . assert_ ( "<STR_LIT>" in cmd_list ) <EOL> def testZipCommandListFiltersCorrectly ( self ) : <EOL> """<STR_LIT>""" <EOL> cmd_list = self . getCommands ( ) <EOL> self . assert_ ( "<STR_LIT>" not in cmd_list ) <EOL> self . assert_ ( "<STR_LIT>" not in cmd_list ) </s>

<s> import logging <EOL> import re <EOL> import urlparse <EOL> from django . conf import settings <EOL> from cleanliness import cleaner <EOL> from cleanliness import encoding <EOL> from common import exception <EOL> from common import display <EOL> NICK_MIN_LENGTH = <NUM_LIT:2> <EOL> NICK_MAX_LENGTH = <NUM_LIT> <EOL> RE_NS_DOMAIN = settings . NS_DOMAIN . replace ( '<STR_LIT:.>' , r'<STR_LIT>' ) <EOL> USER_RE = ( <EOL> r'<STR_LIT>' % ( NICK_MIN_LENGTH , <EOL> NICK_MAX_LENGTH , <EOL> RE_NS_DOMAIN ) <EOL> ) <EOL> USERNAME_ALIAS_RE = ( <EOL> r'<STR_LIT>' % ( NICK_MIN_LENGTH , NICK_MAX_LENGTH ) <EOL> ) <EOL> USER_COMPILED = re . compile ( USER_RE ) <EOL> USERNAME_ALIAS_COMPILED = re . compile ( USERNAME_ALIAS_RE ) <EOL> BG_COLOR_RE = '<STR_LIT>' <EOL> BG_COLOR_COMPILED = re . compile ( BG_COLOR_RE ) <EOL> def bg_color ( value , message = '<STR_LIT>' ) : <EOL> if not value : <EOL> return value <EOL> if not BG_COLOR_COMPILED . match ( value ) : <EOL> raise exception . ValidationError ( message ) <EOL> return value <EOL> def bg_repeat ( value ) : <EOL> """<STR_LIT>""" <EOL> if value == '<STR_LIT>' : <EOL> return value <EOL> return '<STR_LIT>' <EOL> BG_IMAGE_RE = '<STR_LIT>' + USER_RE [ <NUM_LIT:1> : - <NUM_LIT:1> ] + r'<STR_LIT>' <EOL> BG_IMAGE_COMPILED = re . compile ( BG_IMAGE_RE ) <EOL> def bg_image ( value , message = '<STR_LIT>' ) : <EOL> """<STR_LIT>""" <EOL> if not value : <EOL> return value <EOL> if not BG_IMAGE_COMPILED . match ( value ) : <EOL> raise exception . ValidationError ( message ) <EOL> return value <EOL> def datetime ( value , message = '<STR_LIT>' ) : <EOL> return cleaner . datetime ( value , message ) <EOL> def nick ( value , message = '<STR_LIT>' ) : <EOL> """<STR_LIT>""" <EOL> value = encoding . smart_unicode ( value ) <EOL> try : <EOL> return user ( value , message = message ) <EOL> except exception . ValidationError : <EOL> return channel ( value , message = message ) <EOL> def normalize_nick ( value ) : <EOL> return nick ( value ) . lower ( ) <EOL> channel_re = re . compile ( <EOL> r'<STR_LIT>' % ( NICK_MIN_LENGTH , <EOL> NICK_MAX_LENGTH , <EOL> RE_NS_DOMAIN ) <EOL> ) <EOL> def channel ( value , message = '<STR_LIT>' ) : <EOL> """<STR_LIT>""" <EOL> value = encoding . smart_unicode ( value ) <EOL> if not value . startswith ( '<STR_LIT:#>' ) : <EOL> value = '<STR_LIT>' % value <EOL> if not value . endswith ( '<STR_LIT>' % settings . NS_DOMAIN ) : <EOL> value = '<STR_LIT>' % ( value , settings . NS_DOMAIN ) <EOL> match = channel_re . match ( value ) <EOL> if not match : <EOL> logging . info ( "<STR_LIT>" % value ) <EOL> raise exception . ValidationError ( message ) <EOL> return value <EOL> def alias_username ( value , message = '<STR_LIT>' ) : <EOL> """<STR_LIT>""" <EOL> match = USERNAME_ALIAS_COMPILED . match ( value ) <EOL> if not match : <EOL> raise exception . ValidationError ( message ) <EOL> return value <EOL> def oauth_type ( value , message = '<STR_LIT>' ) : <EOL> if value not in [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] : <EOL> raise exception . ValidationError ( message ) <EOL> return value <EOL> def user ( value , message = '<STR_LIT>' ) : <EOL> """<STR_LIT>""" <EOL> value = encoding . smart_unicode ( value ) <EOL> if not value . endswith ( '<STR_LIT>' % settings . NS_DOMAIN ) : <EOL> value = '<STR_LIT>' % ( value , settings . NS_DOMAIN ) <EOL> match = USER_COMPILED . match ( value ) <EOL> if not match : <EOL> raise exception . ValidationError ( message ) <EOL> return value <EOL> def icon ( value ) : <EOL> """<STR_LIT>""" <EOL> if str ( value ) in display . ICONS_BY_ID : <EOL> return str ( value ) <EOL> return display . ICONS . get ( str ( value ) , ( <NUM_LIT:0> , ) ) [ <NUM_LIT:0> ] <EOL> MOBILE_RE = '<STR_LIT>' <EOL> MOBILE_RE_COMPILED = re . compile ( MOBILE_RE ) <EOL> def mobile ( value ) : <EOL> if not value . startswith ( '<STR_LIT:+>' ) : <EOL> value = '<STR_LIT>' % value <EOL> match = MOBILE_RE_COMPILED . match ( value ) <EOL> if not match : <EOL> raise exception . ValidationError ( '<STR_LIT>' ) <EOL> return value <EOL> URL_RE = cleaner . url_re <EOL> def url ( value , message = '<STR_LIT>' ) : <EOL> if value and '<STR_LIT>' not in value : <EOL> value = u'<STR_LIT>' % value <EOL> if value and not urlparse . urlsplit ( value ) [ <NUM_LIT:2> ] : <EOL> value += '<STR_LIT:/>' <EOL> match = URL_RE . match ( value ) <EOL> if not match : <EOL> raise exception . ValidationError ( message ) <EOL> return value <EOL> def limit ( value , max = <NUM_LIT:100> ) : <EOL> try : <EOL> value = int ( value ) <EOL> except : <EOL> value = <NUM_LIT:100> <EOL> if value > max : <EOL> value = max <EOL> if value < <NUM_LIT:1> : <EOL> value = <NUM_LIT:1> <EOL> return value <EOL> def redirect_to ( value ) : <EOL> if not value . startswith ( '<STR_LIT:/>' ) and not value . startswith ( '<STR_LIT:http>' ) : <EOL> value = '<STR_LIT>' + value <EOL> if '<STR_LIT:\n>' in value or '<STR_LIT:\r>' in value : <EOL> return '<STR_LIT:/>' <EOL> scheme , netloc , path , params , query , fragment = urlparse . urlparse ( <EOL> value . lower ( ) ) <EOL> if not scheme and not netloc and path : <EOL> return value <EOL> elif scheme in ( '<STR_LIT:http>' , '<STR_LIT>' ) : <EOL> if ( netloc . endswith ( settings . HOSTED_DOMAIN ) or <EOL> netloc . endswith ( settings . GAE_DOMAIN ) ) : <EOL> if netloc . find ( '<STR_LIT:/>' ) == - <NUM_LIT:1> : <EOL> return value <EOL> return '<STR_LIT:/>' </s>

<s> from common import exception <EOL> class Connection ( object ) : <EOL> pass <EOL> class Service ( object ) : <EOL> connection = None <EOL> handlers = None <EOL> _handlers = None <EOL> def __init__ ( self , connection ) : <EOL> self . connection = connection <EOL> self . _handlers = [ ] <EOL> def init_handlers ( self ) : <EOL> if not self . handlers : <EOL> return <EOL> for handler_class in self . handlers : <EOL> self . _handlers . append ( handler_class ( self ) ) <EOL> def handle_message ( self , sender , target , message ) : <EOL> matched = None <EOL> handler = None <EOL> for h in self . _handlers : <EOL> matched = h . match ( sender , message ) <EOL> if matched : <EOL> handler = h <EOL> break <EOL> if not matched : <EOL> rv = self . unknown ( sender , message ) <EOL> return self . response_ok ( rv ) <EOL> try : <EOL> rv = handler . handle ( sender , matched , message ) <EOL> return self . response_ok ( rv ) <EOL> except exception . UserVisibleError , e : <EOL> exception . log_exception ( ) <EOL> self . send_message ( [ sender ] , str ( e ) ) <EOL> return self . response_error ( e ) <EOL> except exception . Error : <EOL> exception . log_exception ( ) </s>

<s> import datetime <EOL> import logging <EOL> import simplejson <EOL> from oauth import oauth <EOL> from django . conf import settings <EOL> from django . core import mail <EOL> from common import api <EOL> from common import exception <EOL> from common import mail as common_mail <EOL> from common import models <EOL> from common import oauth_util <EOL> from common import profile <EOL> from common . test import base <EOL> from common . test import util as test_util <EOL> class QueueTest ( base . FixturesTestCase ) : <EOL> def setUp ( self ) : <EOL> self . old_utcnow = test_util . utcnow <EOL> self . now = test_util . utcnow ( ) <EOL> self . delta = datetime . timedelta ( seconds = api . DEFAULT_TASK_EXPIRE ) <EOL> self . old_enabled = settings . QUEUE_ENABLED <EOL> super ( QueueTest , self ) . setUp ( ) <EOL> settings . QUEUE_ENABLED = True <EOL> def tearDown ( self ) : <EOL> test_util . utcnow = self . old_utcnow <EOL> super ( QueueTest , self ) . tearDown ( ) <EOL> settings . QUEUE_ENABLED = self . old_enabled <EOL> def test_task_crud ( self ) : <EOL> nick = '<STR_LIT>' <EOL> action = '<STR_LIT>' <EOL> uuid = '<STR_LIT>' <EOL> message = '<STR_LIT>' <EOL> actor_ref = api . actor_get ( api . ROOT , nick ) <EOL> test_util . utcnow = lambda : self . now <EOL> l = profile . label ( '<STR_LIT>' ) <EOL> task_ref = api . task_create ( actor_ref , <EOL> nick , <EOL> action , <EOL> uuid , <EOL> args = [ ] , <EOL> kw = { '<STR_LIT>' : nick , <EOL> '<STR_LIT:message>' : message , <EOL> '<STR_LIT>' : uuid <EOL> } <EOL> ) <EOL> l . stop ( ) <EOL> l = profile . label ( '<STR_LIT>' ) <EOL> task_ref = api . task_get ( actor_ref , nick , action , uuid ) <EOL> l . stop ( ) <EOL> def _again ( ) : <EOL> task_ref = api . task_get ( actor_ref , nick , action , uuid ) <EOL> l = profile . label ( '<STR_LIT>' ) <EOL> self . assertRaises ( exception . ApiLocked , _again ) <EOL> l . stop ( ) <EOL> new_now = self . now + self . delta <EOL> test_util . utcnow = lambda : new_now <EOL> task_ref = api . task_get ( actor_ref , nick , action , uuid ) <EOL> self . assertRaises ( exception . ApiLocked , _again ) <EOL> l = profile . label ( '<STR_LIT>' ) <EOL> task_ref = api . task_update ( actor_ref , nick , action , uuid , '<STR_LIT:1>' ) <EOL> l . stop ( ) <EOL> self . assertEqual ( task_ref . progress , '<STR_LIT:1>' ) <EOL> task_ref = api . task_get ( actor_ref , nick , action , uuid ) <EOL> self . assertEqual ( task_ref . progress , '<STR_LIT:1>' ) <EOL> l = profile . label ( '<STR_LIT>' ) <EOL> api . task_remove ( actor_ref , nick , action , uuid ) <EOL> l . stop ( ) <EOL> def _not_found ( ) : <EOL> task_ref = api . task_get ( actor_ref , nick , action , uuid ) <EOL> self . assertRaises ( exception . ApiNotFound , _not_found ) <EOL> def test_task_post ( self ) : <EOL> """<STR_LIT>""" <EOL> nick = '<STR_LIT>' <EOL> uuid = '<STR_LIT>' <EOL> message = '<STR_LIT>' <EOL> actor_ref = api . actor_get ( api . ROOT , nick ) <EOL> old_max = api . MAX_FOLLOWERS_PER_INBOX <EOL> api . MAX_FOLLOWERS_PER_INBOX = <NUM_LIT:1> <EOL> try : <EOL> entry_ref = api . post ( actor_ref , nick = nick , uuid = uuid , message = message ) <EOL> self . assertEqual ( entry_ref . extra [ '<STR_LIT:title>' ] , message ) <EOL> two_entry_ref = api . post ( actor_ref , nick = nick , uuid = uuid , message = message ) <EOL> self . assertEqual ( entry_ref . uuid , two_entry_ref . uuid ) <EOL> for i in range ( <NUM_LIT:5> ) : <EOL> api . task_process_actor ( api . ROOT , nick ) <EOL> self . assertRaises ( exception . ApiNoTasks , <EOL> lambda : api . task_process_actor ( api . ROOT , nick ) ) <EOL> finally : <EOL> api . MAX_FOLLOWERS_PER_INBOX = old_max <EOL> def test_task_post_process_any ( self ) : <EOL> """<STR_LIT>""" <EOL> nick = '<STR_LIT>' <EOL> uuid = '<STR_LIT>' <EOL> message = '<STR_LIT>' <EOL> actor_ref = api . actor_get ( api . ROOT , nick ) <EOL> old_max = api . MAX_FOLLOWERS_PER_INBOX <EOL> api . MAX_FOLLOWERS_PER_INBOX = <NUM_LIT:1> <EOL> try : <EOL> entry_ref = api . post ( actor_ref , nick = nick , uuid = uuid , message = message ) <EOL> self . assertEqual ( entry_ref . extra [ '<STR_LIT:title>' ] , message ) <EOL> two_entry_ref = api . post ( actor_ref , nick = nick , uuid = uuid , message = message ) <EOL> self . assertEqual ( entry_ref . uuid , two_entry_ref . uuid ) <EOL> for i in range ( <NUM_LIT:5> ) : <EOL> api . task_process_any ( api . ROOT , nick ) <EOL> self . assertRaises ( exception . ApiNoTasks , <EOL> lambda : api . task_process_actor ( api . ROOT , nick ) ) <EOL> finally : <EOL> api . MAX_FOLLOWERS_PER_INBOX = old_max </s>