Datasets:

0n1xus
/

codexglue

Dataset card Viewer Files Files and versions Community

Subset (2)

code-completion-token-py150 · 150k rows

Split (3)

train · 95k rows

code stringlengths 9 256k
<s> import threading <EOL> from hazelcast . proxy . base import Proxy <EOL> from hazelcast . util import AtomicInteger <EOL> BLOCK_SIZE = <NUM_LIT> <EOL> class IdGenerator ( Proxy ) : <EOL> def __init__ ( self , client , service_name , name , atomic_long ) : <EOL> super ( IdGenerator , self ) . __init__ ( client , service_name , name ) <EOL> self . _atomic_long = atomic_long <EOL> self . _residue = BLOCK_SIZE <EOL> self . _local = - <NUM_LIT:1> <EOL> self . _lock = threading . RLock ( ) <EOL> def _on_destroy ( self ) : <EOL> self . _atomic_long . destroy ( ) <EOL> def init ( self , initial ) : <EOL> if id <= <NUM_LIT:0> : <EOL> return False <EOL> step = initial / BLOCK_SIZE <EOL> with self . _lock : <EOL> init = self . _atomic_long . compare_and_set ( <NUM_LIT:0> , step + <NUM_LIT:1> ) . result ( ) <EOL> if init : <EOL> self . _local = step <EOL> self . _residue = ( initial % BLOCK_SIZE ) + <NUM_LIT:1> <EOL> return init <EOL> def new_id ( self ) : <EOL> with self . _lock : <EOL> curr = self . _residue <EOL> self . _residue += <NUM_LIT:1> <EOL> if self . _residue >= BLOCK_SIZE : <EOL> increment = self . _atomic_long . get_and_increment ( ) . result ( ) <EOL> self . _local = increment <EOL> self . _residue = <NUM_LIT:0> <EOL> return self . new_id ( ) <EOL> return self . _local * BLOCK_SIZE + curr </s>
<s> from hazelcast . exception import HazelcastSerializationError <EOL> from hazelcast . serialization import bits <EOL> from hazelcast . serialization . api import PortableReader <EOL> from hazelcast . serialization . portable . classdef import FieldType <EOL> class DefaultPortableReader ( PortableReader ) : <EOL> def __init__ ( self , portable_serializer , data_input , class_def ) : <EOL> self . _portable_serializer = portable_serializer <EOL> self . _in = data_input <EOL> self . _class_def = class_def <EOL> try : <EOL> self . _final_pos = data_input . read_int ( ) <EOL> field_count = data_input . read_int ( ) <EOL> except Exception : <EOL> raise HazelcastSerializationError ( ) <EOL> if field_count != class_def . get_field_count ( ) : <EOL> raise ValueError ( "<STR_LIT>" . format ( field_count , class_def ) ) <EOL> self . _offset = data_input . position ( ) <EOL> self . _raw = False <EOL> def get_version ( self ) : <EOL> return self . _class_def . version <EOL> def has_field ( self , field_name ) : <EOL> return self . _class_def . has_field ( field_name ) <EOL> def get_field_names ( self ) : <EOL> return self . _class_def . get_field_names ( ) <EOL> def get_field_type ( self , field_name ) : <EOL> return self . _class_def . get_field_type ( field_name ) <EOL> def get_field_class_id ( self , field_name ) : <EOL> return self . _class_def . get_field_class_id ( field_name ) <EOL> def read_boolean ( self , field_name ) : <EOL> pos = self . _read_position ( field_name , FieldType . BOOLEAN ) <EOL> return self . _in . read_boolean ( pos ) <EOL> def read_byte ( self , field_name ) : <EOL> pos = self . _read_position ( field_name , FieldType . BYTE ) <EOL> return self . _in . read_byte ( pos ) <EOL> def read_char ( self , field_name ) : <EOL> pos = self . _read_position ( field_name , FieldType . CHAR ) <EOL> return self . _in . read_char ( pos ) <EOL> def read_short ( self , field_name ) : <EOL> pos = self . _read_position ( field_name , FieldType . SHORT ) <EOL> return self . _in . read_short ( pos ) <EOL> def read_int ( self , field_name ) : <EOL> pos = self . _read_position ( field_name , FieldType . INT ) <EOL> return self . _in . read_int ( pos ) <EOL> def read_long ( self , field_name ) : <EOL> pos = self . _read_position ( field_name , FieldType . LONG ) <EOL> return self . _in . read_long ( pos ) <EOL> def read_float ( self , field_name ) : <EOL> pos = self . _read_position ( field_name , FieldType . FLOAT ) <EOL> return self . _in . read_float ( pos ) <EOL> def read_double ( self , field_name ) : <EOL> pos = self . _read_position ( field_name , FieldType . DOUBLE ) <EOL> return self . _in . read_double ( pos ) <EOL> def read_utf ( self , field_name ) : <EOL> cur_pos = self . _in . position ( ) <EOL> try : <EOL> pos = self . _read_position ( field_name , FieldType . UTF ) <EOL> self . _in . set_position ( pos ) <EOL> return self . _in . read_utf ( ) <EOL> finally : <EOL> self . _in . set_position ( cur_pos ) <EOL> def read_portable ( self , field_name ) : <EOL> cur_pos = self . _in . position ( ) <EOL> try : <EOL> fd = self . _class_def . get_field ( field_name ) <EOL> if fd is None : <EOL> raise self . _create_unknown_field_exception ( field_name ) <EOL> if fd . field_type != FieldType . PORTABLE : <EOL> raise HazelcastSerializationError ( "<STR_LIT>" . format ( field_name ) ) <EOL> pos = self . _read_position_by_field_def ( fd ) <EOL> self . _in . set_position ( pos ) <EOL> is_none = self . _in . read_boolean ( ) <EOL> factory_id = self . _in . read_int ( ) <EOL> class_id = self . _in . read_int ( ) <EOL> _check_factory_and_class ( fd , factory_id , class_id ) <EOL> if is_none : <EOL> return None <EOL> return self . _portable_serializer . read_internal ( self . _in , factory_id , class_id ) <EOL> finally : <EOL> self . _in . set_position ( cur_pos ) <EOL> def read_boolean_array ( self , field_name ) : <EOL> current_pos = self . _in . position ( ) <EOL> try : <EOL> pos = self . _read_position ( field_name , FieldType . BOOLEAN_ARRAY ) <EOL> self . _in . set_position ( pos ) <EOL> return self . _in . read_boolean_array ( ) <EOL> finally : <EOL> self . _in . set_position ( current_pos ) <EOL> def read_byte_array ( self , field_name ) : <EOL> current_pos = self . _in . position ( ) <EOL> try : <EOL> pos = self . _read_position ( field_name , FieldType . BYTE_ARRAY ) <EOL> self . _in . set_position ( pos ) <EOL> return self . _in . read_byte_array ( ) <EOL> finally : <EOL> self . _in . set_position ( current_pos ) <EOL> def read_char_array ( self , field_name ) : <EOL> current_pos = self . _in . position ( ) <EOL> try : <EOL> pos = self . _read_position ( field_name , FieldType . CHAR_ARRAY ) <EOL> self . _in . set_position ( pos ) <EOL> return self . _in . read_char_array ( ) <EOL> finally : <EOL> self . _in . set_position ( current_pos ) <EOL> def read_short_array ( self , field_name ) : <EOL> pass <EOL> current_pos = self . _in . position ( ) <EOL> try : <EOL> pos = self . _read_position ( field_name , FieldType . SHORT_ARRAY ) <EOL> self . _in . set_position ( pos ) <EOL> return self . _in . read_short_array ( ) <EOL> finally : <EOL> self . _in . set_position ( current_pos ) <EOL> def read_int_array ( self , field_name ) : <EOL> current_pos = self . _in . position ( ) <EOL> try : <EOL> pos = self . _read_position ( field_name , FieldType . INT_ARRAY ) <EOL> self . _in . set_position ( pos ) <EOL> return self . _in . read_int_array ( ) <EOL> finally : <EOL> self . _in . set_position ( current_pos ) <EOL> def read_long_array ( self , field_name ) : <EOL> current_pos = self . _in . position ( ) <EOL> try : <EOL> pos = self . _read_position ( field_name , FieldType . LONG_ARRAY ) <EOL> self . _in . set_position ( pos ) <EOL> return self . _in . read_long_array ( ) <EOL> finally : <EOL> self . _in . set_position ( current_pos ) <EOL> def read_float_array ( self , field_name ) : <EOL> current_pos = self . _in . position ( ) <EOL> try : <EOL> pos = self . _read_position ( field_name , FieldType . FLOAT_ARRAY ) <EOL> self . _in . set_position ( pos ) <EOL> return self . _in . read_float_array ( ) <EOL> finally : <EOL> self . _in . set_position ( current_pos ) <EOL> def read_double_array ( self , field_name ) : <EOL> current_pos = self . _in . position ( ) <EOL> try : <EOL> pos = self . _read_position ( field_name , FieldType . DOUBLE_ARRAY ) <EOL> self . _in . set_position ( pos ) <EOL> return self . _in . read_double_array ( ) <EOL> finally : <EOL> self . _in . set_position ( current_pos ) <EOL> def read_utf_array ( self , field_name ) : <EOL> current_pos = self . _in . position ( ) <EOL> try : <EOL> pos = self . _read_position ( field_name , FieldType . UTF_ARRAY ) <EOL> self . _in . set_position ( pos ) <EOL> return self . _in . read_utf_array ( ) <EOL> finally : <EOL> self . _in . set_position ( current_pos ) <EOL> def read_portable_array ( self , field_name ) : <EOL> current_pos = self . _in . position ( ) <EOL> try : <EOL> fd = self . _class_def . get_field ( field_name ) <EOL> if fd is None : <EOL> raise self . _create_unknown_field_exception ( field_name ) <EOL> if fd . field_type != FieldType . PORTABLE_ARRAY : <EOL> raise HazelcastSerializationError ( "<STR_LIT>" . format ( field_name ) ) <EOL> pos = self . _read_position_by_field_def ( fd ) <EOL> self . _in . set_position ( pos ) <EOL> length = self . _in . read_int ( ) <EOL> factory_id = self . _in . read_int ( ) <EOL> class_id = self . _in . read_int ( ) <EOL> if length == bits . NULL_ARRAY_LENGTH : <EOL> return None <EOL> _check_factory_and_class ( fd , factory_id , class_id ) <EOL> portables = [ None ] * length <EOL> if length > <NUM_LIT:0> : <EOL> offset = self . _in . position ( ) <EOL> for i in xrange ( <NUM_LIT:0> , length ) : <EOL> start = self . _in . read_int ( offset + i * bits . INT_SIZE_IN_BYTES ) <EOL> self . _in . set_position ( start ) <EOL> portables [ i ] = self . _portable_serializer . read_internal ( self . _in , factory_id , class_id ) <EOL> return portables <EOL> finally : <EOL> self . _in . set_position ( current_pos ) <EOL> def get_raw_data_input ( self ) : <EOL> if not self . _raw : <EOL> pos = self . _in . read_int ( self . _offset + self . _class_def . get_field_count ( ) * bits . INT_SIZE_IN_BYTES ) <EOL> self . _in . set_position ( pos ) <EOL> self . _raw = True <EOL> return self . _in <EOL> def end ( self ) : <EOL> self . _in . set_position ( self . _final_pos ) <EOL> def _read_position ( self , field_name , field_type ) : <EOL> if self . _raw : <EOL> raise HazelcastSerializationError ( "<STR_LIT>" ) <EOL> fd = self . _class_def . get_field ( field_name ) <EOL> if fd is None : <EOL> return self . _read_nested_position ( field_name , field_type ) <EOL> if fd . field_type != field_type : <EOL> raise HazelcastSerializationError ( "<STR_LIT>" . format ( field_type , field_name ) ) <EOL> return self . _read_position_by_field_def ( fd ) <EOL> def _read_nested_position ( self , field_name , field_type ) : <EOL> field_names = field_name . split ( "<STR_LIT:.>" ) <EOL> if len ( field_names ) > <NUM_LIT:1> : <EOL> fd = None <EOL> _reader = self <EOL> for i in xrange ( <NUM_LIT:0> , len ( field_names ) ) : <EOL> fd = _reader . _class_def . get_field ( field_names [ i ] ) <EOL> if fd is None : <EOL> break <EOL> if i == len ( field_names ) - <NUM_LIT:1> : <EOL> break <EOL> pos = _reader . read_position ( fd ) <EOL> self . _in . set_position ( pos ) <EOL> is_none = self . _in . read_boolean ( ) <EOL> if is_none : <EOL> raise ValueError ( "<STR_LIT>" . format ( field_names [ i ] ) ) <EOL> _reader = self . _portable_serializer . create_reader ( self . _in ) <EOL> if fd is None : <EOL> raise self . _create_unknown_field_exception ( field_name ) <EOL> if fd . field_type != field_type : <EOL> raise HazelcastSerializationError ( "<STR_LIT>" . format ( field_type , field_name ) ) <EOL> return _reader . read_position ( fd ) <EOL> raise self . _create_unknown_field_exception ( field_name ) <EOL> def _create_unknown_field_exception ( self , field_name ) : <EOL> return HazelcastSerializationError ( "<STR_LIT>" <EOL> . format ( field_name , self . _class_def . class_id , self . _class_def . version ) ) <EOL> def _read_position_by_field_def ( self , fd ) : <EOL> pos = self . _in . read_int ( self . _offset + fd . index * bits . INT_SIZE_IN_BYTES ) <EOL> _len = self . _in . read_short ( pos ) <EOL> return pos + bits . SHORT_SIZE_IN_BYTES + _len + <NUM_LIT:1> <EOL> def _check_factory_and_class ( field_def , factory_id , class_id ) : <EOL> if factory_id != field_def . factory_id : <EOL> raise ValueError ( "<STR_LIT>" . format ( factory_id , field_def . factory_id ) ) <EOL> if class_id != field_def . class_id : <EOL> raise ValueError ( "<STR_LIT>" . format ( class_id , field_def . class_id ) ) <EOL> class MorphingPortableReader ( DefaultPortableReader ) : <EOL> pass </s>
<s> import time <EOL> from hazelcast . exception import HazelcastError , HazelcastSerializationError <EOL> from hazelcast . proxy . map import EntryEventType <EOL> from hazelcast . serialization . api import IdentifiedDataSerializable <EOL> from hazelcast . serialization . predicate import SqlPredicate <EOL> from tests . base import SingleMemberTestCase <EOL> from tests . util import random_string , event_collector <EOL> FACTORY_ID = <NUM_LIT:1> <EOL> class EntryProcessor ( IdentifiedDataSerializable ) : <EOL> CLASS_ID = <NUM_LIT:1> <EOL> def write_data ( self , object_data_output ) : <EOL> pass <EOL> def get_factory_id ( self ) : <EOL> return FACTORY_ID <EOL> def get_class_id ( self ) : <EOL> return self . CLASS_ID <EOL> class MapTest ( SingleMemberTestCase ) : <EOL> def setUp ( self ) : <EOL> self . map = self . client . get_map ( random_string ( ) ) . blocking ( ) <EOL> def tearDown ( self ) : <EOL> self . map . destroy ( ) <EOL> def test_add_entry_listener_item_added ( self ) : <EOL> collector = event_collector ( ) <EOL> self . map . add_entry_listener ( include_value = True , added = collector ) <EOL> self . map . put ( '<STR_LIT:key>' , '<STR_LIT:value>' ) <EOL> def assert_event ( ) : <EOL> self . assertEqual ( len ( collector . events ) , <NUM_LIT:1> ) <EOL> event = collector . events [ <NUM_LIT:0> ] <EOL> self . assertEntryEvent ( event , key = '<STR_LIT:key>' , event_type = EntryEventType . added , value = '<STR_LIT:value>' ) <EOL> self . assertTrueEventually ( assert_event , <NUM_LIT:5> ) <EOL> def test_add_entry_listener_item_removed ( self ) : <EOL> collector = event_collector ( ) <EOL> self . map . add_entry_listener ( include_value = True , removed = collector ) <EOL> self . map . put ( '<STR_LIT:key>' , '<STR_LIT:value>' ) <EOL> self . map . remove ( '<STR_LIT:key>' ) <EOL> def assert_event ( ) : <EOL> self . assertEqual ( len ( collector . events ) , <NUM_LIT:1> ) <EOL> event = collector . events [ <NUM_LIT:0> ] <EOL> self . assertEntryEvent ( event , key = '<STR_LIT:key>' , event_type = EntryEventType . removed , old_value = '<STR_LIT:value>' ) <EOL> self . assertTrueEventually ( assert_event , <NUM_LIT:5> ) <EOL> def test_add_entry_listener_item_updated ( self ) : <EOL> collector = event_collector ( ) <EOL> self . map . add_entry_listener ( include_value = True , updated = collector ) <EOL> self . map . put ( '<STR_LIT:key>' , '<STR_LIT:value>' ) <EOL> self . map . put ( '<STR_LIT:key>' , '<STR_LIT>' ) <EOL> def assert_event ( ) : <EOL> self . assertEqual ( len ( collector . events ) , <NUM_LIT:1> ) <EOL> event = collector . events [ <NUM_LIT:0> ] <EOL> self . assertEntryEvent ( event , key = '<STR_LIT:key>' , event_type = EntryEventType . updated , old_value = '<STR_LIT:value>' , <EOL> value = '<STR_LIT>' ) <EOL> self . assertTrueEventually ( assert_event , <NUM_LIT:5> ) <EOL> def test_add_entry_listener_item_expired ( self ) : <EOL> collector = event_collector ( ) <EOL> self . map . add_entry_listener ( include_value = True , expired = collector ) <EOL> self . map . put ( '<STR_LIT:key>' , '<STR_LIT:value>' , ttl = <NUM_LIT:0.1> ) <EOL> def assert_event ( ) : <EOL> self . assertEqual ( len ( collector . events ) , <NUM_LIT:1> ) <EOL> event = collector . events [ <NUM_LIT:0> ] <EOL> self . assertEntryEvent ( event , key = '<STR_LIT:key>' , event_type = EntryEventType . expired , old_value = '<STR_LIT:value>' ) <EOL> self . assertTrueEventually ( assert_event , <NUM_LIT:10> ) <EOL> def test_add_entry_listener_with_key ( self ) : <EOL> collector = event_collector ( ) <EOL> self . map . add_entry_listener ( key = '<STR_LIT>' , include_value = True , added = collector ) <EOL> self . map . put ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> self . map . put ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> def assert_event ( ) : <EOL> self . assertEqual ( len ( collector . events ) , <NUM_LIT:1> ) <EOL> event = collector . events [ <NUM_LIT:0> ] <EOL> self . assertEntryEvent ( event , key = '<STR_LIT>' , event_type = EntryEventType . added , value = '<STR_LIT>' ) <EOL> self . assertTrueEventually ( assert_event , <NUM_LIT:5> ) <EOL> def test_add_entry_listener_with_predicate ( self ) : <EOL> collector = event_collector ( ) <EOL> self . map . add_entry_listener ( predicate = SqlPredicate ( "<STR_LIT>" ) , include_value = True , added = collector ) <EOL> self . map . put ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> self . map . put ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> def assert_event ( ) : <EOL> self . assertEqual ( len ( collector . events ) , <NUM_LIT:1> ) <EOL> event = collector . events [ <NUM_LIT:0> ] <EOL> self . assertEntryEvent ( event , key = '<STR_LIT>' , event_type = EntryEventType . added , value = '<STR_LIT>' ) <EOL> self . assertTrueEventually ( assert_event , <NUM_LIT:5> ) <EOL> def test_add_entry_listener_with_key_and_predicate ( self ) : <EOL> collector = event_collector ( ) <EOL> self . map . add_entry_listener ( key = '<STR_LIT>' , predicate = SqlPredicate ( "<STR_LIT>" ) , include_value = True , added = collector ) <EOL> self . map . put ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> self . map . put ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> self . map . remove ( '<STR_LIT>' ) <EOL> self . map . put ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> def assert_event ( ) : <EOL> self . assertEqual ( len ( collector . events ) , <NUM_LIT:1> ) <EOL> event = collector . events [ <NUM_LIT:0> ] <EOL> self . assertEntryEvent ( event , key = '<STR_LIT>' , event_type = EntryEventType . added , value = '<STR_LIT>' ) <EOL> self . assertTrueEventually ( assert_event , <NUM_LIT:5> ) <EOL> def test_add_index ( self ) : <EOL> self . map . add_index ( "<STR_LIT>" , True ) <EOL> def test_clear ( self ) : <EOL> self . _fill_map ( ) <EOL> self . map . clear ( ) <EOL> self . assertEqual ( self . map . size ( ) , <NUM_LIT:0> ) <EOL> def test_contains_key ( self ) : <EOL> self . _fill_map ( ) <EOL> self . assertTrue ( self . map . contains_key ( "<STR_LIT>" ) ) <EOL> self . assertFalse ( self . map . contains_key ( "<STR_LIT>" ) ) <EOL> def test_contains_value ( self ) : <EOL> self . _fill_map ( ) <EOL> self . assertTrue ( self . map . contains_value ( "<STR_LIT>" ) ) <EOL> self . assertFalse ( self . map . contains_value ( "<STR_LIT>" ) ) <EOL> def test_delete ( self ) : <EOL> self . _fill_map ( ) <EOL> self . map . delete ( "<STR_LIT>" ) <EOL> self . assertEqual ( self . map . size ( ) , <NUM_LIT:9> ) <EOL> self . assertFalse ( self . map . contains_key ( "<STR_LIT>" ) ) <EOL> def test_entry_set ( self ) : <EOL> entries = self . _fill_map ( ) <EOL> self . assertItemsEqual ( self . map . entry_set ( ) , list ( entries . iteritems ( ) ) ) <EOL> def test_entry_set_with_predicate ( self ) : <EOL> self . _fill_map ( ) <EOL> self . assertEqual ( self . map . entry_set ( SqlPredicate ( "<STR_LIT>" ) ) , [ ( "<STR_LIT>" , "<STR_LIT>" ) ] ) <EOL> def test_evict ( self ) : <EOL> self . _fill_map ( ) <EOL> self . map . evict ( "<STR_LIT>" ) <EOL> self . assertEqual ( self . map . size ( ) , <NUM_LIT:9> ) <EOL> self . assertFalse ( self . map . contains_key ( "<STR_LIT>" ) ) <EOL> def test_evict_all ( self ) : <EOL> self . _fill_map ( ) <EOL> self . map . evict_all ( ) <EOL> self . assertEqual ( self . map . size ( ) , <NUM_LIT:0> ) <EOL> def test_execute_on_entries ( self ) : <EOL> with self . assertRaises ( HazelcastSerializationError ) : <EOL> self . map . execute_on_entries ( EntryProcessor ( ) ) <EOL> def test_execute_on_entries_with_predicate ( self ) : <EOL> with self . assertRaises ( HazelcastSerializationError ) : <EOL> self . map . execute_on_entries ( EntryProcessor ( ) , predicate = SqlPredicate ( ) ) <EOL> def test_execute_on_key ( self ) : <EOL> self . map . put ( "<STR_LIT:key>" , <NUM_LIT:1> ) <EOL> with self . assertRaises ( HazelcastSerializationError ) : <EOL> self . map . execute_on_key ( "<STR_LIT:key>" , EntryProcessor ( ) ) <EOL> def test_execute_on_keys ( self ) : <EOL> map = self . _fill_map ( ) <EOL> with self . assertRaises ( HazelcastSerializationError ) : <EOL> self . map . execute_on_keys ( map . keys ( ) , EntryProcessor ( ) ) <EOL> def test_flush ( self ) : <EOL> self . _fill_map ( ) <EOL> self . map . flush ( ) <EOL> def test_force_unlock ( self ) : <EOL> self . map . put ( "<STR_LIT:key>" , "<STR_LIT:value>" ) <EOL> self . map . lock ( "<STR_LIT:key>" ) <EOL> self . start_new_thread ( lambda : self . map . force_unlock ( "<STR_LIT:key>" ) ) <EOL> self . assertTrueEventually ( lambda : self . assertFalse ( self . map . is_locked ( "<STR_LIT:key>" ) ) ) <EOL> def test_get_all ( self ) : <EOL> expected = self . _fill_map ( <NUM_LIT:1000> ) <EOL> actual = self . map . get_all ( expected . keys ( ) ) <EOL> self . assertItemsEqual ( expected , actual ) <EOL> def test_get_all_when_no_keys ( self ) : <EOL> self . assertEqual ( self . map . get_all ( [ ] ) , { } ) <EOL> def test_get_entry_view ( self ) : <EOL> self . map . put ( "<STR_LIT:key>" , "<STR_LIT:value>" ) <EOL> self . map . get ( "<STR_LIT:key>" ) <EOL> self . map . put ( "<STR_LIT:key>" , "<STR_LIT>" ) <EOL> entry_view = self . map . get_entry_view ( "<STR_LIT:key>" ) <EOL> self . assertEqual ( entry_view . key , "<STR_LIT:key>" ) <EOL> self . assertEqual ( entry_view . value , "<STR_LIT>" ) <EOL> self . assertIsNotNone ( entry_view . creation_time ) <EOL> self . assertIsNotNone ( entry_view . expiration_time ) <EOL> self . assertEqual ( entry_view . hits , <NUM_LIT:2> ) <EOL> self . assertEqual ( entry_view . version , <NUM_LIT:1> ) <EOL> self . assertEqual ( entry_view . eviction_criteria_number , <NUM_LIT:0> ) <EOL> self . assertIsNotNone ( entry_view . last_access_time ) <EOL> self . assertIsNotNone ( entry_view . last_stored_time ) <EOL> self . assertIsNotNone ( entry_view . last_update_time ) <EOL> self . assertIsNotNone ( entry_view . ttl ) <EOL> def test_is_empty ( self ) : <EOL> self . map . put ( "<STR_LIT:key>" , "<STR_LIT:value>" ) <EOL> self . assertFalse ( self . map . is_empty ( ) ) <EOL> self . map . clear ( ) <EOL> self . assertTrue ( self . map . is_empty ( ) ) <EOL> def test_is_locked ( self ) : <EOL> self . map . put ( "<STR_LIT:key>" , "<STR_LIT:value>" ) <EOL> self . assertFalse ( self . map . is_locked ( "<STR_LIT:key>" ) ) <EOL> self . map . lock ( "<STR_LIT:key>" ) <EOL> self . assertTrue ( self . map . is_locked ( "<STR_LIT:key>" ) ) <EOL> self . map . unlock ( "<STR_LIT:key>" ) <EOL> self . assertFalse ( self . map . is_locked ( "<STR_LIT:key>" ) ) <EOL> def test_key_set ( self ) : <EOL> keys = self . _fill_map ( ) . keys ( ) <EOL> self . assertItemsEqual ( self . map . key_set ( ) , keys ) <EOL> def test_key_set_with_predicate ( self ) : <EOL> self . _fill_map ( ) <EOL> self . assertEqual ( self . map . key_set ( SqlPredicate ( "<STR_LIT>" ) ) , [ "<STR_LIT>" ] ) <EOL> def test_load_all ( self ) : <EOL> keys = self . _fill_map ( ) . keys ( ) <EOL> with self . assertRaises ( HazelcastError ) : <EOL> self . map . load_all ( ) <EOL> def test_load_all_with_keys ( self ) : <EOL> keys = self . _fill_map ( ) . keys ( ) <EOL> with self . assertRaises ( HazelcastError ) : <EOL> self . map . load_all ( [ "<STR_LIT>" , "<STR_LIT>" ] ) <EOL> def test_lock ( self ) : <EOL> self . map . put ( "<STR_LIT:key>" , "<STR_LIT:value>" ) <EOL> t = self . start_new_thread ( lambda : self . map . lock ( "<STR_LIT:key>" ) ) <EOL> t . join ( ) <EOL> self . assertFalse ( self . map . try_put ( "<STR_LIT:key>" , "<STR_LIT>" , timeout = <NUM_LIT> ) ) <EOL> def test_put_all ( self ) : <EOL> map = { "<STR_LIT>" % x : "<STR_LIT>" % x for x in xrange ( <NUM_LIT:0> , <NUM_LIT:1000> ) } <EOL> self . map . put_all ( map ) <EOL> entries = self . map . entry_set ( ) <EOL> self . assertItemsEqual ( entries , map . iteritems ( ) ) <EOL> def test_put_all_when_no_keys ( self ) : <EOL> self . assertIsNone ( self . map . put_all ( { } ) ) <EOL> def test_put_if_absent_when_missing_value ( self ) : <EOL> returned_value = self . map . put_if_absent ( "<STR_LIT:key>" , "<STR_LIT>" ) <EOL> self . assertIsNone ( returned_value ) <EOL> self . assertEqual ( self . map . get ( "<STR_LIT:key>" ) , "<STR_LIT>" ) <EOL> def test_put_if_absent_when_existing_value ( self ) : <EOL> self . map . put ( "<STR_LIT:key>" , "<STR_LIT:value>" ) <EOL> returned_value = self . map . put_if_absent ( "<STR_LIT:key>" , "<STR_LIT>" ) <EOL> self . assertEqual ( returned_value , "<STR_LIT:value>" ) <EOL> self . assertEqual ( self . map . get ( "<STR_LIT:key>" ) , "<STR_LIT:value>" ) <EOL> def test_put_get ( self ) : <EOL> self . assertIsNone ( self . map . put ( "<STR_LIT:key>" , "<STR_LIT:value>" ) ) <EOL> self . assertEqual ( self . map . get ( "<STR_LIT:key>" ) , "<STR_LIT:value>" ) <EOL> def test_put_when_existing ( self ) : <EOL> self . map . put ( "<STR_LIT:key>" , "<STR_LIT:value>" ) <EOL> self . assertEqual ( self . map . put ( "<STR_LIT:key>" , "<STR_LIT>" ) , "<STR_LIT:value>" ) <EOL> self . assertEqual ( self . map . get ( "<STR_LIT:key>" ) , "<STR_LIT>" ) <EOL> def test_put_transient ( self ) : <EOL> self . map . put_transient ( "<STR_LIT:key>" , "<STR_LIT:value>" ) <EOL> self . assertEqual ( self . map . get ( "<STR_LIT:key>" ) , "<STR_LIT:value>" ) <EOL> def test_remove ( self ) : <EOL> self . map . put ( "<STR_LIT:key>" , "<STR_LIT:value>" ) <EOL> removed = self . map . remove ( "<STR_LIT:key>" ) <EOL> self . assertEqual ( removed , "<STR_LIT:value>" ) <EOL> self . assertEqual ( <NUM_LIT:0> , self . map . size ( ) ) <EOL> self . assertFalse ( self . map . contains_key ( "<STR_LIT:key>" ) ) <EOL> def test_remove_if_same_when_same ( self ) : <EOL> self . map . put ( "<STR_LIT:key>" , "<STR_LIT:value>" ) <EOL> self . assertTrue ( self . map . remove_if_same ( "<STR_LIT:key>" , "<STR_LIT:value>" ) ) <EOL> self . assertFalse ( self . map . contains_key ( "<STR_LIT:key>" ) ) <EOL> def test_remove_if_same_when_different ( self ) : <EOL> self . map . put ( "<STR_LIT:key>" , "<STR_LIT:value>" ) <EOL> self . assertFalse ( self . map . remove_if_same ( "<STR_LIT:key>" , "<STR_LIT>" ) ) <EOL> self . assertTrue ( self . map . contains_key ( "<STR_LIT:key>" ) ) <EOL> def test_remove_entry_listener ( self ) : <EOL> collector = event_collector ( ) <EOL> id = self . map . add_entry_listener ( added = collector ) <EOL> self . map . put ( '<STR_LIT:key>' , '<STR_LIT:value>' ) <EOL> self . assertTrueEventually ( lambda : self . assertEqual ( len ( collector . events ) , <NUM_LIT:1> ) ) <EOL> self . map . remove_entry_listener ( id ) <EOL> self . map . put ( '<STR_LIT>' , '<STR_LIT:value>' ) <EOL> time . sleep ( <NUM_LIT:1> ) <EOL> self . assertEqual ( len ( collector . events ) , <NUM_LIT:1> ) <EOL> def test_replace ( self ) : <EOL> self . map . put ( "<STR_LIT:key>" , "<STR_LIT:value>" ) <EOL> replaced = self . map . replace ( "<STR_LIT:key>" , "<STR_LIT>" ) <EOL> self . assertEqual ( replaced , "<STR_LIT:value>" ) <EOL> self . assertEqual ( self . map . get ( "<STR_LIT:key>" ) , "<STR_LIT>" ) <EOL> def test_replace_if_same_when_same ( self ) : <EOL> self . map . put ( "<STR_LIT:key>" , "<STR_LIT:value>" ) <EOL> self . assertTrue ( self . map . replace_if_same ( "<STR_LIT:key>" , "<STR_LIT:value>" , "<STR_LIT>" ) ) <EOL> self . assertEqual ( self . map . get ( "<STR_LIT:key>" ) , "<STR_LIT>" ) <EOL> def test_replace_if_same_when_different ( self ) : <EOL> self . map . put ( "<STR_LIT:key>" , "<STR_LIT:value>" ) <EOL> self . assertFalse ( self . map . replace_if_same ( "<STR_LIT:key>" , "<STR_LIT>" , "<STR_LIT>" ) ) <EOL> self . assertEqual ( self . map . get ( "<STR_LIT:key>" ) , "<STR_LIT:value>" ) <EOL> def test_set ( self ) : <EOL> self . map . set ( "<STR_LIT:key>" , "<STR_LIT:value>" ) <EOL> self . assertEqual ( self . map . get ( "<STR_LIT:key>" ) , "<STR_LIT:value>" ) <EOL> def test_size ( self ) : <EOL> self . _fill_map ( ) <EOL> self . assertEqual ( <NUM_LIT:10> , self . map . size ( ) ) <EOL> def test_try_lock_when_unlocked ( self ) : <EOL> self . assertTrue ( self . map . try_lock ( "<STR_LIT:key>" ) ) <EOL> self . assertTrue ( self . map . is_locked ( "<STR_LIT:key>" ) ) <EOL> def test_try_lock_when_locked ( self ) : <EOL> t = self . start_new_thread ( lambda : self . map . lock ( "<STR_LIT:key>" ) ) <EOL> t . join ( ) <EOL> self . assertFalse ( self . map . try_lock ( "<STR_LIT:key>" , timeout = <NUM_LIT:0.1> ) ) <EOL> def test_try_put_when_unlocked ( self ) : <EOL> self . assertTrue ( self . map . try_put ( "<STR_LIT:key>" , "<STR_LIT:value>" ) ) <EOL> self . assertEqual ( self . map . get ( "<STR_LIT:key>" ) , "<STR_LIT:value>" ) <EOL> def test_try_put_when_locked ( self ) : <EOL> t = self . start_new_thread ( lambda : self . map . lock ( "<STR_LIT:key>" ) ) <EOL> t . join ( ) <EOL> self . assertFalse ( self . map . try_put ( "<STR_LIT:key>" , "<STR_LIT:value>" , timeout = <NUM_LIT:0.1> ) ) <EOL> def test_try_remove_when_unlocked ( self ) : <EOL> self . map . put ( "<STR_LIT:key>" , "<STR_LIT:value>" ) <EOL> self . assertTrue ( self . map . try_remove ( "<STR_LIT:key>" ) ) <EOL> self . assertIsNone ( self . map . get ( "<STR_LIT:key>" ) ) <EOL> def test_try_remove_when_locked ( self ) : <EOL> self . map . put ( "<STR_LIT:key>" , "<STR_LIT:value>" ) <EOL> t = self . start_new_thread ( lambda : self . map . lock ( "<STR_LIT:key>" ) ) <EOL> t . join ( ) <EOL> self . assertFalse ( self . map . try_remove ( "<STR_LIT:key>" , timeout = <NUM_LIT:0.1> ) ) <EOL> def test_unlock ( self ) : <EOL> self . map . lock ( "<STR_LIT:key>" ) <EOL> self . assertTrue ( self . map . is_locked ( "<STR_LIT:key>" ) ) <EOL> self . map . unlock ( "<STR_LIT:key>" ) <EOL> self . assertFalse ( self . map . is_locked ( "<STR_LIT:key>" ) ) <EOL> def test_unlock_when_no_lock ( self ) : <EOL> with self . assertRaises ( HazelcastError ) : <EOL> self . map . unlock ( "<STR_LIT:key>" ) <EOL> def test_values ( self ) : <EOL> values = self . _fill_map ( ) . values ( ) <EOL> self . assertItemsEqual ( self . map . values ( ) , values ) <EOL> def test_values_with_predicate ( self ) : <EOL> self . _fill_map ( ) <EOL> self . assertEqual ( self . map . values ( SqlPredicate ( "<STR_LIT>" ) ) , [ "<STR_LIT>" ] ) <EOL> def test_str ( self ) : <EOL> self . assertTrue ( str ( self . map ) . startswith ( "<STR_LIT>" ) ) <EOL> def _fill_map ( self , count = <NUM_LIT:10> ) : <EOL> map = { "<STR_LIT>" % x : "<STR_LIT>" % x for x in xrange ( <NUM_LIT:0> , count ) } <EOL> for k , v in map . iteritems ( ) : <EOL> self . map . put ( k , v ) <EOL> return map </s>
<s> import json <EOL> import atexit <EOL> from app import constant <EOL> from app import misc <EOL> SECTION = '<STR_LIT>' <EOL> PROXY = '<STR_LIT>' <EOL> parser = misc . ConfParser ( ) <EOL> def initConfig ( ) : <EOL> initValue ( ) <EOL> parser . read ( constant . GLOBAL_CONFIG ) <EOL> atexit . register ( onExit ) <EOL> def initValue ( ) : <EOL> parser [ SECTION ] = { } <EOL> parser [ SECTION ] [ PROXY ] = json . dumps ( { } ) <EOL> def onExit ( ) : <EOL> parser . write ( open ( constant . GLOBAL_CONFIG , '<STR_LIT:w>' ) ) <EOL> initConfig ( ) <EOL> def getParameter ( key ) : <EOL> return parser . get ( SECTION , key ) <EOL> def setParameter ( key , value ) : <EOL> parser . set ( SECTION , key , value ) </s>
<s> import json <EOL> from PyQt4 . QtCore import * <EOL> from PyQt4 . QtGui import * <EOL> from app . widget . ContentWidget import abstract_widget <EOL> from app import logger <EOL> from app import database_manager <EOL> log = logger . getLogger ( __name__ ) <EOL> class AtWidget ( abstract_widget . AbstractTweetContainer ) : <EOL> def __init__ ( self , parent = None ) : <EOL> super ( AtWidget , self ) . __init__ ( '<STR_LIT>' , parent ) <EOL> def retrieveData ( self , account_list , page = <NUM_LIT:1> , count = <NUM_LIT:20> ) : <EOL> rtn = [ ] <EOL> for account in account_list : <EOL> try : <EOL> log . info ( account . plugin ) <EOL> tweet_list = account . plugin . getMentionTimeline ( max_point = ( account . last_tweet_id , account . last_tweet_time ) , <EOL> page = page , count = count <EOL> ) <EOL> for tweet in tweet_list : <EOL> tweet [ '<STR_LIT:type>' ] = abstract_widget . TWEET <EOL> rtn . append ( ( account , tweet_list ) ) <EOL> database_manager . insertHistory ( '<STR_LIT>' , <EOL> [ json . dumps ( tweet ) for tweet in tweet_list ] , <EOL> account . plugin . service , <EOL> account . plugin . uid <EOL> ) <EOL> except Exception as e : <EOL> rtn . append ( ( account , { '<STR_LIT:error>' : str ( e ) } ) ) <EOL> log . info ( '<STR_LIT>' ) <EOL> return ( rtn , ) </s>
<s> import sys <EOL> from os . path import abspath , dirname , join <EOL> try : <EOL> import pinax <EOL> except ImportError : <EOL> sys . stderr . write ( "<STR_LIT>" ) <EOL> sys . exit ( <NUM_LIT:1> ) <EOL> from django . conf import settings <EOL> from django . core . management import setup_environ , execute_from_command_line <EOL> try : <EOL> import settings as settings_mod <EOL> except ImportError : <EOL> sys . stderr . write ( "<STR_LIT>" % __file__ ) <EOL> sys . exit ( <NUM_LIT:1> ) <EOL> setup_environ ( settings_mod ) <EOL> sys . path . insert ( <NUM_LIT:0> , join ( settings . PINAX_ROOT , "<STR_LIT>" ) ) <EOL> sys . path . insert ( <NUM_LIT:0> , join ( settings . PROJECT_ROOT , "<STR_LIT>" ) ) <EOL> if __name__ == "<STR_LIT:__main__>" : <EOL> execute_from_command_line ( ) </s>
<s> from restthumbnails . files import ThumbnailFile <EOL> from testsuite . tests . utils import StorageTestCase <EOL> class ThumbnailFileTestCase ( StorageTestCase ) : <EOL> def test_pil_can_identify_jpeg ( self ) : <EOL> thumb = ThumbnailFile ( <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' ) <EOL> self . assertTrue ( <EOL> thumb . generate ( ) ) <EOL> thumb = ThumbnailFile ( <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' ) <EOL> self . assertTrue ( <EOL> thumb . generate ( ) ) </s>
<s> import sys , os <EOL> from types import FunctionType <EOL> import numpy as np <EOL> from matplotlib . pylab import figure <EOL> import matplotlib . pyplot as plt <EOL> import pandas as pd <EOL> import pymc as pm <EOL> import pymc . progressbar as pbar <EOL> from . import utils <EOL> from . utils import interpolate_trace <EOL> from collections import OrderedDict <EOL> def plot_posterior_nodes ( nodes , bins = <NUM_LIT:50> , lb = None , ub = None ) : <EOL> """<STR_LIT>""" <EOL> figure ( ) <EOL> if lb is None : <EOL> lb = min ( [ min ( node . trace ( ) [ : ] ) for node in nodes ] ) <EOL> if ub is None : <EOL> ub = max ( [ max ( node . trace ( ) [ : ] ) for node in nodes ] ) <EOL> x_data = np . linspace ( lb , ub , <NUM_LIT> ) <EOL> for node in nodes : <EOL> trace = node . trace ( ) [ : ] <EOL> hist = interpolate_trace ( x_data , trace , range = ( lb , ub ) , bins = bins ) <EOL> plt . plot ( x_data , hist , label = node . __name__ , lw = <NUM_LIT> ) <EOL> leg = plt . legend ( loc = '<STR_LIT>' , fancybox = True ) <EOL> leg . get_frame ( ) . set_alpha ( <NUM_LIT:0.5> ) <EOL> def group_plot ( model , params_to_plot = ( ) , bins = <NUM_LIT:50> , samples = <NUM_LIT> , save_to = None ) : <EOL> def find_min_max ( subj_block ) : <EOL> min = np . inf <EOL> max = - np . inf <EOL> for name , subj in subj_block . iterrows ( ) : <EOL> trace = subj [ '<STR_LIT>' ] . trace ( ) <EOL> min = np . min ( [ min , np . min ( trace ) ] ) <EOL> max = np . max ( [ max , np . max ( trace ) ] ) <EOL> return min , max <EOL> assert model . is_group_model , "<STR_LIT>" <EOL> subj_nodes = model . nodes_db [ ( model . nodes_db [ '<STR_LIT>' ] == False ) & ( model . nodes_db [ '<STR_LIT>' ] == True ) ] <EOL> knode_names = subj_nodes . groupby ( [ '<STR_LIT>' , '<STR_LIT>' ] ) <EOL> for ( knode_name , tag ) , subj_block in knode_names : <EOL> min , max = find_min_max ( subj_block ) <EOL> print ( "<STR_LIT>" % ( knode_name , tag ) ) <EOL> sys . stdout . flush ( ) <EOL> plt . figure ( ) <EOL> plt . title ( "<STR_LIT>" % ( knode_name , tag ) ) <EOL> x = np . linspace ( min , max , <NUM_LIT:100> ) <EOL> for name , subj_descr in subj_block . iterrows ( ) : <EOL> trace = subj_descr [ '<STR_LIT>' ] . trace ( ) <EOL> height = interpolate_trace ( x , trace , range = ( min , max ) , bins = bins ) <EOL> plt . plot ( x , height , lw = <NUM_LIT:1.> , label = str ( np . int32 ( subj_descr [ '<STR_LIT>' ] ) ) ) <EOL> node = subj_descr [ '<STR_LIT>' ] <EOL> group_trace = np . empty ( samples , dtype = np . float32 ) <EOL> for sample in range ( samples ) : <EOL> trace_pos = np . random . randint ( <NUM_LIT:0> , len ( node . trace ( ) ) ) <EOL> for parent in node . extended_parents : <EOL> parent . value = parent . trace ( ) [ trace_pos ] <EOL> group_trace [ sample ] = node . random ( ) <EOL> height = interpolate_trace ( x , group_trace , range = ( min , max ) , bins = bins ) <EOL> plt . plot ( x , height , '<STR_LIT>' , lw = <NUM_LIT> , label = '<STR_LIT>' ) <EOL> leg = plt . legend ( loc = '<STR_LIT>' , fancybox = True ) <EOL> leg . get_frame ( ) . set_alpha ( <NUM_LIT:0.5> ) <EOL> plt . gcf ( ) . canvas . set_window_title ( knode_name ) <EOL> if save_to is not None : <EOL> plt . savefig ( os . path . join ( save_to , "<STR_LIT>" % knode_name ) ) <EOL> plt . savefig ( os . path . join ( save_to , "<STR_LIT>" % knode_name ) ) <EOL> def plot_all_pairwise ( model ) : <EOL> """<STR_LIT>""" <EOL> import scipy as sp <EOL> from itertools import combinations <EOL> fig = plt . figure ( ) <EOL> fig . subplots_adjust ( wspace = <NUM_LIT> , hspace = <NUM_LIT> ) <EOL> for i , ( p0 , p1 ) in enumerate ( combinations ( model . get_group_nodes ( ) [ '<STR_LIT>' ] , <NUM_LIT:2> ) ) : <EOL> fig . add_subplot ( <NUM_LIT:6> , <NUM_LIT:6> , i + <NUM_LIT:1> ) <EOL> plt . plot ( p0 . trace ( ) , p1 . trace ( ) , '<STR_LIT:.>' ) <EOL> ( a_s , b_s , r , tt , stderr ) = sp . stats . linregress ( p0 . trace ( ) , p1 . trace ( ) ) <EOL> reg = sp . polyval ( ( a_s , b_s ) , ( np . min ( p0 . trace ( ) ) , np . max ( p0 . trace ( ) ) ) ) <EOL> plt . plot ( ( np . min ( p0 . trace ( ) ) , np . max ( p0 . trace ( ) ) ) , reg , '<STR_LIT:->' ) <EOL> plt . xlabel ( p0 . __name__ ) <EOL> plt . ylabel ( p1 . __name__ ) <EOL> plt . draw ( ) <EOL> def gelman_rubin ( models ) : <EOL> """<STR_LIT>""" <EOL> stochastics = models [ <NUM_LIT:0> ] . get_stochastics ( ) <EOL> R_hat_dict = { } <EOL> num_samples = stochastics . node [ <NUM_LIT:0> ] . trace ( ) . shape [ <NUM_LIT:0> ] <EOL> num_chains = len ( models ) <EOL> for name , stochastic in stochastics . iterrows ( ) : <EOL> samples = np . empty ( ( num_chains , num_samples ) ) <EOL> for i , model in enumerate ( models ) : <EOL> samples [ i , : ] = model . nodes_db . ix [ name , '<STR_LIT>' ] . trace ( ) <EOL> R_hat_dict [ name ] = pm . diagnostics . gelman_rubin ( samples ) <EOL> return R_hat_dict <EOL> R_hat = gelman_rubin <EOL> def check_geweke ( model , assert_ = True ) : <EOL> for name , param in model . iter_stochastics ( ) : <EOL> geweke = np . array ( pm . geweke ( param [ '<STR_LIT>' ] ) ) <EOL> if np . any ( np . abs ( geweke [ : , <NUM_LIT:1> ] ) > <NUM_LIT:2> ) : <EOL> msg = "<STR_LIT>" % param <EOL> if assert_ : <EOL> raise AssertionError ( msg ) <EOL> else : <EOL> print ( msg ) <EOL> return False <EOL> return True <EOL> def group_cond_diff ( hm , node , cond1 , cond2 , threshold = <NUM_LIT:0> ) : <EOL> """<STR_LIT>""" <EOL> import scipy as sp <EOL> name = node <EOL> node_dict = hm . params_include [ name ] . subj_nodes <EOL> n_subjs = hm . _num_subjs <EOL> subj_diff_mean = np . zeros ( n_subjs ) <EOL> subj_diff_std = np . zeros ( n_subjs ) <EOL> for i_subj in range ( n_subjs ) : <EOL> name1 = node_dict [ cond1 ] [ i_subj ] . __name__ <EOL> name2 = node_dict [ cond2 ] [ i_subj ] . __name__ <EOL> trace1 = hm . mc . db . trace ( name1 ) [ : ] <EOL> trace2 = hm . mc . db . trace ( name2 ) [ : ] <EOL> diff_trace = trace1 - trace2 <EOL> subj_diff_mean [ i_subj ] = np . mean ( diff_trace ) <EOL> subj_diff_std [ i_subj ] = np . std ( diff_trace ) <EOL> pooled_var = <NUM_LIT:1.> / sum ( <NUM_LIT:1.> / ( subj_diff_std <NUM_LIT:2> ) ) <EOL> pooled_mean = sum ( subj_diff_mean / ( subj_diff_std <NUM_LIT:2> ) ) * pooled_var <EOL> mass_under = sp . stats . norm . cdf ( threshold , pooled_mean , np . sqrt ( pooled_var ) ) <EOL> return pooled_mean , pooled_var , mass_under <EOL> def post_pred_compare_stats ( sampled_stats , data_stats , evals = None ) : <EOL> """<STR_LIT>""" <EOL> from scipy . stats import scoreatpercentile , percentileofscore <EOL> if evals is None : <EOL> evals = OrderedDict ( ) <EOL> evals [ '<STR_LIT>' ] = lambda x , y : y <EOL> evals [ '<STR_LIT>' ] = lambda x , y : np . mean ( x ) <EOL> evals [ '<STR_LIT>' ] = lambda x , y : np . std ( x ) <EOL> evals [ '<STR_LIT>' ] = lambda x , y : ( np . mean ( x ) - y ) <NUM_LIT:2> <EOL> evals [ '<STR_LIT>' ] = lambda x , y : np . mean ( ( x - y ) <NUM_LIT:2> ) <EOL> evals [ '<STR_LIT>' ] = lambda x , y : ( scoreatpercentile ( x , <NUM_LIT> ) > y ) and ( scoreatpercentile ( x , <NUM_LIT> ) < y ) <EOL> evals [ '<STR_LIT>' ] = percentileofscore <EOL> evals [ '<STR_LIT>' ] = lambda x , y : np . abs ( np . mean ( x ) - y ) / np . std ( x ) <EOL> results = pd . DataFrame ( index = list ( sampled_stats . keys ( ) ) , columns = list ( evals . keys ( ) ) + [ '<STR_LIT>' ] , <EOL> dtype = np . float32 ) <EOL> results . index . names = [ '<STR_LIT>' ] <EOL> for stat_name in sampled_stats : <EOL> s = sampled_stats [ stat_name ] <EOL> results . ix [ stat_name , '<STR_LIT>' ] = sum ( pd . isnull ( s ) ) <EOL> s = s [ np . isfinite ( s ) ] <EOL> if len ( s ) == <NUM_LIT:0> : <EOL> continue <EOL> for eval_name , func in evals . items ( ) : <EOL> value = func ( s , data_stats [ stat_name ] ) <EOL> results . ix [ stat_name , eval_name ] = value <EOL> return results . drop ( '<STR_LIT>' , axis = <NUM_LIT:1> ) <EOL> def _post_pred_generate ( bottom_node , samples = <NUM_LIT> , data = None , append_data = False ) : <EOL> """<STR_LIT>""" <EOL> datasets = [ ] <EOL> for sample in range ( samples ) : <EOL> _parents_to_random_posterior_sample ( bottom_node ) <EOL> sampled_data = bottom_node . random ( ) <EOL> if append_data and data is not None : <EOL> sampled_data = sampled_data . join ( data . reset_index ( ) , lsuffix = '<STR_LIT>' ) <EOL> datasets . append ( sampled_data ) <EOL> return datasets <EOL> def post_pred_gen ( model , groupby = None , samples = <NUM_LIT> , append_data = False , progress_bar = True ) : <EOL> """<STR_LIT>""" <EOL> results = { } <EOL> if progress_bar : <EOL> n_iter = len ( model . get_observeds ( ) ) <EOL> bar = pbar . progress_bar ( n_iter ) <EOL> bar_iter = <NUM_LIT:0> <EOL> else : <EOL> print ( "<STR_LIT>" ) <EOL> if groupby is None : <EOL> iter_data = ( ( name , model . data . ix [ obs [ '<STR_LIT>' ] . value . index ] ) for name , obs in model . iter_observeds ( ) ) <EOL> else : <EOL> iter_data = model . data . groupby ( groupby ) <EOL> for name , data in iter_data : <EOL> node = model . get_data_nodes ( data . index ) <EOL> if progress_bar : <EOL> bar_iter += <NUM_LIT:1> <EOL> bar . update ( bar_iter ) <EOL> if node is None or not hasattr ( node , '<STR_LIT>' ) : <EOL> continue <EOL> datasets = _post_pred_generate ( node , samples = samples , data = data , append_data = append_data ) <EOL> results [ name ] = pd . concat ( datasets , names = [ '<STR_LIT>' ] , keys = list ( range ( len ( datasets ) ) ) ) <EOL> if progress_bar : <EOL> bar_iter += <NUM_LIT:1> <EOL> bar . update ( bar_iter ) <EOL> return pd . concat ( results , names = [ '<STR_LIT>' ] ) <EOL> def post_pred_stats ( data , sim_datasets , stats = None , plot = False , bins = <NUM_LIT:100> , evals = None , call_compare = True ) : <EOL> """<STR_LIT>""" <EOL> def _calc_stats ( data , stats ) : <EOL> out = { } <EOL> for name , func in stats . items ( ) : <EOL> out [ name ] = func ( data ) <EOL> return out <EOL> if stats is None : <EOL> stats = OrderedDict ( ( ( '<STR_LIT>' , np . mean ) , ( '<STR_LIT>' , np . std ) ) ) <EOL> if isinstance ( stats , FunctionType ) : <EOL> stats = OrderedDict ( ( ( '<STR_LIT>' , stats ) , ) ) <EOL> data_stats = _calc_stats ( data , stats ) <EOL> samples = len ( sim_datasets ) <EOL> sampled_stats = { } <EOL> sampled_stats = pd . DataFrame ( index = sim_datasets . index . droplevel ( <NUM_LIT:2> ) . unique ( ) , <EOL> columns = list ( stats . keys ( ) ) , <EOL> dtype = np . float32 ) <EOL> for i , sim_dataset in sim_datasets . groupby ( level = ( <NUM_LIT:0> , <NUM_LIT:1> ) ) : <EOL> sampled_stat = _calc_stats ( sim_dataset . values , stats ) <EOL> for name , value in sampled_stat . items ( ) : <EOL> sampled_stats [ name ] [ i ] = value <EOL> if plot : <EOL> from pymc . Matplot import gof_plot <EOL> for name , value in sampled_stats . items ( ) : <EOL> gof_plot ( value , data_stats [ name ] , bins = bins , name = name , verbose = <NUM_LIT:0> ) <EOL> if call_compare : <EOL> return post_pred_compare_stats ( sampled_stats , data_stats , evals = evals ) <EOL> else : <EOL> return sampled_stats <EOL> def _parents_to_random_posterior_sample ( bottom_node , pos = None ) : <EOL> """<STR_LIT>""" <EOL> for i , parent in enumerate ( bottom_node . extended_parents ) : <EOL> if not isinstance ( parent , pm . Node ) : <EOL> continue <EOL> if pos is None : <EOL> pos = np . random . randint ( <NUM_LIT:0> , len ( parent . trace ( ) ) ) <EOL> assert len ( parent . trace ( ) ) >= pos , "<STR_LIT>" <EOL> parent . value = parent . trace ( ) [ pos ] <EOL> def _plot_posterior_pdf_node ( bottom_node , axis , value_range = None , samples = <NUM_LIT:10> , bins = <NUM_LIT:100> ) : <EOL> """<STR_LIT>""" <EOL> if value_range is None : <EOL> raise NotImplementedError ( "<STR_LIT>" ) <EOL> like = np . empty ( ( samples , len ( value_range ) ) , dtype = np . float32 ) <EOL> for sample in range ( samples ) : <EOL> _parents_to_random_posterior_sample ( bottom_node ) <EOL> like [ sample , : ] = bottom_node . pdf ( value_range ) <EOL> y = like . mean ( axis = <NUM_LIT:0> ) <EOL> try : <EOL> y_std = like . std ( axis = <NUM_LIT:0> ) <EOL> except FloatingPointError : <EOL> print ( "<STR_LIT>" % bottom_node . __name__ ) <EOL> y_std = np . zeros_like ( y ) <EOL> axis . plot ( value_range , y , label = '<STR_LIT>' , color = '<STR_LIT:b>' ) <EOL> axis . fill_between ( value_range , y - y_std , y + y_std , color = '<STR_LIT:b>' , alpha = <NUM_LIT> ) <EOL> if len ( bottom_node . value ) != <NUM_LIT:0> : <EOL> axis . hist ( bottom_node . value . values , normed = True , color = '<STR_LIT:r>' , <EOL> range = ( value_range [ <NUM_LIT:0> ] , value_range [ - <NUM_LIT:1> ] ) , label = '<STR_LIT:data>' , <EOL> bins = bins , histtype = '<STR_LIT>' , lw = <NUM_LIT> ) <EOL> axis . set_ylim ( bottom = <NUM_LIT:0> ) <EOL> def plot_posterior_predictive ( model , plot_func = None , required_method = '<STR_LIT>' , columns = None , save = False , path = None , <EOL> figsize = ( <NUM_LIT:8> , <NUM_LIT:6> ) , format = '<STR_LIT>' , num_subjs = None , kwargs ) : <EOL> """<STR_LIT>""" <EOL> if plot_func is None : <EOL> plot_func = _plot_posterior_pdf_node <EOL> observeds = model . get_observeds ( ) <EOL> if columns is None : <EOL> max_items = max ( [ len ( i [ <NUM_LIT:1> ] ) for i in <EOL> observeds . groupby ( '<STR_LIT>' ) . groups . items ( ) ] ) <EOL> columns = min ( <NUM_LIT:3> , max_items ) <EOL> for tag , nodes in observeds . groupby ( '<STR_LIT>' ) : <EOL> fig = plt . figure ( figsize = figsize ) <EOL> fig . suptitle ( utils . pretty_tag ( tag ) , fontsize = <NUM_LIT:12> ) <EOL> fig . subplots_adjust ( top = <NUM_LIT> , hspace = <NUM_LIT> , wspace = <NUM_LIT> ) <EOL> i = <NUM_LIT:0> <EOL> for subj_i , ( node_name , bottom_node ) in enumerate ( nodes . iterrows ( ) ) : <EOL> i += <NUM_LIT:1> <EOL> if not hasattr ( bottom_node [ '<STR_LIT>' ] , required_method ) : <EOL> continue <EOL> ax = fig . add_subplot ( np . ceil ( len ( nodes ) / columns ) , columns , subj_i + <NUM_LIT:1> ) <EOL> if '<STR_LIT>' in bottom_node : <EOL> ax . set_title ( str ( bottom_node [ '<STR_LIT>' ] ) ) <EOL> plot_func ( bottom_node [ '<STR_LIT>' ] , ax , kwargs ) <EOL> if num_subjs is not None and num_subjs >= i : <EOL> break <EOL> if save : <EOL> fname = '<STR_LIT>' + '<STR_LIT:.>' . join ( tag ) <EOL> if path is None : <EOL> path = '<STR_LIT:.>' <EOL> if isinstance ( format , str ) : <EOL> format = [ format ] <EOL> [ fig . savefig ( '<STR_LIT>' % ( os . path . join ( path , fname ) , x ) , format = x ) for x in format ] <EOL> def geweke_problems ( model , fname = None , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> g = pm . geweke ( model . mc ) <EOL> problems = [ ] <EOL> for node , output in g . items ( ) : <EOL> values = np . array ( output ) [ : , <NUM_LIT:1> ] <EOL> if np . any ( np . abs ( values ) > <NUM_LIT:2> ) : <EOL> problems . append ( node ) <EOL> if fname is not None : <EOL> with open ( fname , '<STR_LIT:w>' ) as f : <EOL> for node in problems : <EOL> f . write ( node ) <EOL> return problems </s>
<s> """<STR_LIT>""" <EOL> try : <EOL> from setuptools import setup , Extension <EOL> except ImportError : <EOL> from distutils . core import setup , Extension <EOL> try : <EOL> from pypandoc import convert <EOL> def read_md ( fpath ) : <EOL> return convert ( fpath , '<STR_LIT>' ) <EOL> except ImportError : <EOL> print ( "<STR_LIT>" ) <EOL> def read_md ( fpath ) : <EOL> with open ( fpath , '<STR_LIT:r>' ) as fp : <EOL> return fp . read ( ) <EOL> import numpy <EOL> from Cython . Distutils import build_ext <EOL> setup ( name = '<STR_LIT>' , <EOL> version = '<STR_LIT>' , <EOL> author = '<STR_LIT>' , <EOL> author_email = '<STR_LIT>' , <EOL> package_dir = { '<STR_LIT>' : '<STR_LIT>' } , <EOL> packages = [ <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> ] , <EOL> cmdclass = { '<STR_LIT>' : build_ext } , <EOL> ext_modules = [ <EOL> Extension ( <EOL> "<STR_LIT>" , <EOL> sources = [ <EOL> "<STR_LIT>" , <EOL> "<STR_LIT>" , <EOL> ] , <EOL> include_dirs = [ numpy . get_include ( ) , "<STR_LIT>" ] ) , <EOL> Extension ( <EOL> "<STR_LIT>" , <EOL> sources = [ <EOL> "<STR_LIT>" , <EOL> "<STR_LIT>" , <EOL> ] , <EOL> language = "<STR_LIT>" , <EOL> include_dirs = [ numpy . get_include ( ) , "<STR_LIT>" ] ) <EOL> ] , <EOL> scripts = [ <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> ] , <EOL> url = '<STR_LIT>' , <EOL> license = '<STR_LIT>' , <EOL> description = '<STR_LIT>' , <EOL> long_description = open ( "<STR_LIT>" ) . read ( ) , <EOL> install_requires = [ <EOL> "<STR_LIT>" , <EOL> "<STR_LIT>" , <EOL> "<STR_LIT>" , <EOL> "<STR_LIT>" , <EOL> ] , <EOL> ) </s>
<s> import json <EOL> import uuid <EOL> from functools import wraps <EOL> from django . contrib . auth . models import User <EOL> from django . http import HttpResponseBadRequest , JsonResponse <EOL> from six import string_types <EOL> def uuid_or_400 ( f ) : <EOL> @ wraps ( f ) <EOL> def wrapper ( request , * args , ** kwds ) : <EOL> try : <EOL> uuid . UUID ( args [ <NUM_LIT:0> ] ) <EOL> except ValueError : <EOL> return HttpResponseBadRequest ( ) <EOL> return f ( request , * args , ** kwds ) <EOL> return wrapper <EOL> def make_error ( msg ) : <EOL> return JsonResponse ( { "<STR_LIT:error>" : msg } , status = <NUM_LIT> ) <EOL> def check_api_key ( f ) : <EOL> @ wraps ( f ) <EOL> def wrapper ( request , * args , ** kwds ) : <EOL> try : <EOL> data = json . loads ( request . body . decode ( "<STR_LIT:utf-8>" ) ) <EOL> except ValueError : <EOL> return make_error ( "<STR_LIT>" ) <EOL> api_key = str ( data . get ( "<STR_LIT>" , "<STR_LIT>" ) ) <EOL> if api_key == "<STR_LIT>" : <EOL> return make_error ( "<STR_LIT>" ) <EOL> try : <EOL> user = User . objects . get ( profile__api_key = api_key ) <EOL> except User . DoesNotExist : <EOL> return make_error ( "<STR_LIT>" ) <EOL> request . json = data <EOL> request . user = user <EOL> return f ( request , * args , ** kwds ) <EOL> return wrapper <EOL> def validate_json ( schema ) : <EOL> """<STR_LIT>""" <EOL> def decorator ( f ) : <EOL> @ wraps ( f ) <EOL> def wrapper ( request , * args , ** kwds ) : <EOL> for key , spec in schema [ "<STR_LIT>" ] . items ( ) : <EOL> if key not in request . json : <EOL> continue <EOL> value = request . json [ key ] <EOL> if spec [ "<STR_LIT:type>" ] == "<STR_LIT:string>" : <EOL> if not isinstance ( value , string_types ) : <EOL> return make_error ( "<STR_LIT>" % key ) <EOL> elif spec [ "<STR_LIT:type>" ] == "<STR_LIT>" : <EOL> if not isinstance ( value , int ) : <EOL> return make_error ( "<STR_LIT>" % key ) <EOL> if "<STR_LIT>" in spec and value < spec [ "<STR_LIT>" ] : <EOL> return make_error ( "<STR_LIT>" % key ) <EOL> if "<STR_LIT>" in spec and value > spec [ "<STR_LIT>" ] : <EOL> return make_error ( "<STR_LIT>" % key ) <EOL> return f ( request , * args , ** kwds ) <EOL> return wrapper <EOL> return decorator </s>
<s> from __future__ import unicode_literals <EOL> from django . db import migrations , models <EOL> class Migration ( migrations . Migration ) : <EOL> dependencies = [ <EOL> ( '<STR_LIT>' , '<STR_LIT>' ) , <EOL> ] <EOL> operations = [ <EOL> migrations . AddField ( <EOL> model_name = '<STR_LIT>' , <EOL> name = '<STR_LIT:n>' , <EOL> field = models . IntegerField ( null = True ) , <EOL> ) , <EOL> ] </s>
<s> from hc . api . models import Check <EOL> from hc . test import BaseTestCase <EOL> class MyChecksTestCase ( BaseTestCase ) : <EOL> def setUp ( self ) : <EOL> super ( MyChecksTestCase , self ) . setUp ( ) <EOL> self . check = Check ( user = self . alice , name = "<STR_LIT>" ) <EOL> self . check . save ( ) <EOL> def test_it_works ( self ) : <EOL> self . client . login ( username = "<STR_LIT>" , password = "<STR_LIT:password>" ) <EOL> r = self . client . get ( "<STR_LIT>" ) <EOL> self . assertContains ( r , "<STR_LIT>" , status_code = <NUM_LIT:200> ) </s>
<s> import os , sys <EOL> from Tkinter import * <EOL> from tkFileDialog import * <EOL> from PIL import Image , ImageStat , ImageDraw , ImageFont , TiffImagePlugin , ImageTk <EOL> import scipy <EOL> from scipy import polyval , polyfit , ndimage <EOL> from pylab import polyfit , polyval <EOL> import numpy as np <EOL> def Show_pic ( pic ) : <EOL> im = pic . copy ( ) <EOL> im . thumbnail ( ( <NUM_LIT> , <NUM_LIT> ) , Image . ANTIALIAS ) <EOL> imtk = ImageTk . PhotoImage ( im ) <EOL> label = Label ( image = imtk , height = <NUM_LIT> , width = <NUM_LIT> ) <EOL> label . image = imtk <EOL> label . grid ( row = <NUM_LIT:5> , rowspan = <NUM_LIT:50> , column = <NUM_LIT:2> ) <EOL> main . update ( ) <EOL> def Pixel_check ( curFile , dirF , file ) : <EOL> pic = Image . open ( curFile ) <EOL> pic2 = Image . open ( curFile ) <EOL> picr = Image . open ( curFile ) <EOL> if ( rotPic . get ( ) ) : <EOL> print "<STR_LIT>" <EOL> pic = pic . rotate ( <NUM_LIT> ) <EOL> if ( flipPic . get ( ) ) : <EOL> print "<STR_LIT>" <EOL> pic = pic . transpose ( Image . FLIP_LEFT_RIGHT ) <EOL> imgdata = pic . load ( ) <EOL> print file , "<STR_LIT>" <EOL> speedP = speedPscale . get ( ) <EOL> xsize , ysize = pic . size <EOL> xsize = xsize / speedP <EOL> ysize = ysize / speedP <EOL> pic = pic . resize ( ( xsize , ysize ) ) <EOL> pic2 = pic2 . resize ( ( xsize , ysize ) ) <EOL> picr = picr . resize ( ( xsize , ysize ) ) <EOL> xsize , ysize = pic . size <EOL> print xsize , "<STR_LIT:x>" , ysize <EOL> minG = minGscale . get ( ) <EOL> minR = minRscale . get ( ) <EOL> ratG = ratGscale . get ( ) <EOL> ratGb = ratGbscale . get ( ) <EOL> ratR = ratRscale . get ( ) <EOL> global mingGactual , ratGactual , ratGbactual <EOL> mingGactual = minG <EOL> ratGactual = ratG <EOL> ratGbactual = ratGb <EOL> pixels = pic . load ( ) <EOL> leafpix = [ ] <EOL> scalepix = [ ] <EOL> backpix = [ ] <EOL> leafonly = pic2 . load ( ) <EOL> scaleonly = picr . load ( ) <EOL> for i in range ( pic . size [ <NUM_LIT:0> ] ) : <EOL> for j in range ( pic . size [ <NUM_LIT:1> ] ) : <EOL> r , g , b = pixels [ i , j ] <EOL> if r * ratG < g and b * ratGb < g and g > minG : <EOL> leafpix . append ( ( i , j ) ) <EOL> leafonly [ i , j ] = ( <NUM_LIT:0> , <NUM_LIT:255> , <NUM_LIT:0> ) <EOL> scaleonly [ i , j ] = ( <NUM_LIT:0> , <NUM_LIT:0> , <NUM_LIT:0> ) <EOL> else : <EOL> leafonly [ i , j ] = ( <NUM_LIT:0> , <NUM_LIT:0> , <NUM_LIT:0> ) <EOL> if r > minR and g * ratR < r and b * ratR < r : <EOL> scalepix . append ( ( i , j ) ) <EOL> scaleonly [ i , j ] = ( <NUM_LIT:255> , <NUM_LIT:0> , <NUM_LIT:0> ) <EOL> else : <EOL> backpix . append ( ( i , j ) ) <EOL> scaleonly [ i , j ] = ( <NUM_LIT:0> , <NUM_LIT:0> , <NUM_LIT:0> ) <EOL> gCnt = len ( leafpix ) <EOL> if ( delBack . get ( ) ) : <EOL> for i in backpix : <EOL> pixels [ i ] = ( <NUM_LIT:255> , <NUM_LIT:255> , <NUM_LIT:255> ) <EOL> flat = scipy . misc . fromimage ( pic2 , flatten = <NUM_LIT:1> ) <EOL> flatr = scipy . misc . fromimage ( picr , flatten = <NUM_LIT:1> ) <EOL> blobs , leaves = ndimage . label ( flat ) <EOL> blobsr , scales = ndimage . label ( flatr ) <EOL> scalehist = ndimage . measurements . histogram ( blobsr , <NUM_LIT:1> , scales , scales ) <EOL> try : maxscale = max ( scalehist ) <EOL> except : pass <EOL> cnt = <NUM_LIT:1> <EOL> gcnt = <NUM_LIT:0> <EOL> parcnt = <NUM_LIT:0> <EOL> rCnt = <NUM_LIT:0> <EOL> largescale = [ ] <EOL> for s in scalehist : <EOL> if s == maxscale : <EOL> cnti = <NUM_LIT:0> <EOL> cntj = <NUM_LIT:0> <EOL> gcnt = <NUM_LIT:0> <EOL> parcnt = parcnt + <NUM_LIT:1> <EOL> for i in range ( pic . size [ <NUM_LIT:0> ] ) : <EOL> for j in range ( pic . size [ <NUM_LIT:1> ] ) : <EOL> if blobsr [ j , i ] == cnt : <EOL> gcnt = gcnt + <NUM_LIT:1> <EOL> rCnt = rCnt + <NUM_LIT:1> <EOL> cnti = cnti + i <EOL> cntj = cntj + j <EOL> pixels [ i , j ] = ( <NUM_LIT:255> , <NUM_LIT:0> , <NUM_LIT:0> ) <EOL> flat [ j , i ] = ( <NUM_LIT:0> ) <EOL> cnti = cnti / gcnt <EOL> cntj = cntj / gcnt <EOL> largescale . append ( gcnt ) <EOL> if labpix . get ( ) : <EOL> draw = ImageDraw . Draw ( pic ) <EOL> draw . text ( ( cnti , cntj ) , str ( gcnt ) , ( <NUM_LIT:0> , <NUM_LIT:0> , <NUM_LIT:0> ) ) <EOL> cnt = cnt + <NUM_LIT:1> <EOL> blobhist = ndimage . measurements . histogram ( blobs , <NUM_LIT:1> , leaves , leaves ) <EOL> minPsize = minPscale . get ( ) <EOL> try : maxleaf = max ( blobhist ) <EOL> except : pass <EOL> if ThereCanBeOnlyOne . get ( ) : <EOL> cnt = <NUM_LIT:1> <EOL> gcnt = <NUM_LIT:0> <EOL> parcnt = <NUM_LIT:0> <EOL> gCnt = <NUM_LIT:0> <EOL> largeleaf = [ ] <EOL> for s in blobhist : <EOL> if s == maxleaf : <EOL> cnti = <NUM_LIT:0> <EOL> cntj = <NUM_LIT:0> <EOL> gcnt = <NUM_LIT:0> <EOL> parcnt = parcnt + <NUM_LIT:1> <EOL> for i in range ( pic . size [ <NUM_LIT:0> ] ) : <EOL> for j in range ( pic . size [ <NUM_LIT:1> ] ) : <EOL> if blobs [ j , i ] == cnt : <EOL> gcnt = gcnt + <NUM_LIT:1> <EOL> gCnt = gCnt + <NUM_LIT:1> <EOL> cnti = cnti + i <EOL> cntj = cntj + j <EOL> pixels [ i , j ] = ( <NUM_LIT:0> , <NUM_LIT:255> , <NUM_LIT:0> ) <EOL> flat [ j , i ] = ( <NUM_LIT:0> ) <EOL> cnti = cnti / gcnt <EOL> cntj = cntj / gcnt <EOL> largeleaf . append ( gcnt ) <EOL> if labpix . get ( ) : <EOL> draw = ImageDraw . Draw ( pic ) <EOL> draw . text ( ( cnti , cntj ) , str ( gcnt ) , ( <NUM_LIT:0> , <NUM_LIT:0> , <NUM_LIT:0> ) ) <EOL> cnt = cnt + <NUM_LIT:1> <EOL> leafprint = '<STR_LIT:U+002CU+0020>' . join ( map ( str , largeleaf ) ) <EOL> elif minPsize > <NUM_LIT:10> : <EOL> cnt = <NUM_LIT:1> <EOL> gcnt = <NUM_LIT:0> <EOL> parcnt = <NUM_LIT:0> <EOL> gCnt = <NUM_LIT:0> <EOL> largeleaf = [ ] <EOL> for s in blobhist : <EOL> if s > minPsize : <EOL> cnti = <NUM_LIT:0> <EOL> cntj = <NUM_LIT:0> <EOL> gcnt = <NUM_LIT:0> <EOL> parcnt = parcnt + <NUM_LIT:1> <EOL> for i in range ( pic . size [ <NUM_LIT:0> ] ) : <EOL> for j in range ( pic . size [ <NUM_LIT:1> ] ) : <EOL> if blobs [ j , i ] == cnt : <EOL> gcnt = gcnt + <NUM_LIT:1> <EOL> gCnt = gCnt + <NUM_LIT:1> <EOL> cnti = cnti + i <EOL> cntj = cntj + j <EOL> pixels [ i , j ] = ( <NUM_LIT:0> , <NUM_LIT:255> , <NUM_LIT:0> ) <EOL> flat [ j , i ] = ( <NUM_LIT:0> ) <EOL> cnti = cnti / gcnt <EOL> cntj = cntj / gcnt <EOL> largeleaf . append ( gcnt ) <EOL> if labpix . get ( ) : <EOL> draw = ImageDraw . Draw ( pic ) <EOL> draw . text ( ( cnti , cntj ) , str ( gcnt ) , ( <NUM_LIT:0> , <NUM_LIT:0> , <NUM_LIT:0> ) ) <EOL> cnt = cnt + <NUM_LIT:1> <EOL> leafprint = '<STR_LIT:U+002CU+0020>' . join ( map ( str , largeleaf ) ) <EOL> else : <EOL> print "<STR_LIT>" <EOL> for i in leafpix : <EOL> pixels [ i ] = ( <NUM_LIT:0> , <NUM_LIT:255> , <NUM_LIT:0> ) <EOL> leafprint = "<STR_LIT>" <EOL> if rCnt < <NUM_LIT:1> : <EOL> rCnt += <NUM_LIT:1> <EOL> scalesize = SSscale . get ( ) <EOL> if scalesize == <NUM_LIT:0> : <EOL> print "<STR_LIT>" <EOL> leafarea = float ( gCnt ) / float ( rCnt ) * scalesize <EOL> Show_pic ( pic ) <EOL> highlightfile = dirF + '<STR_LIT>' <EOL> pixdata = file + '<STR_LIT:U+002CU+0020>' + str ( gCnt ) + '<STR_LIT:U+002CU+0020>' + str ( rCnt ) + '<STR_LIT:U+002CU+0020>' + '<STR_LIT>' % leafarea + '<STR_LIT:U+002C>' + leafprint + '<STR_LIT:\n>' <EOL> return gCnt , rCnt , pic , pixdata <EOL> def test_LA ( ) : <EOL> print "<STR_LIT>" <EOL> global chosfile <EOL> global dirF <EOL> dirF = os . path . dirname ( chosfile ) <EOL> pic = Image . open ( chosfile ) <EOL> xsize , ysize = pic . size <EOL> file = os . path . basename ( chosfile ) <EOL> ( gCnt , rCnt , pic , pixdata ) = Pixel_check ( chosfile , dirF , file ) <EOL> if rCnt < <NUM_LIT:1> : <EOL> rCnt += <NUM_LIT:1> <EOL> scalesize = SSscale . get ( ) <EOL> if scalesize == <NUM_LIT:0> : <EOL> print "<STR_LIT>" <EOL> leafarea = float ( gCnt ) / float ( rCnt ) * scalesize <EOL> if rCnt < <NUM_LIT:2> : <EOL> rCnt = <NUM_LIT:0> <EOL> filelabel = Label ( main , height = <NUM_LIT:1> , width = <NUM_LIT> ) <EOL> speedP = speedPscale . get ( ) <EOL> xsize = xsize / speedP <EOL> ysize = ysize / speedP <EOL> filelabel . configure ( text = file + "<STR_LIT:U+0020>" + str ( xsize ) + "<STR_LIT:x>" + str ( ysize ) ) <EOL> filelabel . grid ( row = <NUM_LIT:1> , column = <NUM_LIT:2> ) <EOL> Pixlabel = Label ( main , height = <NUM_LIT:1> , width = <NUM_LIT> ) <EOL> Pixlabel . configure ( text = "<STR_LIT>" + str ( gCnt ) + "<STR_LIT>" + str ( rCnt ) + "<STR_LIT>" + '<STR_LIT>' % leafarea + "<STR_LIT>" ) <EOL> Pixlabel . grid ( row = <NUM_LIT:2> , column = <NUM_LIT:2> ) <EOL> print "<STR_LIT>" <EOL> def addTocalib ( ) : <EOL> global ConsData <EOL> ConsData = [ <NUM_LIT:0> , <NUM_LIT:0> , <NUM_LIT:0> , <NUM_LIT:0> , <NUM_LIT:0> ] <EOL> minG = minGscale . get ( ) <EOL> minR = minRscale . get ( ) <EOL> ratG = ratGscale . get ( ) <EOL> ratGb = ratGbscale . get ( ) <EOL> ratR = ratRscale . get ( ) <EOL> ConservativeData = auto_Settings ( ConsData ) <EOL> minGscale . set ( minG ) <EOL> ratGscale . set ( ratG ) <EOL> ratGbscale . set ( ratGb ) <EOL> minRscale . set ( minR ) <EOL> ratRscale . set ( ratR ) <EOL> sing_Meas ( ) <EOL> global chosfile <EOL> global dirF <EOL> calibdata = str ( ConservativeData [ <NUM_LIT:0> ] ) + '<STR_LIT:U+002CU+0020>' + str ( ConservativeData [ <NUM_LIT:1> ] ) + '<STR_LIT:U+002CU+0020>' + str ( ConservativeData [ <NUM_LIT:2> ] ) + '<STR_LIT:U+002CU+0020>' + str ( minG ) + '<STR_LIT:U+002CU+0020>' + str ( ratG ) + '<STR_LIT:U+002CU+0020>' + str ( ratGb ) + '<STR_LIT:U+002CU+0020>' + str ( ConservativeData [ <NUM_LIT:3> ] ) + '<STR_LIT:U+002CU+0020>' + str ( ConservativeData [ <NUM_LIT:4> ] ) + '<STR_LIT:U+002CU+0020>' + str ( minR ) + '<STR_LIT:U+002CU+0020>' + str ( ratR ) + '<STR_LIT:\n>' <EOL> dirF = os . path . dirname ( chosfile ) <EOL> Newcalib = dirF + '<STR_LIT>' <EOL> try : <EOL> open ( Newcalib , "<STR_LIT:a>" ) <EOL> except : <EOL> open ( dirF + '<STR_LIT>' , "<STR_LIT:w>" ) <EOL> print "<STR_LIT>" <EOL> with open ( Newcalib , "<STR_LIT:a>" ) as f : <EOL> f . write ( calibdata ) <EOL> print "<STR_LIT>" <EOL> def single_LA ( ) : <EOL> print "<STR_LIT>" <EOL> global chosfile <EOL> global dirF <EOL> dirF = os . path . dirname ( chosfile ) <EOL> pic = Image . open ( chosfile ) <EOL> xsize , ysize = pic . size <EOL> file = os . path . basename ( chosfile ) <EOL> ( gCnt , rCnt , pic , pixdata ) = Pixel_check ( chosfile , dirF , file ) <EOL> if rCnt < <NUM_LIT:1> : <EOL> rCnt += <NUM_LIT:1> <EOL> leafarea = float ( gCnt ) / float ( rCnt ) * <NUM_LIT> <EOL> if rCnt < <NUM_LIT:2> : <EOL> rCnt = <NUM_LIT:0> <EOL> filelabel = Label ( main , height = <NUM_LIT:1> , width = <NUM_LIT> ) <EOL> speedP = speedPscale . get ( ) <EOL> xsize = xsize / speedP <EOL> ysize = ysize / speedP <EOL> filelabel . configure ( text = file + "<STR_LIT:U+0020>" + str ( xsize ) + "<STR_LIT:x>" + str ( ysize ) ) <EOL> filelabel . grid ( row = <NUM_LIT:1> , column = <NUM_LIT:2> ) <EOL> Pixlabel = Label ( main , height = <NUM_LIT:1> , width = <NUM_LIT> ) <EOL> Pixlabel . configure ( text = "<STR_LIT>" + str ( gCnt ) + "<STR_LIT>" + str ( rCnt ) + "<STR_LIT>" + '<STR_LIT>' % leafarea + "<STR_LIT>" ) <EOL> Pixlabel . grid ( row = <NUM_LIT:2> , column = <NUM_LIT:2> ) <EOL> highlightfile = dirF + '<STR_LIT>' <EOL> try : <EOL> with open ( highlightfile , "<STR_LIT:a>" ) as f : <EOL> f . write ( "<STR_LIT>" ) <EOL> f . write ( "<STR_LIT:\n>" ) <EOL> except : <EOL> open ( dirF + '<STR_LIT>' , "<STR_LIT:w>" ) <EOL> print "<STR_LIT>" <EOL> with open ( highlightfile , "<STR_LIT:a>" ) as f : <EOL> f . write ( "<STR_LIT>" ) <EOL> f . write ( "<STR_LIT:\n>" ) <EOL> save_Output ( highlightfile , file , pixdata , pic , dirF ) <EOL> print "<STR_LIT>" <EOL> def run_LA ( ) : <EOL> print "<STR_LIT>" <EOL> global dirS <EOL> global dirF <EOL> global chosfile <EOL> dirS = os . path . abspath ( dirS ) <EOL> dirF = os . path . abspath ( dirF ) <EOL> filesInCurDir = os . listdir ( dirS ) <EOL> try : <EOL> with open ( dirF + '<STR_LIT>' , "<STR_LIT:a>" ) as f : <EOL> f . write ( "<STR_LIT>" ) <EOL> f . write ( "<STR_LIT:\n>" ) <EOL> except : <EOL> open ( dirF + '<STR_LIT>' , "<STR_LIT:w>" ) <EOL> with open ( dirF + '<STR_LIT>' , "<STR_LIT:a>" ) as f : <EOL> f . write ( "<STR_LIT>" ) <EOL> f . write ( "<STR_LIT:\n>" ) <EOL> for file in filesInCurDir : <EOL> curFile = os . path . join ( dirS , file ) <EOL> try : <EOL> pic = Image . open ( curFile ) <EOL> xsize , ysize = pic . size <EOL> except : <EOL> continue <EOL> Show_pic ( pic ) <EOL> chosfile = curFile <EOL> if ( autocheck . get ( ) ) : <EOL> global ConsData <EOL> ConsData = [ <NUM_LIT:0> , <NUM_LIT:0> , <NUM_LIT:0> , <NUM_LIT:0> , <NUM_LIT:0> ] <EOL> auto_Settings ( ConsData ) <EOL> ( gCnt , rCnt , pic , pixdata ) = Pixel_check ( curFile , dirF , file ) <EOL> if rCnt < <NUM_LIT:1> : <EOL> rCnt += <NUM_LIT:1> <EOL> leafarea = float ( gCnt ) / float ( rCnt ) * <NUM_LIT> <EOL> if rCnt < <NUM_LIT:2> : <EOL> rCnt = <NUM_LIT:0> <EOL> filelabel = Label ( main , height = <NUM_LIT:1> , width = <NUM_LIT> ) <EOL> speedP = speedPscale . get ( ) <EOL> xsize = xsize / speedP <EOL> ysize = ysize / speedP <EOL> filelabel . configure ( text = file + "<STR_LIT:U+0020>" + str ( xsize ) + "<STR_LIT:x>" + str ( ysize ) ) <EOL> filelabel . grid ( row = <NUM_LIT:1> , column = <NUM_LIT:2> ) <EOL> Pixlabel = Label ( main , height = <NUM_LIT:1> , width = <NUM_LIT> ) <EOL> Pixlabel . configure ( text = "<STR_LIT>" + str ( gCnt ) + "<STR_LIT>" + str ( rCnt ) + "<STR_LIT>" + '<STR_LIT>' % leafarea + "<STR_LIT>" ) <EOL> Pixlabel . grid ( row = <NUM_LIT:2> , column = <NUM_LIT:2> ) <EOL> highlightfile = dirF + '<STR_LIT>' <EOL> save_Output ( highlightfile , file , pixdata , pic , dirF ) <EOL> print "<STR_LIT>" <EOL> def S_dir ( ) : <EOL> global dirS <EOL> dirS = askdirectory ( ) <EOL> Slabel . configure ( text = dirS ) <EOL> def F_dir ( ) : <EOL> global dirF <EOL> dirF = askdirectory ( ) <EOL> Flabel . configure ( text = dirF ) <EOL> def check_Sett ( ) : <EOL> print "<STR_LIT>" <EOL> run_LA ( ) <EOL> def chos_file ( ) : <EOL> global chosfile <EOL> chosfile = askopenfilename ( filetypes = [ ( "<STR_LIT>" , "<STR_LIT>" ) ] ) <EOL> pic = Image . open ( chosfile ) <EOL> xsize , ysize = pic . size <EOL> Show_pic ( pic ) <EOL> file = os . path . basename ( chosfile ) <EOL> filelabel = Label ( main , height = <NUM_LIT:1> , width = <NUM_LIT> ) <EOL> filelabel . configure ( text = file + "<STR_LIT:U+0020>" + str ( xsize ) + "<STR_LIT:x>" + str ( ysize ) ) <EOL> filelabel . grid ( row = <NUM_LIT:1> , column = <NUM_LIT:2> ) <EOL> Pixlabel = Label ( main , height = <NUM_LIT:1> , width = <NUM_LIT> ) <EOL> Pixlabel . configure ( text = "<STR_LIT:U+0020>" ) <EOL> Pixlabel . grid ( row = <NUM_LIT:2> , column = <NUM_LIT:2> ) <EOL> print "<STR_LIT>" + chosfile <EOL> def chos_calib ( ) : <EOL> global choscalib <EOL> choscalib = askopenfilename ( filetypes = [ ( "<STR_LIT>" , "<STR_LIT>" ) ] ) <EOL> print "<STR_LIT>" <EOL> with open ( choscalib ) as csvfile : <EOL> a = [ row . strip ( ) . split ( '<STR_LIT:U+002C>' ) for row in csvfile ] <EOL> x = [ float ( i [ <NUM_LIT:0> ] ) for i in a ] <EOL> y = [ float ( i [ <NUM_LIT:3> ] ) for i in a ] <EOL> ( m , b ) = polyfit ( x , y , <NUM_LIT:1> ) <EOL> mg = m <EOL> bg = b <EOL> x = [ float ( i [ <NUM_LIT:1> ] ) for i in a ] <EOL> y = [ float ( i [ <NUM_LIT:4> ] ) for i in a ] <EOL> ( m , b ) = polyfit ( x , y , <NUM_LIT:1> ) <EOL> mgr = m <EOL> bgr = b <EOL> x = [ float ( i [ <NUM_LIT:2> ] ) for i in a ] <EOL> y = [ float ( i [ <NUM_LIT:5> ] ) for i in a ] <EOL> ( m , b ) = polyfit ( x , y , <NUM_LIT:1> ) <EOL> mgb = m <EOL> bgb = b <EOL> x = [ float ( i [ <NUM_LIT:6> ] ) for i in a ] <EOL> y = [ float ( i [ <NUM_LIT:8> ] ) for i in a ] <EOL> ( m , b ) = polyfit ( x , y , <NUM_LIT:1> ) <EOL> mmr = m <EOL> bmr = b <EOL> x = [ float ( i [ <NUM_LIT:7> ] ) for i in a ] <EOL> y = [ float ( i [ <NUM_LIT:9> ] ) for i in a ] <EOL> ( m , b ) = polyfit ( x , y , <NUM_LIT:1> ) <EOL> mmg = m <EOL> bmg = b <EOL> print "<STR_LIT>" , mg , "<STR_LIT>" , bg , "<STR_LIT>" , mgr , "<STR_LIT>" , bgr , "<STR_LIT>" , mgb , "<STR_LIT>" , bgb <EOL> print "<STR_LIT>" , mmr , "<STR_LIT>" , bmr , "<STR_LIT>" , mmg , "<STR_LIT>" , bmg <EOL> print "<STR_LIT>" <EOL> return mg , bg , mgr , bgr , mgb , bgb , mmr , bmr , mmg , bmg <EOL> def load_calib ( ) : <EOL> try : <EOL> with open ( os . path . join ( sys . path [ <NUM_LIT:0> ] , "<STR_LIT>" ) ) as csvfile : <EOL> a = [ row . strip ( ) . split ( '<STR_LIT:U+002C>' ) for row in csvfile ] <EOL> x = [ float ( i [ <NUM_LIT:0> ] ) for i in a ] <EOL> y = [ float ( i [ <NUM_LIT:3> ] ) for i in a ] <EOL> ( m , b ) = polyfit ( x , y , <NUM_LIT:1> ) <EOL> print sum ( ( polyval ( polyfit ( x , y , <NUM_LIT:1> ) , x ) - y ) ** <NUM_LIT:2> ) / ( len ( x ) ) <EOL> mg = m <EOL> bg = b <EOL> x = [ float ( i [ <NUM_LIT:1> ] ) for i in a ] <EOL> y = [ float ( i [ <NUM_LIT:4> ] ) for i in a ] <EOL> ( m , b ) = polyfit ( x , y , <NUM_LIT:1> ) <EOL> mgr = m <EOL> bgr = b <EOL> x = [ float ( i [ <NUM_LIT:2> ] ) for i in a ] <EOL> y = [ float ( i [ <NUM_LIT:5> ] ) for i in a ] <EOL> ( m , b ) = polyfit ( x , y , <NUM_LIT:1> ) <EOL> mgb = m <EOL> bgb = b <EOL> x = [ float ( i [ <NUM_LIT:6> ] ) for i in a ] <EOL> y = [ float ( i [ <NUM_LIT:8> ] ) for i in a ] <EOL> ( m , b ) = polyfit ( x , y , <NUM_LIT:1> ) <EOL> mmr = m <EOL> bmr = b <EOL> x = [ float ( i [ <NUM_LIT:7> ] ) for i in a ] <EOL> y = [ float ( i [ <NUM_LIT:9> ] ) for i in a ] <EOL> ( m , b ) = polyfit ( x , y , <NUM_LIT:1> ) <EOL> mmg = m <EOL> bmg = b <EOL> print "<STR_LIT>" <EOL> except : <EOL> mg = <NUM_LIT> <EOL> bg = - <NUM_LIT> <EOL> mgr = <NUM_LIT> <EOL> bgr = <NUM_LIT> <EOL> mgb = <NUM_LIT> <EOL> bgb = <NUM_LIT> <EOL> mmr = <NUM_LIT> <EOL> bmr = - <NUM_LIT> <EOL> mmg = <NUM_LIT> <EOL> bmg = <NUM_LIT> <EOL> print "<STR_LIT>" <EOL> print "<STR_LIT>" <EOL> return mg , bg , mgr , bgr , mgb , bgb , mmr , bmr , mmg , bmg <EOL> def sing_Meas ( ) : <EOL> print "<STR_LIT>" <EOL> test_LA ( ) <EOL> def show_Output ( ) : <EOL> global dirF <EOL> print dirF <EOL> print "<STR_LIT>" <EOL> outputfile = '<STR_LIT>' + dirF + '<STR_LIT>' <EOL> os . system ( outputfile ) <EOL> def save_Output ( highlightfile , file , pixdata , pic , dirF ) : <EOL> print "<STR_LIT>" <EOL> with open ( highlightfile , "<STR_LIT:a>" ) as f : <EOL> f . write ( pixdata ) <EOL> tifffile = file . replace ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> pic . save ( dirF + '<STR_LIT>' + tifffile ) <EOL> def auto_Settings ( WhatData ) : <EOL> global chosfile <EOL> pic = Image . open ( chosfile ) <EOL> speedP = <NUM_LIT:8> <EOL> xsize , ysize = pic . size <EOL> xsize = xsize / speedP <EOL> ysize = ysize / speedP <EOL> pic = pic . resize ( ( xsize , ysize ) ) <EOL> xsize , ysize = pic . size <EOL> print xsize , "<STR_LIT:x>" , ysize <EOL> ratG = <NUM_LIT:2> <EOL> ratGb = <NUM_LIT> <EOL> minG = <NUM_LIT> <EOL> cnt = <NUM_LIT:0> <EOL> lpcntb = <NUM_LIT:0> <EOL> lpcnt = - <NUM_LIT:1> <EOL> pixMinGreen = xsize * ysize * <NUM_LIT> <EOL> pixels = pic . load ( ) <EOL> while cnt < pixMinGreen : <EOL> leafpix = [ ] <EOL> for i in range ( pic . size [ <NUM_LIT:0> ] ) : <EOL> for j in range ( pic . size [ <NUM_LIT:1> ] ) : <EOL> r , g , b = pixels [ i , j ] <EOL> if r * ratG < g and b * ( ratGb ) < g and g > minG : <EOL> leafpix . append ( ( r , g , b ) ) <EOL> lpcnt = lpcnt + <NUM_LIT:1> <EOL> cnt = len ( leafpix ) <EOL> if lpcnt < <NUM_LIT:12> : <EOL> ratG = <NUM_LIT> * ratG <EOL> ratGb = <NUM_LIT> * ratGb <EOL> if lpcnt > <NUM_LIT:11> : <EOL> minG = <NUM_LIT> * minG <EOL> if lpcnt > <NUM_LIT:15> : <EOL> cnt = ( pixMinGreen + <NUM_LIT:10> ) <EOL> print "<STR_LIT>" <EOL> print minG , ratG , ratGb , "<STR_LIT>" , pixMinGreen , "<STR_LIT>" , lpcnt , "<STR_LIT>" <EOL> gavg = <NUM_LIT:0> <EOL> gravg = <NUM_LIT:0> <EOL> bravg = <NUM_LIT:0> <EOL> if cnt == <NUM_LIT:0> : cnt = <NUM_LIT:1> <EOL> for i in leafpix : <EOL> r , g , b = i <EOL> if r < <NUM_LIT:1> : r = g <EOL> if g < <NUM_LIT:1> : g = <NUM_LIT:0.1> <EOL> if b < <NUM_LIT:1> : b = g <EOL> gavg = gavg + g <EOL> gravg = gravg + ( float ( g ) / float ( r ) ) <EOL> bravg = bravg + ( float ( g ) / float ( b ) ) <EOL> gavg = float ( gavg ) / float ( cnt ) <EOL> gravg = float ( gravg ) / float ( cnt ) <EOL> bravg = float ( bravg ) / float ( cnt ) <EOL> global ConsData <EOL> gavg = mgset * gavg + bgset <EOL> if gavg < <NUM_LIT:10> : gavg = <NUM_LIT:10> <EOL> minGscale . set ( gavg ) <EOL> ratGscale . set ( mgrset * gravg + bgrset ) <EOL> ratGbscale . set ( mgbset * bravg + bgbset ) <EOL> ratR = <NUM_LIT:2> <EOL> minR = <NUM_LIT> <EOL> cnt = <NUM_LIT:0> <EOL> lpcntb = <NUM_LIT:0> <EOL> lpcnt = <NUM_LIT:0> <EOL> while cnt < pixMinGreen : <EOL> scalepix = [ ] <EOL> for i in range ( pic . size [ <NUM_LIT:0> ] ) : <EOL> for j in range ( pic . size [ <NUM_LIT:1> ] ) : <EOL> r , g , b = pixels [ i , j ] <EOL> if g * ratR < r and b * ( ratR ) < r and r > minR : <EOL> scalepix . append ( ( r , g , b ) ) <EOL> cnt = len ( scalepix ) <EOL> lpcnt = lpcnt + <NUM_LIT:1> <EOL> if lpcnt < <NUM_LIT:8> : <EOL> ratR = <NUM_LIT> * ratR <EOL> if lpcnt > <NUM_LIT:7> : <EOL> ratR = <NUM_LIT:2> <EOL> minR = <NUM_LIT> * minR <EOL> if lpcnt > <NUM_LIT:10> : <EOL> cnt = ( pixMinGreen + <NUM_LIT:10> ) <EOL> print minR , ratR , "<STR_LIT>" , pixMinGreen , "<STR_LIT>" , lpcnt , "<STR_LIT>" <EOL> ravg = <NUM_LIT:0> <EOL> rgavg = <NUM_LIT:0> <EOL> rbavg = <NUM_LIT:0> <EOL> cnt = len ( scalepix ) <EOL> if cnt > <NUM_LIT:0> : <EOL> for i in scalepix : <EOL> r , g , b = i <EOL> if g < <NUM_LIT:1> : g = r <EOL> if b < <NUM_LIT:1> : b = r <EOL> ravg = ravg + r <EOL> rgavg = rgavg + ( float ( r ) / float ( g ) ) <EOL> rbavg = rbavg + ( float ( r ) / float ( b ) ) <EOL> ravg = float ( ravg ) / float ( cnt ) <EOL> rgavg = float ( rgavg ) / float ( cnt ) <EOL> rbavg = float ( rbavg ) / float ( cnt ) <EOL> rgavg = ( rgavg + rbavg ) / <NUM_LIT:2> <EOL> rrat = mmrgset * rgavg + bmrgset <EOL> if rrat < <NUM_LIT> : rrat = <NUM_LIT> <EOL> minRscale . set ( mmrset * ravg + bmrset ) <EOL> ratRscale . set ( rrat ) <EOL> else : <EOL> minRscale . set ( <NUM_LIT:255> ) <EOL> ratRscale . set ( <NUM_LIT:2> ) <EOL> print "<STR_LIT>" <EOL> ConsData = [ gavg , gravg , bravg , ravg , rgavg ] <EOL> print ravg , mmrset , bmrset , ( mmrset * ravg + bmrset ) <EOL> return ConsData <EOL> def auto_Sing ( ) : <EOL> global ConsData <EOL> ConsData = [ <NUM_LIT:0> , <NUM_LIT:0> , <NUM_LIT:0> , <NUM_LIT:0> , <NUM_LIT:0> ] <EOL> auto_Settings ( ConsData ) <EOL> sing_Meas ( ) <EOL> def calib_set ( ) : <EOL> global mgset , bgset , mgrset , bgrset , mgbset , bgbset , mmrset , bmrset , mmrgset , bmrgset <EOL> mgset , bgset , mgrset , bgrset , mgbset , bgbset , mmrset , bmrset , mmrgset , bmrgset = chos_calib ( ) <EOL> mgset , bgset , mgrset , bgrset , mgbset , bgbset , mmrset , bmrset , mmrgset , bmrgset = load_calib ( ) <EOL> main = Tk ( ) <EOL> main . title ( "<STR_LIT>" ) <EOL> Frame1 = Frame ( main ) <EOL> Frame1 . grid ( row = <NUM_LIT:1> , column = <NUM_LIT:1> , rowspan = <NUM_LIT> ) <EOL> runsingbut = Button ( Frame1 , text = "<STR_LIT>" , command = test_LA ) <EOL> saveresults = Button ( Frame1 , text = "<STR_LIT>" , command = single_LA ) <EOL> SObut = Button ( main , text = "<STR_LIT>" , command = show_Output ) <EOL> singbut = Button ( Frame1 , text = "<STR_LIT>" , command = chos_file ) <EOL> singlabel = Label ( Frame1 ) <EOL> loadcalibbut = Button ( Frame1 , text = "<STR_LIT>" , command = calib_set ) <EOL> Batchlabel = Label ( Frame1 ) <EOL> Batchlabel . configure ( text = "<STR_LIT>" ) <EOL> dirS = "<STR_LIT>" <EOL> Sbut = Button ( Frame1 , text = "<STR_LIT>" , command = S_dir ) <EOL> Slabel = Label ( Frame1 ) <EOL> Slabel . configure ( text = "<STR_LIT>" ) <EOL> dirF = "<STR_LIT>" <EOL> Fbut = Button ( Frame1 , text = "<STR_LIT>" , command = F_dir ) <EOL> Flabel = Label ( Frame1 ) <EOL> Flabel . configure ( text = "<STR_LIT>" ) <EOL> CSbut = Button ( Frame1 , text = "<STR_LIT>" , command = check_Sett ) <EOL> Frame3 = Frame ( main ) <EOL> Frame3 . grid ( row = <NUM_LIT:1> , column = <NUM_LIT:3> , rowspan = <NUM_LIT:10> ) <EOL> addTocalibbut = Button ( Frame1 , text = "<STR_LIT>" , command = addTocalib ) <EOL> minG = <NUM_LIT:100> <EOL> minGscale = Scale ( Frame3 , from_ = <NUM_LIT:0> , to = <NUM_LIT:255> , label = "<STR_LIT>" , orient = HORIZONTAL , tickinterval = <NUM_LIT:50> , length = <NUM_LIT> , variable = minG ) <EOL> minGscale . set ( <NUM_LIT> ) <EOL> minR = <NUM_LIT:200> <EOL> minRscale = Scale ( Frame3 , from_ = <NUM_LIT:0> , to = <NUM_LIT:255> , label = "<STR_LIT>" , orient = HORIZONTAL , tickinterval = <NUM_LIT:50> , length = <NUM_LIT> , variable = minR ) <EOL> minRscale . set ( <NUM_LIT> ) <EOL> ratG = <NUM_LIT> <EOL> ratGscale = Scale ( Frame3 , from_ = <NUM_LIT> , to = <NUM_LIT:2> , resolution = <NUM_LIT> , label = "<STR_LIT>" , orient = HORIZONTAL , tickinterval = <NUM_LIT:0.5> , length = <NUM_LIT:200> , variable = ratG ) <EOL> ratGscale . set ( <NUM_LIT> ) <EOL> ratGb = <NUM_LIT> <EOL> ratGbscale = Scale ( Frame3 , from_ = <NUM_LIT> , to = <NUM_LIT:2> , resolution = <NUM_LIT> , label = "<STR_LIT>" , orient = HORIZONTAL , tickinterval = <NUM_LIT:0.5> , length = <NUM_LIT:200> , variable = ratGb ) <EOL> ratGbscale . set ( <NUM_LIT> ) <EOL> ratR = <NUM_LIT> <EOL> ratRscale = Scale ( Frame3 , from_ = <NUM_LIT:1> , to = <NUM_LIT:2> , resolution = <NUM_LIT> , label = "<STR_LIT>" , orient = HORIZONTAL , tickinterval = <NUM_LIT:0.5> , length = <NUM_LIT:200> , variable = ratR ) <EOL> ratRscale . set ( <NUM_LIT> ) <EOL> speedP = <NUM_LIT:1> <EOL> speedPscale = Scale ( Frame3 , from_ = <NUM_LIT:1> , to = <NUM_LIT:4> , resolution = <NUM_LIT:1> , label = "<STR_LIT>" , orient = HORIZONTAL , tickinterval = <NUM_LIT:1> , length = <NUM_LIT:200> , variable = speedP ) <EOL> speedPscale . set ( <NUM_LIT:4> ) <EOL> minPsize = <NUM_LIT> <EOL> minPscale = Scale ( Frame3 , from_ = <NUM_LIT:1> , to = <NUM_LIT> , resolution = <NUM_LIT:10> , label = "<STR_LIT>" , orient = HORIZONTAL , tickinterval = <NUM_LIT:1000> , length = <NUM_LIT> , variable = minPsize ) <EOL> minPscale . set ( <NUM_LIT:0> ) <EOL> Scalesize = <NUM_LIT> <EOL> SSscale = Scale ( Frame3 , from_ = <NUM_LIT:0> , to = <NUM_LIT:20> , resolution = <NUM_LIT:0.1> , label = "<STR_LIT>" , orient = HORIZONTAL , tickinterval = <NUM_LIT:4> , length = <NUM_LIT> , variable = Scalesize ) <EOL> SSscale . set ( <NUM_LIT:4> ) <EOL> flipPic = IntVar ( ) <EOL> C1 = Checkbutton ( Frame1 , text = "<STR_LIT>" , variable = flipPic ) <EOL> flipPic . get ( ) <EOL> rotPic = IntVar ( ) <EOL> C2 = Checkbutton ( Frame1 , text = "<STR_LIT>" , variable = rotPic ) <EOL> rotPic . get ( ) <EOL> delBack = IntVar ( ) <EOL> C3 = Checkbutton ( Frame1 , text = "<STR_LIT>" , variable = delBack ) <EOL> delBack . get ( ) <EOL> labpix = IntVar ( ) <EOL> C5 = Checkbutton ( main , text = "<STR_LIT>" , variable = labpix ) <EOL> labpix . get ( ) <EOL> ThereCanBeOnlyOne = IntVar ( ) <EOL> C6 = Checkbutton ( main , text = "<STR_LIT>" , variable = ThereCanBeOnlyOne ) <EOL> ThereCanBeOnlyOne . get ( ) <EOL> autosetbut = Button ( Frame1 , text = "<STR_LIT>" , command = auto_Sing ) <EOL> autocheck = IntVar ( ) <EOL> C4 = Checkbutton ( Frame1 , text = "<STR_LIT>" , variable = autocheck ) <EOL> autocheck . get ( ) <EOL> singbut . grid ( row = <NUM_LIT:1> , column = <NUM_LIT:1> , pady = <NUM_LIT:5> ) <EOL> autosetbut . grid ( row = <NUM_LIT:2> , column = <NUM_LIT:1> , pady = <NUM_LIT:5> ) <EOL> runsingbut . grid ( row = <NUM_LIT:3> , column = <NUM_LIT:1> , pady = <NUM_LIT:5> ) <EOL> saveresults . grid ( row = <NUM_LIT:4> , column = <NUM_LIT:1> , pady = <NUM_LIT:5> ) <EOL> C1 . grid ( row = <NUM_LIT:5> , column = <NUM_LIT:1> , pady = <NUM_LIT:5> ) <EOL> C2 . grid ( row = <NUM_LIT:6> , column = <NUM_LIT:1> , pady = <NUM_LIT:5> ) <EOL> C3 . grid ( row = <NUM_LIT:7> , column = <NUM_LIT:1> , pady = <NUM_LIT:5> ) <EOL> Batchlabel . grid ( row = <NUM_LIT:9> , column = <NUM_LIT:1> , pady = <NUM_LIT:10> ) <EOL> Sbut . grid ( row = <NUM_LIT:10> , column = <NUM_LIT:1> , pady = <NUM_LIT:5> ) <EOL> Slabel . grid ( row = <NUM_LIT:11> , column = <NUM_LIT:1> , pady = <NUM_LIT:5> ) <EOL> Fbut . grid ( row = <NUM_LIT:12> , column = <NUM_LIT:1> , pady = <NUM_LIT:5> ) <EOL> Flabel . grid ( row = <NUM_LIT> , column = <NUM_LIT:1> , pady = <NUM_LIT:5> ) <EOL> CSbut . grid ( row = <NUM_LIT> , column = <NUM_LIT:1> , pady = <NUM_LIT:5> ) <EOL> C4 . grid ( row = <NUM_LIT:15> , column = <NUM_LIT:1> , pady = <NUM_LIT:5> ) <EOL> loadcalibbut . grid ( row = <NUM_LIT:16> , column = <NUM_LIT:1> , pady = <NUM_LIT:5> ) <EOL> addTocalibbut . grid ( row = <NUM_LIT> , column = <NUM_LIT:1> , pady = <NUM_LIT:5> ) <EOL> C6 . grid ( row = <NUM_LIT:15> , column = <NUM_LIT:3> , pady = <NUM_LIT:5> ) <EOL> minGscale . grid ( row = <NUM_LIT:1> , column = <NUM_LIT:3> ) <EOL> ratGscale . grid ( row = <NUM_LIT:2> , column = <NUM_LIT:3> ) <EOL> ratGbscale . grid ( row = <NUM_LIT:3> , column = <NUM_LIT:3> ) <EOL> minRscale . grid ( row = <NUM_LIT:4> , column = <NUM_LIT:3> ) <EOL> ratRscale . grid ( row = <NUM_LIT:5> , column = <NUM_LIT:3> ) <EOL> speedPscale . grid ( row = <NUM_LIT:7> , column = <NUM_LIT:3> ) <EOL> minPscale . grid ( row = <NUM_LIT:8> , column = <NUM_LIT:3> ) <EOL> SSscale . grid ( row = <NUM_LIT:6> , column = <NUM_LIT:3> ) <EOL> filelabel = Label ( main , height = <NUM_LIT:1> , width = <NUM_LIT:100> ) <EOL> filelabel . configure ( text = "<STR_LIT:U+0020>" ) <EOL> filelabel . grid ( row = <NUM_LIT:1> , column = <NUM_LIT:2> ) <EOL> SObut . grid ( row = <NUM_LIT:3> , column = <NUM_LIT:2> ) <EOL> C5 . grid ( row = <NUM_LIT:4> , column = <NUM_LIT:2> ) <EOL> main . mainloop ( ) </s>
<s> from . base import ClimataTestCase <EOL> from climata . snotel import ( <EOL> StationIO , StationDailyDataIO , RegionDailyDataIO , ElementIO <EOL> ) <EOL> class SnotelTestCase ( ClimataTestCase ) : <EOL> def test_station ( self ) : <EOL> data = StationIO ( <EOL> basin = '<STR_LIT>' , <EOL> ) <EOL> self . assertGreater ( len ( data ) , <NUM_LIT:0> ) <EOL> item = data [ <NUM_LIT:0> ] <EOL> self . assertHasFields ( <EOL> item , ( "<STR_LIT:name>" , "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" ) <EOL> ) <EOL> def test_station_daily_data ( self ) : <EOL> data = StationDailyDataIO ( <EOL> station = '<STR_LIT>' , <EOL> start_date = '<STR_LIT>' , <EOL> end_date = '<STR_LIT>' , <EOL> ) <EOL> item = data [ <NUM_LIT:0> ] <EOL> self . assertHasFields ( <EOL> item , ( <EOL> "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" <EOL> ) <EOL> ) <EOL> self . assertHasFields ( <EOL> item . data [ <NUM_LIT:0> ] , ( "<STR_LIT:value>" , "<STR_LIT>" , "<STR_LIT:date>" ) <EOL> ) <EOL> def test_region_daily_data ( self ) : <EOL> data = RegionDailyDataIO ( <EOL> basin = '<STR_LIT>' , <EOL> start_date = '<STR_LIT>' , <EOL> end_date = '<STR_LIT>' , <EOL> ) <EOL> for site in data : <EOL> self . assertHasFields ( <EOL> site , ( "<STR_LIT:name>" , "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" ) <EOL> ) <EOL> if len ( site . data ) > <NUM_LIT:0> : <EOL> self . assertHasFields ( <EOL> site . data [ <NUM_LIT:0> ] , ( "<STR_LIT>" , "<STR_LIT:value>" , "<STR_LIT>" , "<STR_LIT:date>" ) <EOL> ) <EOL> def test_element ( self ) : <EOL> data = ElementIO ( ) <EOL> item = data [ <NUM_LIT:0> ] <EOL> self . assertHasFields ( item , ( "<STR_LIT>" , "<STR_LIT:name>" , "<STR_LIT>" ) ) </s>
<s> from models . card import Card <EOL> from modules . validations import is_required , is_string , is_list , is_list_of_strings , has_max_length , is_integer <EOL> media = ( <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT:image>' , <EOL> '<STR_LIT>' <EOL> ) <EOL> class UploadCard ( Card ) : <EOL> schema = dict ( Card . schema . copy ( ) , ** { <EOL> '<STR_LIT:body>' : { <EOL> '<STR_LIT>' : ( is_required , is_string , ) <EOL> } , <EOL> '<STR_LIT>' : { <EOL> '<STR_LIT>' : ( is_required , is_list , is_list_of_strings , ) , <EOL> } , <EOL> '<STR_LIT>' : { <EOL> '<STR_LIT>' : ( is_required , is_list , ( has_max_length , <NUM_LIT:5> ) ) , <EOL> '<STR_LIT>' : { <EOL> '<STR_LIT:body>' : { <EOL> '<STR_LIT>' : ( is_required , is_string , ) , <EOL> } , <EOL> '<STR_LIT:value>' : { <EOL> '<STR_LIT>' : ( is_required , is_integer , ) , <EOL> '<STR_LIT:default>' : <NUM_LIT:1> , <EOL> } , <EOL> '<STR_LIT>' : { <EOL> '<STR_LIT>' : ( is_required , is_string , ) , <EOL> } , <EOL> '<STR_LIT>' : { <EOL> '<STR_LIT>' : ( is_required , is_string , ) , <EOL> } , <EOL> '<STR_LIT>' : { <EOL> '<STR_LIT>' : ( is_required , is_string , ) , <EOL> } , <EOL> } , <EOL> } , <EOL> } ) <EOL> def __init__ ( self , fields = None ) : <EOL> """<STR_LIT>""" <EOL> super ( ) . __init__ ( fields ) <EOL> self [ '<STR_LIT>' ] = '<STR_LIT>' <EOL> def validate_response ( self , response ) : <EOL> """<STR_LIT>""" <EOL> return [ ] </s>
<s> """<STR_LIT>""" <EOL> from models . card_parameters import CardParameters <EOL> from modules . sequencer . formulas import update as formula_update <EOL> from modules . sequencer . params import init_learned <EOL> from models . response import Response <EOL> from time import time <EOL> """<STR_LIT>""" <EOL> def update ( db_conn , user , card , response ) : <EOL> """<STR_LIT>""" <EOL> if not card . has_assessment ( ) : <EOL> return { <EOL> '<STR_LIT>' : Response ( { } ) , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> } <EOL> errors = card . validate_response ( response ) <EOL> if errors : <EOL> return { '<STR_LIT>' : errors } <EOL> score , feedback = card . score_response ( response ) <EOL> response = Response ( { <EOL> '<STR_LIT>' : user [ '<STR_LIT:id>' ] , <EOL> '<STR_LIT>' : card [ '<STR_LIT>' ] , <EOL> '<STR_LIT>' : card [ '<STR_LIT>' ] , <EOL> '<STR_LIT>' : response , <EOL> '<STR_LIT>' : score , <EOL> } ) <EOL> card_parameters = CardParameters . get ( db_conn , entity_id = card [ '<STR_LIT>' ] ) <EOL> previous_response = Response . get_latest ( db_conn , <EOL> user_id = user [ '<STR_LIT:id>' ] , <EOL> unit_id = card [ '<STR_LIT>' ] ) <EOL> now = time ( ) <EOL> time_delta = now - ( int ( previous_response [ '<STR_LIT>' ] . strftime ( "<STR_LIT:%s>" ) ) <EOL> if previous_response else now ) <EOL> learned = ( previous_response [ '<STR_LIT>' ] <EOL> if previous_response else init_learned ) <EOL> guess_distribution = card_parameters . get_distribution ( '<STR_LIT>' ) <EOL> slip_distribution = card_parameters . get_distribution ( '<STR_LIT>' ) <EOL> updates = formula_update ( score , time_delta , <EOL> learned , guess_distribution , slip_distribution ) <EOL> response [ '<STR_LIT>' ] = updates [ '<STR_LIT>' ] <EOL> response , errors = response . save ( db_conn ) <EOL> if errors : <EOL> return { '<STR_LIT>' : errors , '<STR_LIT>' : feedback } <EOL> card_parameters . set_distribution ( '<STR_LIT>' , updates [ '<STR_LIT>' ] ) <EOL> card_parameters . set_distribution ( '<STR_LIT>' , updates [ '<STR_LIT>' ] ) <EOL> card_parameters , errors = card_parameters . save ( db_conn ) <EOL> if errors : <EOL> return { '<STR_LIT>' : errors , '<STR_LIT>' : feedback } <EOL> return { '<STR_LIT>' : response , '<STR_LIT>' : feedback } </s>
<s> import pytest <EOL> xfail = pytest . mark . xfail <EOL> from conftest import create_user_in_db , log_in <EOL> from framework . session import get_current_user , log_in_user , log_out_user <EOL> from models . user import User <EOL> from framework . redis import redis <EOL> def test_get_current_user ( users_table , db_conn ) : <EOL> """<STR_LIT>""" <EOL> create_user_in_db ( users_table , db_conn ) <EOL> token = log_in ( ) <EOL> user = get_current_user ( { <EOL> '<STR_LIT>' : { '<STR_LIT>' : token } , <EOL> '<STR_LIT>' : db_conn , <EOL> } ) <EOL> assert user <EOL> assert user [ '<STR_LIT:id>' ] == '<STR_LIT>' <EOL> def test_log_in_user ( users_table , db_conn ) : <EOL> """<STR_LIT>""" <EOL> create_user_in_db ( users_table , db_conn ) <EOL> user = User . get ( db_conn , id = '<STR_LIT>' ) <EOL> token = log_in_user ( user ) <EOL> assert token <EOL> assert redis . get ( token ) . decode ( ) == '<STR_LIT>' <EOL> def test_log_out_user ( users_table , db_conn ) : <EOL> """<STR_LIT>""" <EOL> create_user_in_db ( users_table , db_conn ) <EOL> user = User . get ( db_conn , id = '<STR_LIT>' ) <EOL> token = log_in_user ( user ) <EOL> assert redis . get ( token ) . decode ( ) == '<STR_LIT>' <EOL> log_out_user ( { <EOL> '<STR_LIT>' : { '<STR_LIT>' : token } , <EOL> '<STR_LIT>' : db_conn , <EOL> } ) <EOL> assert redis . get ( token ) is None </s>
<s> from modules import content <EOL> import pytest <EOL> xfail = pytest . mark . xfail <EOL> def test_get ( ) : <EOL> assert content . get ( '<STR_LIT>' ) == '<STR_LIT>' <EOL> assert content . get ( '<STR_LIT>' , '<STR_LIT>' ) == '<STR_LIT>' <EOL> def test_get_default ( ) : <EOL> assert ( content . get ( '<STR_LIT>' ) == <EOL> content . get ( '<STR_LIT>' , '<STR_LIT>' ) ) <EOL> @ xfail <EOL> def test_get_no_country ( ) : <EOL> assert False </s>
<s> import pytest <EOL> xfail = pytest . mark . xfail <EOL> @ xfail <EOL> def test_version ( app ) : <EOL> """<STR_LIT>""" <EOL> assert False <EOL> @ xfail <EOL> def test_version_name ( app ) : <EOL> """<STR_LIT>""" <EOL> assert False <EOL> @ xfail <EOL> def test_version_entity ( app ) : <EOL> """<STR_LIT>""" <EOL> assert False <EOL> @ xfail <EOL> def test_version_entity_kind ( app ) : <EOL> """<STR_LIT>""" <EOL> assert False <EOL> @ xfail <EOL> def test_version_accepted ( app ) : <EOL> """<STR_LIT>""" <EOL> assert False </s>
<s> from __future__ import unicode_literals <EOL> from django . db import models , migrations <EOL> from django . conf import settings <EOL> class Migration ( migrations . Migration ) : <EOL> dependencies = [ <EOL> migrations . swappable_dependency ( settings . AUTH_USER_MODEL ) , <EOL> ( '<STR_LIT>' , '<STR_LIT>' ) , <EOL> ] <EOL> operations = [ <EOL> migrations . AddField ( <EOL> model_name = '<STR_LIT>' , <EOL> name = '<STR_LIT:user>' , <EOL> field = models . ForeignKey ( related_name = '<STR_LIT>' , null = True , blank = True , to = settings . AUTH_USER_MODEL , unique = True ) , <EOL> preserve_default = True , <EOL> ) , <EOL> ] </s>
<s> from django . views . generic import TemplateView <EOL> from simplepage . views import NaviMixin <EOL> class IndexTemplateView ( NaviMixin , TemplateView ) : <EOL> template_name = '<STR_LIT>' </s>
<s> import os <EOL> import sys <EOL> PY3 = sys . version_info [ <NUM_LIT:0> ] == <NUM_LIT:3> <EOL> if PY3 : <EOL> from configparser import ConfigParser <EOL> else : <EOL> from ConfigParser import SafeConfigParser as ConfigParser <EOL> class UndefinedValueError ( Exception ) : <EOL> pass <EOL> class Undefined ( object ) : <EOL> """<STR_LIT>""" <EOL> pass <EOL> undefined = Undefined ( ) <EOL> class Config ( object ) : <EOL> """<STR_LIT>""" <EOL> _BOOLEANS = { '<STR_LIT:1>' : True , '<STR_LIT:yes>' : True , '<STR_LIT:true>' : True , '<STR_LIT>' : True , <EOL> '<STR_LIT:0>' : False , '<STR_LIT>' : False , '<STR_LIT:false>' : False , '<STR_LIT>' : False } <EOL> def __init__ ( self , repository ) : <EOL> self . repository = repository <EOL> def _cast_boolean ( self , value ) : <EOL> """<STR_LIT>""" <EOL> if value . lower ( ) not in self . _BOOLEANS : <EOL> raise ValueError ( '<STR_LIT>' % value ) <EOL> return self . _BOOLEANS [ value . lower ( ) ] <EOL> def get ( self , option , default = undefined , cast = undefined ) : <EOL> """<STR_LIT>""" <EOL> if option in self . repository : <EOL> value = self . repository . get ( option ) <EOL> else : <EOL> value = default <EOL> if isinstance ( value , Undefined ) : <EOL> raise UndefinedValueError ( '<STR_LIT>' % option ) <EOL> if isinstance ( cast , Undefined ) : <EOL> cast = lambda v : v <EOL> elif cast is bool : <EOL> cast = self . _cast_boolean <EOL> return cast ( value ) <EOL> def __call__ ( self , * args , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> return self . get ( * args , ** kwargs ) <EOL> class RepositoryBase ( object ) : <EOL> def __init__ ( self , source ) : <EOL> raise NotImplementedError <EOL> def __contains__ ( self , key ) : <EOL> raise NotImplementedError <EOL> def get ( self , key ) : <EOL> raise NotImplementedError <EOL> class RepositoryIni ( RepositoryBase ) : <EOL> """<STR_LIT>""" <EOL> SECTION = '<STR_LIT>' <EOL> def __init__ ( self , source ) : <EOL> self . parser = ConfigParser ( ) <EOL> self . parser . readfp ( open ( source ) ) <EOL> def __contains__ ( self , key ) : <EOL> return self . parser . has_option ( self . SECTION , key ) <EOL> def get ( self , key ) : <EOL> return self . parser . get ( self . SECTION , key ) <EOL> class RepositoryEnv ( RepositoryBase ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , source ) : <EOL> self . data = { } <EOL> for line in open ( source ) : <EOL> line = line . strip ( ) <EOL> if not line or line . startswith ( '<STR_LIT:#>' ) or '<STR_LIT:=>' not in line : <EOL> continue <EOL> k , v = line . split ( '<STR_LIT:=>' , <NUM_LIT:1> ) <EOL> v = v . strip ( "<STR_LIT:'>" ) . strip ( '<STR_LIT:">' ) <EOL> self . data [ k ] = v <EOL> def __contains__ ( self , key ) : <EOL> return key in self . data or key in os . environ <EOL> def get ( self , key ) : <EOL> return self . data . get ( key ) or os . environ [ key ] <EOL> class RepositoryShell ( RepositoryBase ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , source = None ) : <EOL> pass <EOL> def __contains__ ( self , key ) : <EOL> return key in os . environ <EOL> def get ( self , key ) : <EOL> return os . environ [ key ] <EOL> class AutoConfig ( object ) : <EOL> """<STR_LIT>""" <EOL> SUPPORTED = { <EOL> '<STR_LIT>' : RepositoryIni , <EOL> '<STR_LIT>' : RepositoryEnv , <EOL> } <EOL> def __init__ ( self ) : <EOL> self . config = None <EOL> def _find_file ( self , path ) : <EOL> for configfile in self . SUPPORTED : <EOL> filename = os . path . join ( path , configfile ) <EOL> if os . path . exists ( filename ) : <EOL> return filename <EOL> parent = os . path . dirname ( path ) <EOL> if parent and parent != os . path . sep : <EOL> return self . _find_file ( parent ) <EOL> return '<STR_LIT>' <EOL> def _load ( self , path ) : <EOL> try : <EOL> filename = self . _find_file ( path ) <EOL> except Exception : <EOL> filename = '<STR_LIT>' <EOL> Repository = self . SUPPORTED . get ( os . path . basename ( filename ) ) <EOL> if not Repository : <EOL> Repository = RepositoryShell <EOL> self . config = Config ( Repository ( filename ) ) <EOL> def _caller_path ( self ) : <EOL> frame = sys . _getframe ( ) <EOL> path = os . path . dirname ( frame . f_back . f_back . f_code . co_filename ) <EOL> return path <EOL> def __call__ ( self , * args , ** kwargs ) : <EOL> if not self . config : <EOL> self . _load ( self . _caller_path ( ) ) <EOL> return self . config ( * args , ** kwargs ) <EOL> config = AutoConfig ( ) </s>
<s> import os <EOL> import sys <EOL> import string <EOL> from shlex import shlex <EOL> PY3 = sys . version_info [ <NUM_LIT:0> ] == <NUM_LIT:3> <EOL> if PY3 : <EOL> from configparser import ConfigParser <EOL> text_type = str <EOL> else : <EOL> from ConfigParser import SafeConfigParser as ConfigParser <EOL> text_type = unicode <EOL> class UndefinedValueError ( Exception ) : <EOL> pass <EOL> class Undefined ( object ) : <EOL> """<STR_LIT>""" <EOL> pass <EOL> undefined = Undefined ( ) <EOL> class Config ( object ) : <EOL> """<STR_LIT>""" <EOL> _BOOLEANS = { '<STR_LIT:1>' : True , '<STR_LIT:yes>' : True , '<STR_LIT:true>' : True , '<STR_LIT>' : True , <EOL> '<STR_LIT:0>' : False , '<STR_LIT>' : False , '<STR_LIT:false>' : False , '<STR_LIT>' : False } <EOL> def __init__ ( self , repository ) : <EOL> self . repository = repository <EOL> def _cast_boolean ( self , value ) : <EOL> """<STR_LIT>""" <EOL> value = str ( value ) <EOL> if value . lower ( ) not in self . _BOOLEANS : <EOL> raise ValueError ( '<STR_LIT>' % value ) <EOL> return self . _BOOLEANS [ value . lower ( ) ] <EOL> def get ( self , option , default = undefined , cast = undefined ) : <EOL> """<STR_LIT>""" <EOL> if option in self . repository : <EOL> value = self . repository . get ( option ) <EOL> else : <EOL> value = default <EOL> if isinstance ( value , Undefined ) : <EOL> raise UndefinedValueError ( '<STR_LIT>' % option ) <EOL> if isinstance ( cast , Undefined ) : <EOL> cast = lambda v : v <EOL> elif cast is bool : <EOL> cast = self . _cast_boolean <EOL> return cast ( value ) <EOL> def __call__ ( self , * args , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> return self . get ( * args , ** kwargs ) <EOL> class RepositoryBase ( object ) : <EOL> def __init__ ( self , source ) : <EOL> raise NotImplementedError <EOL> def __contains__ ( self , key ) : <EOL> raise NotImplementedError <EOL> def get ( self , key ) : <EOL> raise NotImplementedError <EOL> class RepositoryIni ( RepositoryBase ) : <EOL> """<STR_LIT>""" <EOL> SECTION = '<STR_LIT>' <EOL> def __init__ ( self , source ) : <EOL> self . parser = ConfigParser ( ) <EOL> self . parser . readfp ( open ( source ) ) <EOL> def __contains__ ( self , key ) : <EOL> return ( key in os . environ or <EOL> self . parser . has_option ( self . SECTION , key ) ) <EOL> def get ( self , key ) : <EOL> return ( os . environ . get ( key ) or <EOL> self . parser . get ( self . SECTION , key ) ) <EOL> class RepositoryEnv ( RepositoryBase ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , source ) : <EOL> self . data = { } <EOL> for line in open ( source ) : <EOL> line = line . strip ( ) <EOL> if not line or line . startswith ( '<STR_LIT:#>' ) or '<STR_LIT:=>' not in line : <EOL> continue <EOL> k , v = line . split ( '<STR_LIT:=>' , <NUM_LIT:1> ) <EOL> k = k . strip ( ) <EOL> v = v . strip ( ) . strip ( '<STR_LIT>' ) <EOL> self . data [ k ] = v <EOL> def __contains__ ( self , key ) : <EOL> return key in os . environ or key in self . data <EOL> def get ( self , key ) : <EOL> return os . environ . get ( key ) or self . data [ key ] <EOL> class RepositoryShell ( RepositoryBase ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , source = None ) : <EOL> pass <EOL> def __contains__ ( self , key ) : <EOL> return key in os . environ <EOL> def get ( self , key ) : <EOL> return os . environ [ key ] <EOL> class AutoConfig ( object ) : <EOL> """<STR_LIT>""" <EOL> SUPPORTED = { <EOL> '<STR_LIT>' : RepositoryIni , <EOL> '<STR_LIT>' : RepositoryEnv , <EOL> } <EOL> def __init__ ( self ) : <EOL> self . config = None <EOL> def _find_file ( self , path ) : <EOL> for configfile in self . SUPPORTED : <EOL> filename = os . path . join ( path , configfile ) <EOL> if os . path . isfile ( filename ) : <EOL> return filename <EOL> parent = os . path . dirname ( path ) <EOL> if parent and parent != os . path . sep : <EOL> return self . _find_file ( parent ) <EOL> return '<STR_LIT>' <EOL> def _load ( self , path ) : <EOL> try : <EOL> filename = self . _find_file ( os . path . abspath ( path ) ) <EOL> except Exception : <EOL> filename = '<STR_LIT>' <EOL> Repository = self . SUPPORTED . get ( os . path . basename ( filename ) ) <EOL> if not Repository : <EOL> Repository = RepositoryShell <EOL> self . config = Config ( Repository ( filename ) ) <EOL> def _caller_path ( self ) : <EOL> frame = sys . _getframe ( ) <EOL> path = os . path . dirname ( frame . f_back . f_back . f_code . co_filename ) <EOL> return path <EOL> def __call__ ( self , * args , ** kwargs ) : <EOL> if not self . config : <EOL> self . _load ( self . _caller_path ( ) ) <EOL> return self . config ( * args , ** kwargs ) <EOL> config = AutoConfig ( ) <EOL> class Csv ( object ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , cast = text_type , delimiter = '<STR_LIT:U+002C>' , strip = string . whitespace ) : <EOL> """<STR_LIT>""" <EOL> self . cast = cast <EOL> self . delimiter = delimiter <EOL> self . strip = strip <EOL> def __call__ ( self , value ) : <EOL> """<STR_LIT>""" <EOL> transform = lambda s : self . cast ( s . strip ( self . strip ) ) <EOL> splitter = shlex ( value , posix = True ) <EOL> splitter . whitespace = self . delimiter <EOL> splitter . whitespace_split = True <EOL> return [ transform ( s ) for s in splitter ] </s>
<s> import re <EOL> import unittest <EOL> import salesforce_oauth_request <EOL> from salesforce_bulk import SalesforceBulk <EOL> class SalesforceBulkTest ( unittest . TestCase ) : <EOL> def __init__ ( self , testName , endpoint , sessionId ) : <EOL> super ( SalesforceBulkTest , self ) . __init__ ( testName ) <EOL> self . endpoint = endpoint <EOL> self . sessionId = sessionId <EOL> def setUp ( self ) : <EOL> self . jobs = [ ] <EOL> def tearDown ( self ) : <EOL> if hasattr ( self , '<STR_LIT>' ) : <EOL> for job_id in self . jobs : <EOL> print "<STR_LIT>" % job_id <EOL> self . bulk . close_job ( job_id ) <EOL> def test_raw_query ( self ) : <EOL> bulk = SalesforceBulk ( self . sessionId , self . endpoint ) <EOL> self . bulk = bulk <EOL> job_id = bulk . create_query_job ( "<STR_LIT>" ) <EOL> self . jobs . append ( job_id ) <EOL> self . assertIsNotNone ( re . match ( "<STR_LIT>" , job_id ) ) <EOL> batch_id = bulk . query ( job_id , "<STR_LIT>" ) <EOL> self . assertIsNotNone ( re . match ( "<STR_LIT>" , batch_id ) ) <EOL> while not bulk . is_batch_done ( job_id , batch_id ) : <EOL> print "<STR_LIT>" <EOL> print bulk . batch_status ( job_id , batch_id ) <EOL> time . sleep ( <NUM_LIT:2> ) <EOL> self . results = "<STR_LIT>" <EOL> def save_results ( tfile , kwargs ) : <EOL> print "<STR_LIT>" <EOL> self . results = tfile . read ( ) <EOL> flag = bulk . get_batch_results ( job_id , batch_id , callback = save_results ) <EOL> self . assertTrue ( flag ) <EOL> self . assertTrue ( len ( self . results ) > <NUM_LIT:0> ) <EOL> self . assertIn ( '<STR_LIT:">' , self . results ) <EOL> def test_csv_query ( self ) : <EOL> bulk = SalesforceBulk ( self . sessionId , self . endpoint ) <EOL> self . bulk = bulk <EOL> job_id = bulk . create_query_job ( "<STR_LIT>" ) <EOL> self . jobs . append ( job_id ) <EOL> self . assertIsNotNone ( re . match ( "<STR_LIT>" , job_id ) ) <EOL> batch_id = bulk . query ( job_id , "<STR_LIT>" ) <EOL> self . assertIsNotNone ( re . match ( "<STR_LIT>" , batch_id ) ) <EOL> bulk . wait_for_batch ( job_id , batch_id , timeout = <NUM_LIT> ) <EOL> self . results = None <EOL> def save_results1 ( rows , kwargs ) : <EOL> self . results = rows <EOL> flag = bulk . get_batch_results ( job_id , batch_id , callback = save_results1 , parse_csv = True ) <EOL> self . assertTrue ( flag ) <EOL> results = self . results <EOL> self . assertTrue ( len ( results ) > <NUM_LIT:0> ) <EOL> self . assertTrue ( isinstance ( results , list ) ) <EOL> self . assertEqual ( results [ <NUM_LIT:0> ] , [ '<STR_LIT>' , '<STR_LIT:Name>' , '<STR_LIT>' ] ) <EOL> self . assertTrue ( len ( results ) > <NUM_LIT:3> ) <EOL> self . results = None <EOL> self . callback_count = <NUM_LIT:0> <EOL> def save_results2 ( rows , ** kwargs ) : <EOL> self . results = rows <EOL> print rows <EOL> self . callback_count += <NUM_LIT:1> <EOL> batch = len ( results ) / <NUM_LIT:3> <EOL> self . callback_count = <NUM_LIT:0> <EOL> flag = bulk . get_batch_results ( job_id , batch_id , callback = save_results2 , parse_csv = True , batch_size = batch ) <EOL> self . assertTrue ( self . callback_count >= <NUM_LIT:3> ) <EOL> def test_csv_upload ( self ) : <EOL> bulk = SalesforceBulk ( self . sessionId , self . endpoint ) <EOL> self . bulk = bulk <EOL> job_id = bulk . create_insert_job ( "<STR_LIT>" ) <EOL> self . jobs . append ( job_id ) <EOL> self . assertIsNotNone ( re . match ( "<STR_LIT>" , job_id ) ) <EOL> batch_ids = [ ] <EOL> content = open ( "<STR_LIT>" ) . read ( ) <EOL> for i in range ( <NUM_LIT:5> ) : <EOL> batch_id = bulk . query ( job_id , content ) <EOL> self . assertIsNotNone ( re . match ( "<STR_LIT>" , batch_id ) ) <EOL> batch_ids . append ( batch_id ) <EOL> for batch_id in batch_ids : <EOL> bulk . wait_for_batch ( job_id , batch_id , timeout = <NUM_LIT> ) <EOL> self . results = None <EOL> def save_results1 ( rows , failed , remaining ) : <EOL> self . results = rows <EOL> for batch_id in batch_ids : <EOL> flag = bulk . get_upload_results ( job_id , batch_id , callback = save_results1 ) <EOL> self . assertTrue ( flag ) <EOL> results = self . results <EOL> self . assertTrue ( len ( results ) > <NUM_LIT:0> ) <EOL> self . assertTrue ( isinstance ( results , list ) ) <EOL> self . assertEqual ( results [ <NUM_LIT:0> ] , UploadResult ( '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ) ) <EOL> self . assertEqual ( len ( results ) , <NUM_LIT:3> ) <EOL> self . results = None <EOL> self . callback_count = <NUM_LIT:0> <EOL> def save_results2 ( rows , failed , remaining ) : <EOL> self . results = rows <EOL> self . callback_count += <NUM_LIT:1> <EOL> batch = len ( results ) / <NUM_LIT:3> <EOL> self . callback_count = <NUM_LIT:0> <EOL> flag = bulk . get_upload_results ( job_id , batch_id , callback = save_results2 , batch_size = batch ) <EOL> self . assertTrue ( self . callback_count >= <NUM_LIT:3> ) <EOL> if __name__ == '<STR_LIT:__main__>' : <EOL> username = raw_input ( "<STR_LIT>" ) <EOL> password = raw_input ( "<STR_LIT>" ) <EOL> login = salesforce_oauth_request . login ( username = username , password = password , cache_session = True ) <EOL> endpoint = login [ '<STR_LIT>' ] <EOL> sessionId = login [ '<STR_LIT>' ] <EOL> suite = unittest . TestSuite ( ) <EOL> suite . addTest ( SalesforceBulkTest ( "<STR_LIT>" , endpoint , sessionId ) ) <EOL> unittest . TextTestRunner ( ) . run ( suite ) </s>
<s> from derpconf . config import Config , generate_config <EOL> MINUTES = <NUM_LIT> <EOL> Config . define ( '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ) <EOL> Config . define ( '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ) <EOL> Config . define ( '<STR_LIT>' , <NUM_LIT:2> * MINUTES , "<STR_LIT>" , '<STR_LIT>' ) <EOL> Config . define ( '<STR_LIT>' , True , "<STR_LIT>" , '<STR_LIT>' ) <EOL> Config . define ( <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' + <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' <EOL> ) <EOL> Config . define ( '<STR_LIT>' , <NUM_LIT:1000> , '<STR_LIT>' , '<STR_LIT>' ) <EOL> Config . define ( '<STR_LIT>' , <NUM_LIT> , '<STR_LIT>' , '<STR_LIT>' ) <EOL> Config . define ( '<STR_LIT>' , { } , '<STR_LIT>' , '<STR_LIT>' ) <EOL> Config . define ( '<STR_LIT>' , None , '<STR_LIT>' , '<STR_LIT>' ) <EOL> Config . define ( '<STR_LIT>' , True , '<STR_LIT>' , '<STR_LIT>' ) <EOL> Config . define ( '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ) <EOL> Config . define ( '<STR_LIT>' , '<STR_LIT:localhost>' , '<STR_LIT>' , '<STR_LIT>' ) <EOL> Config . define ( '<STR_LIT>' , <NUM_LIT> , '<STR_LIT>' , '<STR_LIT>' ) <EOL> Config . define ( '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ) <EOL> Config . define ( '<STR_LIT>' , '<STR_LIT:root>' , '<STR_LIT>' , '<STR_LIT>' ) <EOL> Config . define ( '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ) <EOL> Config . alias ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> Config . alias ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> Config . alias ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> Config . alias ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> Config . alias ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> Config . define ( '<STR_LIT>' , <NUM_LIT:1> , '<STR_LIT>' , '<STR_LIT>' ) <EOL> Config . define ( '<STR_LIT>' , <NUM_LIT:10> , '<STR_LIT>' , '<STR_LIT>' ) <EOL> Config . define ( '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ) <EOL> Config . define ( '<STR_LIT>' , '<STR_LIT:127.0.0.1>' , '<STR_LIT>' , '<STR_LIT>' ) <EOL> Config . define ( '<STR_LIT>' , <NUM_LIT> , '<STR_LIT>' , '<STR_LIT>' ) <EOL> Config . define ( '<STR_LIT>' , <NUM_LIT:0> , '<STR_LIT>' , '<STR_LIT>' ) <EOL> Config . define ( '<STR_LIT>' , None , '<STR_LIT>' , '<STR_LIT>' ) <EOL> if __name__ == '<STR_LIT:__main__>' : <EOL> generate_config ( ) </s>
<s> '''<STR_LIT>''' <EOL> from __future__ import absolute_import , print_function <EOL> import re <EOL> from datetime import datetime <EOL> import difflib <EOL> from uuid import UUID <EOL> try : <EOL> from six import string_types , binary_type , PY2 , PY3 <EOL> except ImportError : <EOL> import warnings <EOL> warnings . warn ( '<STR_LIT>' ) <EOL> import numbers <EOL> from preggy import assertion <EOL> from preggy import utils <EOL> __all__ = ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> DATE_THRESHOLD = <NUM_LIT> <EOL> RESET = '<STR_LIT>' <EOL> RED = '<STR_LIT>' <EOL> GREEN = '<STR_LIT>' <EOL> YELLOW = '<STR_LIT>' <EOL> REMOVE_COLORS_REGEX = re . compile ( <EOL> r'<STR_LIT>' <EOL> r'<STR_LIT>' <EOL> r'<STR_LIT>' <EOL> r'<STR_LIT>' , <EOL> flags = re . UNICODE <EOL> ) <EOL> NORMALIZE_WHITESPACE_REGEX = re . compile ( <EOL> r'<STR_LIT>' , <EOL> flags = re . UNICODE \| re . MULTILINE \| re . IGNORECASE <EOL> ) <EOL> _filter_str = lambda s : NORMALIZE_WHITESPACE_REGEX . sub ( '<STR_LIT>' , s . lower ( ) ) . strip ( ) <EOL> def compare ( first , second ) : <EOL> matcher = difflib . SequenceMatcher ( None , first , second ) <EOL> first = get_match_for_text ( matcher , first , True ) <EOL> second = get_match_for_text ( matcher , second , True ) <EOL> return matcher , first , second <EOL> def get_match_for_text ( matcher , text , first ) : <EOL> result = [ ] <EOL> COLOR_MAP = { <EOL> '<STR_LIT>' : RED , <EOL> '<STR_LIT>' : GREEN , <EOL> '<STR_LIT:replace>' : YELLOW <EOL> } <EOL> for tag , i1 , i2 , j1 , j2 in matcher . get_opcodes ( ) : <EOL> start , stop = ( i1 , i2 ) if first else ( j1 , j2 ) <EOL> to_append = text [ start : stop ] <EOL> if tag in COLOR_MAP : <EOL> to_append = '<STR_LIT>' . join ( ( COLOR_MAP [ tag ] , to_append , RESET ) ) <EOL> result . append ( to_append ) <EOL> return '<STR_LIT>' . join ( result ) <EOL> def _match_alike ( expected , topic , diff = False ) : <EOL> '''<STR_LIT>''' <EOL> if topic is None : <EOL> return expected is None <EOL> if isinstance ( topic , UUID ) : <EOL> return _compare_uuid ( expected , topic ) <EOL> if isinstance ( topic , string_types + ( binary_type , ) ) : <EOL> return _compare_strings ( expected , topic ) <EOL> if isinstance ( topic , numbers . Number ) : <EOL> return _compare_numbers ( expected , topic ) <EOL> if isinstance ( topic , ( list , tuple , set ) ) : <EOL> return _compare_lists ( expected , topic ) <EOL> if isinstance ( topic , dict ) : <EOL> return _compare_dicts ( expected , topic ) <EOL> if isinstance ( topic , datetime ) : <EOL> return _compare_datetime ( expected , topic ) <EOL> if _is_comparable ( topic ) and _is_comparable ( expected ) : <EOL> return _compare_comparables ( expected , topic ) <EOL> raise RuntimeError ( '<STR_LIT>' . format ( expected = expected , topic = topic ) ) <EOL> def _strip_string ( text ) : <EOL> if not text : <EOL> return text <EOL> text = utils . fix_string ( text ) <EOL> text = REMOVE_COLORS_REGEX . sub ( '<STR_LIT>' , text ) <EOL> text = _filter_str ( text ) <EOL> return text <EOL> def _is_comparable ( obj ) : <EOL> if PY2 : <EOL> return hasattr ( obj , '<STR_LIT>' ) or hasattr ( obj , '<STR_LIT>' ) <EOL> if PY3 : <EOL> return obj . __class__ . __eq__ != object . __eq__ <EOL> def _compare_strings ( expected , topic ) : <EOL> '''<STR_LIT>''' <EOL> topic = _strip_string ( topic ) <EOL> expected = _strip_string ( expected ) <EOL> return expected == _filter_str ( topic ) <EOL> def _compare_uuid ( expected , topic ) : <EOL> '''<STR_LIT>''' <EOL> topic = str ( topic ) <EOL> expected = str ( expected ) <EOL> return expected == topic <EOL> def __timedelta_to_seconds ( timedelta ) : <EOL> ms = <NUM_LIT:10> ** <NUM_LIT:6> <EOL> days = <NUM_LIT> * <NUM_LIT> * <NUM_LIT> <EOL> ms_as_seconds = float ( timedelta . microseconds ) / ms <EOL> seconds = float ( timedelta . seconds ) <EOL> days_as_seconds = float ( timedelta . days ) * days <EOL> total_seconds = sum ( ( ms_as_seconds , <EOL> seconds , <EOL> days_as_seconds ) ) <EOL> return abs ( total_seconds ) <EOL> def _compare_datetime ( expected , topic ) : <EOL> return __timedelta_to_seconds ( topic - expected ) <= DATE_THRESHOLD <EOL> def _compare_numbers ( expected , topic ) : <EOL> '''<STR_LIT>''' <EOL> FALSE_CONDITIONS = ( not isinstance ( topic , numbers . Number ) , <EOL> not isinstance ( expected , numbers . Number ) , ) <EOL> if any ( FALSE_CONDITIONS ) : <EOL> return False <EOL> return float ( expected ) == float ( topic ) <EOL> def _compare_dicts ( expected , topic ) : <EOL> '''<STR_LIT>''' <EOL> return _match_dicts ( expected , topic ) and _match_dicts ( topic , expected ) <EOL> def _match_dicts ( expected , topic ) : <EOL> '''<STR_LIT>''' <EOL> for k , v in expected . items ( ) : <EOL> if not k in topic or not _match_alike ( topic [ k ] , v ) : <EOL> return False <EOL> return True <EOL> def _compare_lists ( expected , topic ) : <EOL> '''<STR_LIT>''' <EOL> return _match_lists ( expected , topic ) and _match_lists ( topic , expected ) <EOL> def _compare_comparables ( expected , topic ) : <EOL> '''<STR_LIT>''' <EOL> try : <EOL> return expected == topic <EOL> except : <EOL> return False <EOL> def _match_lists ( expected , topic ) : <EOL> '''<STR_LIT>''' <EOL> for item in expected : <EOL> if isinstance ( item , ( list , tuple ) ) : <EOL> found = False <EOL> for inner_item in topic : <EOL> if isinstance ( inner_item , ( list , tuple ) ) and _compare_lists ( item , inner_item ) : <EOL> found = True <EOL> break <EOL> if not found : <EOL> return False <EOL> else : <EOL> found = False <EOL> for t in topic : <EOL> try : <EOL> if item == t : <EOL> found = True <EOL> break <EOL> except : <EOL> continue <EOL> if not found : <EOL> return False <EOL> return True <EOL> @ assertion <EOL> def to_be_like ( topic , expected , diff = True ) : <EOL> '''<STR_LIT>''' <EOL> result = _match_alike ( expected , topic , diff = diff ) <EOL> is_str = lambda x : isinstance ( x , string_types + ( binary_type , ) ) <EOL> if not result : <EOL> if diff is True and ( <EOL> is_str ( topic ) and <EOL> is_str ( expected ) <EOL> ) : <EOL> first , second = _strip_string ( topic ) , _strip_string ( expected ) <EOL> matcher , first , second = compare ( first , second ) <EOL> print ( ) <EOL> print ( '<STR_LIT>' ) <EOL> print ( first ) <EOL> print ( second ) <EOL> print ( ) <EOL> raise AssertionError ( "<STR_LIT>" . format ( topic = topic , expected = expected ) ) <EOL> @ assertion <EOL> def not_to_be_like ( topic , expected , diff = False ) : <EOL> '''<STR_LIT>''' <EOL> result = _match_alike ( expected , topic , diff = diff ) <EOL> if result : <EOL> raise AssertionError ( "<STR_LIT>" . format ( topic = topic , expected = expected ) ) </s>
<s> from preggy import expect <EOL> TEST_DATA = frozenset ( [ <EOL> <NUM_LIT:10> , <EOL> <NUM_LIT:20> , <EOL> <NUM_LIT> , <EOL> <NUM_LIT:10> / <NUM_LIT:3> <EOL> ] ) <EOL> def is_expected ( item ) : <EOL> expect ( item ) . to_be_numeric ( ) <EOL> def test_to_be_numeric ( ) : <EOL> for item in TEST_DATA : <EOL> yield is_expected , item </s>
<s> from tornado import gen <EOL> from tornado_json . requesthandlers import APIHandler <EOL> from tornado_json import schema <EOL> from tornado_json . gen import coroutine <EOL> class HelloWorldHandler ( APIHandler ) : <EOL> @ schema . validate ( <EOL> output_schema = { "<STR_LIT:type>" : "<STR_LIT:string>" } , <EOL> output_example = "<STR_LIT>" <EOL> ) <EOL> def get ( self ) : <EOL> """<STR_LIT>""" <EOL> return "<STR_LIT>" <EOL> class PostIt ( APIHandler ) : <EOL> @ schema . validate ( <EOL> input_schema = { <EOL> "<STR_LIT:type>" : "<STR_LIT:object>" , <EOL> "<STR_LIT>" : { <EOL> "<STR_LIT:title>" : { "<STR_LIT:type>" : "<STR_LIT:string>" } , <EOL> "<STR_LIT:body>" : { "<STR_LIT:type>" : "<STR_LIT:string>" } , <EOL> "<STR_LIT:index>" : { "<STR_LIT:type>" : "<STR_LIT>" } , <EOL> } <EOL> } , <EOL> input_example = { <EOL> "<STR_LIT:title>" : "<STR_LIT>" , <EOL> "<STR_LIT:body>" : "<STR_LIT>" , <EOL> "<STR_LIT:index>" : <NUM_LIT:0> <EOL> } , <EOL> output_schema = { <EOL> "<STR_LIT:type>" : "<STR_LIT:object>" , <EOL> "<STR_LIT>" : { <EOL> "<STR_LIT:message>" : { "<STR_LIT:type>" : "<STR_LIT:string>" } <EOL> } <EOL> } , <EOL> output_example = { <EOL> "<STR_LIT:message>" : "<STR_LIT>" <EOL> } , <EOL> ) <EOL> def post ( self ) : <EOL> """<STR_LIT>""" <EOL> return { <EOL> "<STR_LIT:message>" : "<STR_LIT>" . format ( self . body [ "<STR_LIT:title>" ] ) <EOL> } <EOL> class Greeting ( APIHandler ) : <EOL> @ schema . validate ( <EOL> output_schema = { "<STR_LIT:type>" : "<STR_LIT:string>" } , <EOL> output_example = "<STR_LIT>" <EOL> ) <EOL> def get ( self , fname , lname ) : <EOL> """<STR_LIT>""" <EOL> return "<STR_LIT>" . format ( fname , lname ) <EOL> class AsyncHelloWorld ( APIHandler ) : <EOL> def hello ( self , name , callback = None ) : <EOL> callback ( "<STR_LIT>" . format ( name ) ) <EOL> @ schema . validate ( <EOL> output_schema = { "<STR_LIT:type>" : "<STR_LIT:string>" } , <EOL> output_example = "<STR_LIT>" <EOL> ) <EOL> @ coroutine <EOL> def get ( self , name ) : <EOL> """<STR_LIT>""" <EOL> res = yield gen . Task ( self . hello , name ) <EOL> raise gen . Return ( res ) <EOL> class FreeWilledHandler ( APIHandler ) : <EOL> def get ( self ) : <EOL> self . success ( "<STR_LIT>" ) </s>
<s> from __future__ import print_function <EOL> import codecs <EOL> import os <EOL> import re <EOL> from setuptools import setup <EOL> def read ( filename ) : <EOL> """<STR_LIT>""" <EOL> here = os . path . abspath ( os . path . dirname ( __file__ ) ) <EOL> return codecs . open ( os . path . join ( here , filename ) , '<STR_LIT:r>' ) . read ( ) <EOL> with open ( '<STR_LIT>' , '<STR_LIT:r>' ) as fd : <EOL> version = re . search ( r'<STR_LIT>' , <EOL> fd . read ( ) , re . MULTILINE ) . group ( <NUM_LIT:1> ) <EOL> install_requires = read ( "<STR_LIT>" ) . split ( ) <EOL> long_description = read ( '<STR_LIT>' ) <EOL> setup ( <EOL> name = '<STR_LIT>' , <EOL> version = version , <EOL> url = '<STR_LIT>' , <EOL> license = '<STR_LIT>' , <EOL> author = '<STR_LIT>' , <EOL> install_requires = install_requires , <EOL> description = "<STR_LIT>" , <EOL> long_description = long_description , <EOL> packages = [ '<STR_LIT>' ] , <EOL> platforms = '<STR_LIT>' , <EOL> classifiers = [ <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> ) </s>
<s> from Timeout import Timeout <EOL> from Rtp_proxy_client_udp import Rtp_proxy_client_udp <EOL> from Rtp_proxy_client_local import Rtp_proxy_client_local <EOL> from time import time <EOL> from hashlib import md5 <EOL> from random import random <EOL> class Rtp_proxy_client ( Rtp_proxy_client_udp , Rtp_proxy_client_local ) : <EOL> worker = None <EOL> address = None <EOL> online = False <EOL> copy_supported = False <EOL> stat_supported = False <EOL> tnot_supported = False <EOL> sbind_supported = False <EOL> shutdown = False <EOL> proxy_address = None <EOL> caps_done = False <EOL> active_sessions = None <EOL> def __init__ ( self , global_config , * address ) : <EOL> if len ( address ) > <NUM_LIT:0> and type ( address [ <NUM_LIT:0> ] ) in ( tuple , list ) : <EOL> Rtp_proxy_client_udp . __init__ ( self , global_config , * address ) <EOL> else : <EOL> Rtp_proxy_client_local . __init__ ( self , global_config , * address ) <EOL> self . version_check ( ) <EOL> def send_command ( self , * args , ** kwargs ) : <EOL> if self . is_local : <EOL> Rtp_proxy_client_local . send_command ( self , * args , ** kwargs ) <EOL> else : <EOL> Rtp_proxy_client_udp . send_command ( self , * args , ** kwargs ) <EOL> def caps_query1 ( self , result ) : <EOL> if self . shutdown : <EOL> self . worker . shutdown ( ) <EOL> return <EOL> if not self . online : <EOL> return <EOL> if result != '<STR_LIT:1>' : <EOL> if result != None : <EOL> self . copy_supported = False <EOL> self . stat_supported = False <EOL> self . tnot_supported = False <EOL> self . sbind_supported = False <EOL> self . caps_done = True <EOL> return <EOL> self . copy_supported = True <EOL> self . send_command ( '<STR_LIT>' , self . caps_query2 ) <EOL> def caps_query2 ( self , result ) : <EOL> if self . shutdown : <EOL> self . worker . shutdown ( ) <EOL> return <EOL> if not self . online : <EOL> return <EOL> if result != None : <EOL> if result == '<STR_LIT:1>' : <EOL> self . stat_supported = True <EOL> self . send_command ( '<STR_LIT>' , self . caps_query3 ) <EOL> return <EOL> else : <EOL> self . stat_supported = False <EOL> self . tnot_supported = False <EOL> self . sbind_supported = False <EOL> self . caps_done = True <EOL> def caps_query3 ( self , result ) : <EOL> if self . shutdown : <EOL> self . worker . shutdown ( ) <EOL> return <EOL> if not self . online : <EOL> return <EOL> if result != None : <EOL> if result == '<STR_LIT:1>' : <EOL> self . tnot_supported = True <EOL> self . send_command ( '<STR_LIT>' , self . caps_query4 ) <EOL> return <EOL> else : <EOL> self . tnot_supported = False <EOL> self . sbind_supported = False <EOL> self . caps_done = True <EOL> def caps_query4 ( self , result ) : <EOL> if self . shutdown : <EOL> self . worker . shutdown ( ) <EOL> return <EOL> if not self . online : <EOL> return <EOL> if result != None : <EOL> if result == '<STR_LIT:1>' : <EOL> self . sbind_supported = True <EOL> else : <EOL> self . sbind_supported = False <EOL> self . caps_done = True <EOL> def version_check ( self ) : <EOL> self . send_command ( '<STR_LIT>' , self . version_check_reply ) <EOL> def version_check_reply ( self , version ) : <EOL> if self . shutdown : <EOL> self . worker . shutdown ( ) <EOL> return <EOL> if version == '<STR_LIT>' : <EOL> self . go_online ( ) <EOL> elif self . online : <EOL> self . go_offline ( ) <EOL> else : <EOL> Timeout ( self . version_check , <NUM_LIT> ) <EOL> def heartbeat ( self ) : <EOL> self . send_command ( '<STR_LIT>' , self . heartbeat_reply ) <EOL> def heartbeat_reply ( self , stats ) : <EOL> if self . shutdown : <EOL> self . udp_server . shutdown ( ) <EOL> return <EOL> if not self . online : <EOL> return <EOL> if stats == None : <EOL> self . active_sessions = None <EOL> self . go_offline ( ) <EOL> else : <EOL> for line in stats . splitlines ( ) : <EOL> if not line . startswith ( '<STR_LIT>' ) : <EOL> continue <EOL> self . update_active ( int ( line . split ( '<STR_LIT::>' , <NUM_LIT:1> ) [ <NUM_LIT:1> ] ) ) <EOL> Timeout ( self . heartbeat , <NUM_LIT:10> ) <EOL> def go_online ( self ) : <EOL> if not self . online : <EOL> self . caps_done = False <EOL> self . send_command ( '<STR_LIT>' , self . caps_query1 ) <EOL> self . online = True <EOL> self . heartbeat ( ) <EOL> def go_offline ( self ) : <EOL> if self . online : <EOL> self . online = False <EOL> Timeout ( self . version_check , <NUM_LIT> ) <EOL> def update_active ( self , active_sessions ) : <EOL> self . active_sessions = active_sessions </s>
<s> from SipNumericHF import SipNumericHF <EOL> class SipMaxForwards ( SipNumericHF ) : <EOL> hf_names = ( '<STR_LIT>' , ) <EOL> def __init__ ( self , body = None , number = <NUM_LIT> ) : <EOL> SipNumericHF . __init__ ( self , body , number ) <EOL> def getCanName ( self , name , compact = False ) : <EOL> return '<STR_LIT>' </s>
<s> class UaStateGeneric ( object ) : <EOL> sname = '<STR_LIT>' <EOL> ua = None <EOL> connected = False <EOL> dead = False <EOL> def __init__ ( self , ua ) : <EOL> self . ua = ua <EOL> def recvRequest ( self , req ) : <EOL> return None <EOL> def recvResponse ( self , resp ) : <EOL> return None <EOL> def recvEvent ( self , event ) : <EOL> return None <EOL> def cancel ( self , rtime , req ) : <EOL> return None <EOL> def onStateChange ( self , newstate ) : <EOL> pass <EOL> def __str__ ( self ) : <EOL> return self . sname </s>
<s> """<STR_LIT>""" <EOL> import logging <EOL> class NullHandler ( logging . Handler ) : <EOL> """<STR_LIT>""" <EOL> def handle ( self , record ) : <EOL> pass <EOL> def emit ( self , record ) : <EOL> pass <EOL> def createLock ( self ) : <EOL> self . lock = None </s>
<s> from __future__ import division , unicode_literals , print_function , absolute_import <EOL> import collections <EOL> import copy <EOL> import operator as op <EOL> from pint . testsuite import BaseTestCase , QuantityTestCase <EOL> from pint . util import ( string_preprocessor , find_shortest_path , matrix_to_string , <EOL> transpose , find_connected_nodes , ParserHelper , <EOL> UnitsContainer , to_units_container ) <EOL> class TestUnitsContainer ( QuantityTestCase ) : <EOL> def _test_inplace ( self , operator , value1 , value2 , expected_result ) : <EOL> value1 = copy . copy ( value1 ) <EOL> value2 = copy . copy ( value2 ) <EOL> id1 = id ( value1 ) <EOL> id2 = id ( value2 ) <EOL> value1 = operator ( value1 , value2 ) <EOL> value2_cpy = copy . copy ( value2 ) <EOL> self . assertEqual ( value1 , expected_result ) <EOL> self . assertNotEqual ( id1 , id ( value1 ) ) <EOL> self . assertEqual ( value2 , value2_cpy ) <EOL> self . assertEqual ( id2 , id ( value2 ) ) <EOL> def _test_not_inplace ( self , operator , value1 , value2 , expected_result ) : <EOL> id1 = id ( value1 ) <EOL> id2 = id ( value2 ) <EOL> value1_cpy = copy . copy ( value1 ) <EOL> value2_cpy = copy . copy ( value2 ) <EOL> result = operator ( value1 , value2 ) <EOL> self . assertEqual ( expected_result , result ) <EOL> self . assertEqual ( value1 , value1_cpy ) <EOL> self . assertEqual ( value2 , value2_cpy ) <EOL> self . assertNotEqual ( id ( result ) , id1 ) <EOL> self . assertNotEqual ( id ( result ) , id2 ) <EOL> def test_unitcontainer_creation ( self ) : <EOL> x = UnitsContainer ( meter = <NUM_LIT:1> , second = <NUM_LIT:2> ) <EOL> y = UnitsContainer ( { '<STR_LIT>' : <NUM_LIT:1.0> , '<STR_LIT>' : <NUM_LIT> } ) <EOL> self . assertIsInstance ( x [ '<STR_LIT>' ] , float ) <EOL> self . assertEqual ( x , y ) <EOL> self . assertIsNot ( x , y ) <EOL> z = copy . copy ( x ) <EOL> self . assertEqual ( x , z ) <EOL> self . assertIsNot ( x , z ) <EOL> z = UnitsContainer ( x ) <EOL> self . assertEqual ( x , z ) <EOL> self . assertIsNot ( x , z ) <EOL> def test_unitcontainer_repr ( self ) : <EOL> x = UnitsContainer ( ) <EOL> self . assertEqual ( str ( x ) , '<STR_LIT>' ) <EOL> self . assertEqual ( repr ( x ) , '<STR_LIT>' ) <EOL> x = UnitsContainer ( meter = <NUM_LIT:1> , second = <NUM_LIT:2> ) <EOL> self . assertEqual ( str ( x ) , '<STR_LIT>' ) <EOL> self . assertEqual ( repr ( x ) , <EOL> "<STR_LIT>" ) <EOL> x = UnitsContainer ( meter = <NUM_LIT:1> , second = <NUM_LIT> ) <EOL> self . assertEqual ( str ( x ) , '<STR_LIT>' ) <EOL> self . assertEqual ( repr ( x ) , <EOL> "<STR_LIT>" ) <EOL> def test_unitcontainer_bool ( self ) : <EOL> self . assertTrue ( UnitsContainer ( meter = <NUM_LIT:1> , second = <NUM_LIT:2> ) ) <EOL> self . assertFalse ( UnitsContainer ( ) ) <EOL> def test_unitcontainer_comp ( self ) : <EOL> x = UnitsContainer ( meter = <NUM_LIT:1> , second = <NUM_LIT:2> ) <EOL> y = UnitsContainer ( meter = <NUM_LIT:1.> , second = <NUM_LIT:2> ) <EOL> z = UnitsContainer ( meter = <NUM_LIT:1> , second = <NUM_LIT:3> ) <EOL> self . assertTrue ( x == y ) <EOL> self . assertFalse ( x != y ) <EOL> self . assertFalse ( x == z ) <EOL> self . assertTrue ( x != z ) <EOL> def test_unitcontainer_arithmetic ( self ) : <EOL> x = UnitsContainer ( meter = <NUM_LIT:1> ) <EOL> y = UnitsContainer ( second = <NUM_LIT:1> ) <EOL> z = UnitsContainer ( meter = <NUM_LIT:1> , second = - <NUM_LIT:2> ) <EOL> self . _test_not_inplace ( op . mul , x , y , UnitsContainer ( meter = <NUM_LIT:1> , second = <NUM_LIT:1> ) ) <EOL> self . _test_not_inplace ( op . truediv , x , y , UnitsContainer ( meter = <NUM_LIT:1> , second = - <NUM_LIT:1> ) ) <EOL> self . _test_not_inplace ( op . pow , z , <NUM_LIT:2> , UnitsContainer ( meter = <NUM_LIT:2> , second = - <NUM_LIT:4> ) ) <EOL> self . _test_not_inplace ( op . pow , z , - <NUM_LIT:2> , UnitsContainer ( meter = - <NUM_LIT:2> , second = <NUM_LIT:4> ) ) <EOL> self . _test_inplace ( op . imul , x , y , UnitsContainer ( meter = <NUM_LIT:1> , second = <NUM_LIT:1> ) ) <EOL> self . _test_inplace ( op . itruediv , x , y , UnitsContainer ( meter = <NUM_LIT:1> , second = - <NUM_LIT:1> ) ) <EOL> self . _test_inplace ( op . ipow , z , <NUM_LIT:2> , UnitsContainer ( meter = <NUM_LIT:2> , second = - <NUM_LIT:4> ) ) <EOL> self . _test_inplace ( op . ipow , z , - <NUM_LIT:2> , UnitsContainer ( meter = - <NUM_LIT:2> , second = <NUM_LIT:4> ) ) <EOL> def test_string_comparison ( self ) : <EOL> x = UnitsContainer ( meter = <NUM_LIT:1> ) <EOL> y = UnitsContainer ( second = <NUM_LIT:1> ) <EOL> z = UnitsContainer ( meter = <NUM_LIT:1> , second = - <NUM_LIT:2> ) <EOL> self . assertEqual ( x , '<STR_LIT>' ) <EOL> self . assertEqual ( '<STR_LIT>' , x ) <EOL> self . assertNotEqual ( x , '<STR_LIT>' ) <EOL> self . assertNotEqual ( x , '<STR_LIT>' ) <EOL> self . assertNotEqual ( x , '<STR_LIT>' ) <EOL> self . assertEqual ( y , '<STR_LIT>' ) <EOL> self . assertEqual ( z , '<STR_LIT>' ) <EOL> def test_invalid ( self ) : <EOL> self . assertRaises ( TypeError , UnitsContainer , { <NUM_LIT:1> : <NUM_LIT:2> } ) <EOL> self . assertRaises ( TypeError , UnitsContainer , { '<STR_LIT:1>' : '<STR_LIT:2>' } ) <EOL> d = UnitsContainer ( ) <EOL> self . assertRaises ( TypeError , d . __mul__ , list ( ) ) <EOL> self . assertRaises ( TypeError , d . __pow__ , list ( ) ) <EOL> self . assertRaises ( TypeError , d . __truediv__ , list ( ) ) <EOL> self . assertRaises ( TypeError , d . __rtruediv__ , list ( ) ) <EOL> class TestToUnitsContainer ( BaseTestCase ) : <EOL> def test_str_conversion ( self ) : <EOL> self . assertEqual ( to_units_container ( '<STR_LIT:m>' ) , UnitsContainer ( m = <NUM_LIT:1> ) ) <EOL> def test_uc_conversion ( self ) : <EOL> a = UnitsContainer ( m = <NUM_LIT:1> ) <EOL> self . assertIs ( to_units_container ( a ) , a ) <EOL> def test_quantity_conversion ( self ) : <EOL> from pint . unit import UnitRegistry <EOL> ureg = UnitRegistry ( ) <EOL> self . assertEqual ( to_units_container ( ureg . Quantity ( <NUM_LIT:1> , UnitsContainer ( m = <NUM_LIT:1> ) ) ) , <EOL> UnitsContainer ( m = <NUM_LIT:1> ) ) <EOL> def test_unit_conversion ( self ) : <EOL> from pint . unit import _Unit <EOL> self . assertEqual ( to_units_container ( _Unit ( UnitsContainer ( m = <NUM_LIT:1> ) ) ) , <EOL> UnitsContainer ( m = <NUM_LIT:1> ) ) <EOL> def test_dict_conversion ( self ) : <EOL> self . assertEqual ( to_units_container ( dict ( m = <NUM_LIT:1> ) ) , UnitsContainer ( m = <NUM_LIT:1> ) ) <EOL> class TestParseHelper ( BaseTestCase ) : <EOL> def test_basic ( self ) : <EOL> x = lambda : ParserHelper ( <NUM_LIT:1> , meter = <NUM_LIT:2> ) <EOL> xp = lambda : ParserHelper ( <NUM_LIT:1> , meter = <NUM_LIT:2> ) <EOL> y = lambda : ParserHelper ( <NUM_LIT:2> , meter = <NUM_LIT:2> ) <EOL> self . assertEqual ( x ( ) , xp ( ) ) <EOL> self . assertNotEqual ( x ( ) , y ( ) ) <EOL> self . assertEqual ( ParserHelper . from_string ( '<STR_LIT>' ) , ParserHelper ( ) ) <EOL> self . assertEqual ( repr ( x ( ) ) , "<STR_LIT>" ) <EOL> self . assertEqual ( ParserHelper ( <NUM_LIT:2> ) , <NUM_LIT:2> ) <EOL> self . assertEqual ( x ( ) , dict ( meter = <NUM_LIT:2> ) ) <EOL> self . assertEqual ( x ( ) , '<STR_LIT>' ) <EOL> self . assertNotEqual ( y ( ) , dict ( meter = <NUM_LIT:2> ) ) <EOL> self . assertNotEqual ( y ( ) , '<STR_LIT>' ) <EOL> self . assertNotEqual ( xp ( ) , object ( ) ) <EOL> def test_calculate ( self ) : <EOL> x = lambda : ParserHelper ( <NUM_LIT:1.> , meter = <NUM_LIT:2> ) <EOL> y = lambda : ParserHelper ( <NUM_LIT> , meter = - <NUM_LIT:2> ) <EOL> z = lambda : ParserHelper ( <NUM_LIT> , meter = <NUM_LIT:2> ) <EOL> self . assertEqual ( x ( ) * <NUM_LIT> , ParserHelper ( <NUM_LIT> , meter = <NUM_LIT:2> ) ) <EOL> self . assertEqual ( x ( ) * y ( ) , ParserHelper ( <NUM_LIT> ) ) <EOL> self . assertEqual ( x ( ) * '<STR_LIT>' , ParserHelper ( <NUM_LIT:1.> , meter = <NUM_LIT:2> , second = <NUM_LIT:1> ) ) <EOL> self . assertEqual ( x ( ) / <NUM_LIT> , ParserHelper ( <NUM_LIT> , meter = <NUM_LIT:2> ) ) <EOL> self . assertEqual ( x ( ) / '<STR_LIT>' , ParserHelper ( <NUM_LIT:1.> , meter = <NUM_LIT:2> , second = - <NUM_LIT:1> ) ) <EOL> self . assertEqual ( x ( ) / z ( ) , ParserHelper ( <NUM_LIT:0.5> ) ) <EOL> self . assertEqual ( <NUM_LIT> / z ( ) , ParserHelper ( <NUM_LIT> , meter = - <NUM_LIT:2> ) ) <EOL> self . assertEqual ( '<STR_LIT>' / z ( ) , <EOL> ParserHelper ( <NUM_LIT:0.5> , seconds = <NUM_LIT:1> , meter = - <NUM_LIT:2> ) ) <EOL> self . assertEqual ( dict ( seconds = <NUM_LIT:1> ) / z ( ) , <EOL> ParserHelper ( <NUM_LIT:0.5> , seconds = <NUM_LIT:1> , meter = - <NUM_LIT:2> ) ) <EOL> class TestStringProcessor ( BaseTestCase ) : <EOL> def _test ( self , bef , aft ) : <EOL> for pattern in ( '<STR_LIT>' , '<STR_LIT>' ) : <EOL> b = pattern . format ( bef ) <EOL> a = pattern . format ( aft ) <EOL> self . assertEqual ( string_preprocessor ( b ) , a ) <EOL> def test_square_cube ( self ) : <EOL> self . _test ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> self . _test ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> self . _test ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> self . _test ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> self . _test ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> self . _test ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> self . _test ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> self . _test ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> self . _test ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> self . _test ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> def test_per ( self ) : <EOL> self . _test ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> def test_numbers ( self ) : <EOL> self . _test ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> self . _test ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> self . _test ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> self . _test ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> self . _test ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> self . _test ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> self . _test ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> def test_space_multiplication ( self ) : <EOL> self . _test ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> self . _test ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> self . _test ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> self . _test ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> self . _test ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> self . _test ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> self . _test ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> self . _test ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> self . _test ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> self . _test ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> self . _test ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> def test_joined_multiplication ( self ) : <EOL> self . _test ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> self . _test ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> self . _test ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> self . _test ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> self . _test ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> self . _test ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> def test_names ( self ) : <EOL> self . _test ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> self . _test ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> self . _test ( '<STR_LIT:g>' , '<STR_LIT:g>' ) <EOL> self . _test ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> class TestGraph ( BaseTestCase ) : <EOL> def test_start_not_in_graph ( self ) : <EOL> g = collections . defaultdict ( list ) <EOL> g [ <NUM_LIT:1> ] = set ( ( <NUM_LIT:2> , ) ) <EOL> g [ <NUM_LIT:2> ] = set ( ( <NUM_LIT:3> , ) ) <EOL> self . assertIs ( find_connected_nodes ( g , <NUM_LIT:9> ) , None ) <EOL> def test_shortest_path ( self ) : <EOL> g = collections . defaultdict ( list ) <EOL> g [ <NUM_LIT:1> ] = set ( ( <NUM_LIT:2> , ) ) <EOL> g [ <NUM_LIT:2> ] = set ( ( <NUM_LIT:3> , ) ) <EOL> p = find_shortest_path ( g , <NUM_LIT:1> , <NUM_LIT:2> ) <EOL> self . assertEqual ( p , [ <NUM_LIT:1> , <NUM_LIT:2> ] ) <EOL> p = find_shortest_path ( g , <NUM_LIT:1> , <NUM_LIT:3> ) <EOL> self . assertEqual ( p , [ <NUM_LIT:1> , <NUM_LIT:2> , <NUM_LIT:3> ] ) <EOL> p = find_shortest_path ( g , <NUM_LIT:3> , <NUM_LIT:1> ) <EOL> self . assertIs ( p , None ) <EOL> g = collections . defaultdict ( list ) <EOL> g [ <NUM_LIT:1> ] = set ( ( <NUM_LIT:2> , ) ) <EOL> g [ <NUM_LIT:2> ] = set ( ( <NUM_LIT:3> , <NUM_LIT:1> ) ) <EOL> g [ <NUM_LIT:3> ] = set ( ( <NUM_LIT:2> , ) ) <EOL> p = find_shortest_path ( g , <NUM_LIT:1> , <NUM_LIT:2> ) <EOL> self . assertEqual ( p , [ <NUM_LIT:1> , <NUM_LIT:2> ] ) <EOL> p = find_shortest_path ( g , <NUM_LIT:1> , <NUM_LIT:3> ) <EOL> self . assertEqual ( p , [ <NUM_LIT:1> , <NUM_LIT:2> , <NUM_LIT:3> ] ) <EOL> p = find_shortest_path ( g , <NUM_LIT:3> , <NUM_LIT:1> ) <EOL> self . assertEqual ( p , [ <NUM_LIT:3> , <NUM_LIT:2> , <NUM_LIT:1> ] ) <EOL> p = find_shortest_path ( g , <NUM_LIT:2> , <NUM_LIT:1> ) <EOL> self . assertEqual ( p , [ <NUM_LIT:2> , <NUM_LIT:1> ] ) <EOL> class TestMatrix ( BaseTestCase ) : <EOL> def test_matrix_to_string ( self ) : <EOL> self . assertEqual ( matrix_to_string ( [ [ <NUM_LIT:1> , <NUM_LIT:2> ] , [ <NUM_LIT:3> , <NUM_LIT:4> ] ] , <EOL> row_headers = None , <EOL> col_headers = None ) , <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' ) <EOL> self . assertEqual ( matrix_to_string ( [ [ <NUM_LIT:1> , <NUM_LIT:2> ] , [ <NUM_LIT:3> , <NUM_LIT:4> ] ] , <EOL> row_headers = None , <EOL> col_headers = None , <EOL> fmtfun = lambda x : '<STR_LIT>' . format ( x ) ) , <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' ) <EOL> self . assertEqual ( matrix_to_string ( [ [ <NUM_LIT:1> , <NUM_LIT:2> ] , [ <NUM_LIT:3> , <NUM_LIT:4> ] ] , <EOL> row_headers = [ '<STR_LIT:c>' , '<STR_LIT:d>' ] , <EOL> col_headers = None ) , <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' ) <EOL> self . assertEqual ( matrix_to_string ( [ [ <NUM_LIT:1> , <NUM_LIT:2> ] , [ <NUM_LIT:3> , <NUM_LIT:4> ] ] , <EOL> row_headers = None , <EOL> col_headers = [ '<STR_LIT:a>' , '<STR_LIT:b>' ] ) , <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' ) <EOL> self . assertEqual ( matrix_to_string ( [ [ <NUM_LIT:1> , <NUM_LIT:2> ] , [ <NUM_LIT:3> , <NUM_LIT:4> ] ] , <EOL> row_headers = [ '<STR_LIT:c>' , '<STR_LIT:d>' ] , <EOL> col_headers = [ '<STR_LIT:a>' , '<STR_LIT:b>' ] ) , <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' ) <EOL> def test_transpose ( self ) : <EOL> self . assertEqual ( transpose ( [ [ <NUM_LIT:1> , <NUM_LIT:2> ] , [ <NUM_LIT:3> , <NUM_LIT:4> ] ] ) , [ [ <NUM_LIT:1> , <NUM_LIT:3> ] , [ <NUM_LIT:2> , <NUM_LIT:4> ] ] ) </s>
<s> """<STR_LIT>""" <EOL> from __future__ import division , unicode_literals , print_function , absolute_import <EOL> from . . import constants <EOL> from . messagebased import MessageBasedResource <EOL> @ MessageBasedResource . register ( constants . InterfaceType . asrl , '<STR_LIT>' ) <EOL> class SerialInstrument ( MessageBasedResource ) : <EOL> """<STR_LIT>""" <EOL> def flush ( self , mask ) : <EOL> """<STR_LIT>""" <EOL> self . visalib . flush ( self . session , mask ) </s>
<s> import sys , os <EOL> def foo ( ) : <EOL> import subprocess , argparse <EOL> import copy ; import math , email <EOL> print ( <NUM_LIT:1> ) <EOL> print ( <NUM_LIT:2> ) <EOL> d = { <NUM_LIT:1> : <NUM_LIT:2> , <EOL> <NUM_LIT:3> : <NUM_LIT:4> } <EOL> print ( <NUM_LIT:2> ) <EOL> print ( <NUM_LIT:2> ) <EOL> print ( <NUM_LIT:2> ) <EOL> print ( <NUM_LIT:2> ) <EOL> <NUM_LIT:1> / <NUM_LIT:1> <EOL> <NUM_LIT:1> * <NUM_LIT:2> <EOL> <NUM_LIT:1> + <NUM_LIT:1> <EOL> <NUM_LIT:1> - <NUM_LIT:1> <EOL> <NUM_LIT:1> ** <NUM_LIT:2> <EOL> def dummy1 ( a ) : <EOL> print ( a ) <EOL> print ( a ) <EOL> def dummy2 ( a ) : <EOL> if <NUM_LIT:1> in a : <EOL> print ( "<STR_LIT:a>" ) <EOL> print ( <NUM_LIT:1> + <NUM_LIT:1> ) <EOL> print ( <NUM_LIT:1> + <NUM_LIT:1> ) <EOL> print ( <NUM_LIT:1> + <NUM_LIT:1> ) <EOL> print ( <NUM_LIT:1> + <NUM_LIT:1> ) <EOL> print ( <NUM_LIT:1> + <NUM_LIT:1> ) <EOL> print ( <NUM_LIT:1> * <NUM_LIT:1> ) <EOL> print ( <NUM_LIT:1> + <NUM_LIT:1> ) <EOL> print ( <NUM_LIT:1> * <NUM_LIT:1> ) <EOL> print ( a ) <EOL> def func1 ( ) : <EOL> print ( "<STR_LIT:A>" ) <EOL> return <NUM_LIT:0> <EOL> def func11 ( ) : <EOL> a = ( <NUM_LIT:1> , <NUM_LIT:2> , <NUM_LIT:3> , "<STR_LIT:a>" ) <EOL> b = [ <NUM_LIT:1> , <NUM_LIT:2> , <NUM_LIT:3> , "<STR_LIT:b>" ] <EOL> c = <NUM_LIT:0> , <NUM_LIT:11> / <NUM_LIT:2> <EOL> return <NUM_LIT:1> <EOL> def func2 ( ) : <EOL> pass <EOL> def func22 ( ) : <EOL> pass ; <EOL> def func_oneline ( ) : print ( <NUM_LIT:1> ) <EOL> def func_last ( ) : <EOL> if True : print ( <NUM_LIT:1> ) <EOL> pass <EOL> def func_e251 ( a , b = <NUM_LIT:1> , c = <NUM_LIT:3> ) : <EOL> pass <EOL> def func_e251_t ( a , b = <NUM_LIT:1> , c = <NUM_LIT:3> , d = <NUM_LIT:4> ) : <EOL> pass <EOL> ( <NUM_LIT:1> ) <EOL> [ <NUM_LIT:1> ] <EOL> { <NUM_LIT:1> : <NUM_LIT:2> } <EOL> ( <NUM_LIT:1> ) <EOL> [ <NUM_LIT:1> ] <EOL> { <NUM_LIT:1> : <NUM_LIT:2> } <EOL> { <NUM_LIT:4> : <NUM_LIT:2> } <EOL> [ <NUM_LIT:4> , <NUM_LIT:2> ] <EOL> d = [ <NUM_LIT:1> ] <EOL> d [ <NUM_LIT:0> ] <EOL> dummy1 ( <NUM_LIT:0> ) <EOL> def func_e702 ( ) : <EOL> <NUM_LIT:4> ; <NUM_LIT:1> ; <EOL> <NUM_LIT:4> ; <NUM_LIT:1> ; <EOL> <NUM_LIT:4> ; <NUM_LIT:1> ; <EOL> <NUM_LIT:4> ; <NUM_LIT:1> ; <EOL> print ( <NUM_LIT:2> ) ; print ( <NUM_LIT:4> ) ; <NUM_LIT:6> ; <NUM_LIT:8> <EOL> if True : <EOL> <NUM_LIT:1> ; <NUM_LIT:2> ; <NUM_LIT:3> <EOL> <NUM_LIT:0> ; <NUM_LIT:1> <EOL> <NUM_LIT:2> ; <NUM_LIT:3> <EOL> <NUM_LIT:4> ; <NUM_LIT:5> ; <EOL> def func_w602 ( ) : <EOL> raise ValueError , "<STR_LIT>" <EOL> raise ValueError , "<STR_LIT>" <EOL> raise ValueError <EOL> raise ValueError <EOL> raise ValueError , '<STR_LIT>' ; print ( <NUM_LIT:1> ) <EOL> raise ValueError , '<STR_LIT>' ; print ( <NUM_LIT:2> ) <EOL> raise ValueError , '<STR_LIT>' <EOL> raise ValueError , '<STR_LIT>' <EOL> raise ValueError , """<STR_LIT>""" <EOL> raise ValueError , """<STR_LIT>""" <EOL> raise ValueError , '''<STR_LIT>''' <EOL> a = '<STR_LIT:a>' <EOL> raise ValueError , "<STR_LIT:%s>" % ( a , ) <EOL> raise '<STR_LIT:string>' <EOL> def func_w603 ( ) : <EOL> if <NUM_LIT:1> < > <NUM_LIT:2> : <EOL> if <NUM_LIT:2> < > <NUM_LIT:2> : <EOL> print ( True ) <EOL> else : <EOL> print ( False ) <EOL> def func_w604 ( ) : <EOL> a = <NUM_LIT> <EOL> b = ` ` ` a ` ` ` <EOL> def func_e101 ( ) : <EOL> print ( '<STR_LIT:abc>' ) <EOL> if True : <EOL> print ( '<STR_LIT:hello>' ) <EOL> if __name__ == '<STR_LIT:__main__>' : func_last ( ) </s>
<s> from gruffy . stacked_bar import StackedBar <EOL> class AccumulatorBar ( StackedBar ) : <EOL> """<STR_LIT>""" <EOL> def draw ( self ) : <EOL> if not self . has_gdata or len ( self . gdata ) != <NUM_LIT:1> : <EOL> return <EOL> accumulator_array = [ ] <EOL> memo = [ ] <EOL> for index , value in enumerate ( self . gdata [ <NUM_LIT:0> ] [ '<STR_LIT>' ] ) : <EOL> if index > <NUM_LIT:0> : <EOL> memo . append ( value + max ( memo ) ) <EOL> else : <EOL> memo . append ( value ) <EOL> accumulator_array . append ( memo [ index ] - value ) <EOL> self . data ( "<STR_LIT>" , accumulator_array ) <EOL> self . sort = False <EOL> self . gdata . reverse ( ) <EOL> AccumulatorBar . __base__ . draw ( self ) </s>
<s> import sys , os <EOL> sys . path . insert ( <NUM_LIT:0> , os . path . abspath ( os . path . dirname ( __file__ ) ) ) <EOL> from flask . testsuite import main <EOL> main ( ) </s>
<s> import sys <EOL> import os <EOL> import shlex <EOL> extensions = [ <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> ] <EOL> templates_path = [ '<STR_LIT>' ] <EOL> source_suffix = '<STR_LIT>' <EOL> master_doc = '<STR_LIT:index>' <EOL> project = '<STR_LIT>' <EOL> copyright = '<STR_LIT>' <EOL> author = '<STR_LIT>' <EOL> version = '<STR_LIT>' <EOL> release = '<STR_LIT>' <EOL> language = '<STR_LIT>' <EOL> exclude_patterns = [ '<STR_LIT>' ] <EOL> add_function_parentheses = True <EOL> add_module_names = True <EOL> show_authors = False <EOL> pygments_style = '<STR_LIT>' <EOL> todo_include_todos = True <EOL> html_theme = '<STR_LIT>' <EOL> html_static_path = [ '<STR_LIT>' ] <EOL> htmlhelp_basename = '<STR_LIT>' <EOL> latex_elements = { <EOL> } <EOL> latex_documents = [ <EOL> ( master_doc , '<STR_LIT>' , '<STR_LIT>' , <EOL> '<STR_LIT>' , '<STR_LIT>' ) , <EOL> ] <EOL> man_pages = [ <EOL> ( master_doc , '<STR_LIT>' , '<STR_LIT>' , <EOL> [ author ] , <NUM_LIT:1> ) <EOL> ] <EOL> texinfo_documents = [ <EOL> ( master_doc , '<STR_LIT>' , '<STR_LIT>' , <EOL> author , '<STR_LIT>' , '<STR_LIT>' , <EOL> '<STR_LIT>' ) , <EOL> ] <EOL> epub_title = project <EOL> epub_author = author <EOL> epub_publisher = author <EOL> epub_copyright = copyright <EOL> epub_exclude_files = [ '<STR_LIT>' ] </s>
<s> from django . conf . urls . defaults import patterns , url <EOL> urlpatterns = patterns ( '<STR_LIT>' , <EOL> ( r'<STR_LIT>' , '<STR_LIT>' ) , <EOL> ( r'<STR_LIT>' , '<STR_LIT>' ) , <EOL> ( r'<STR_LIT>' , '<STR_LIT>' ) , <EOL> ) </s>
<s> from django . conf . urls . defaults import patterns , url <EOL> from oauth2app . token import TokenGenerator <EOL> from oauth2app . consts import MAC <EOL> urlpatterns = patterns ( '<STR_LIT>' , <EOL> ( r'<STR_LIT>' , '<STR_LIT>' ) , <EOL> ( r'<STR_LIT>' , '<STR_LIT>' ) , <EOL> ( r'<STR_LIT>' , '<STR_LIT>' ) , <EOL> ( r'<STR_LIT>' , '<STR_LIT>' ) , <EOL> ( r'<STR_LIT>' , '<STR_LIT>' ) , <EOL> ( r'<STR_LIT>' , '<STR_LIT>' ) , <EOL> ( r'<STR_LIT>' , '<STR_LIT>' ) , <EOL> ( r'<STR_LIT>' , '<STR_LIT>' ) , <EOL> ( r'<STR_LIT>' , '<STR_LIT>' ) , <EOL> ( r'<STR_LIT>' , '<STR_LIT>' ) , <EOL> ( r'<STR_LIT>' , '<STR_LIT>' ) , <EOL> ( r'<STR_LIT>' , '<STR_LIT>' ) , <EOL> ( r'<STR_LIT>' , TokenGenerator ( authentication_method = MAC ) ) <EOL> ) </s>
<s> from setuptools import setup <EOL> description = "<STR_LIT>" <EOL> try : <EOL> from distutils . command . build_py import build_py_2to3 as build_py <EOL> except ImportError : <EOL> from distutils . command . build_py import build_py <EOL> setup ( <EOL> name = "<STR_LIT>" , <EOL> url = "<STR_LIT>" , <EOL> author = "<STR_LIT>" , <EOL> author_email = "<STR_LIT>" , <EOL> maintainer = '<STR_LIT>' , <EOL> maintainer_email = '<STR_LIT>' , <EOL> version = '<STR_LIT>' , <EOL> packages = [ "<STR_LIT>" , ] , <EOL> description = description . strip ( ) , <EOL> zip_safe = False , <EOL> include_package_data = True , <EOL> classifiers = [ <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> cmdclass = { "<STR_LIT>" : build_py } , <EOL> install_requires = [ "<STR_LIT>" ] , <EOL> test_suite = '<STR_LIT:test>' , <EOL> tests_require = [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] , <EOL> ) </s>
<s> __version__ = "<STR_LIT>" <EOL> """<STR_LIT>""" <EOL> __revision__ = "<STR_LIT>" <EOL> """<STR_LIT>""" <EOL> __date__ = "<STR_LIT>" <EOL> """<STR_LIT>""" <EOL> __copyright__ = "<STR_LIT>" <EOL> """<STR_LIT>""" <EOL> __license__ = "<STR_LIT>" <EOL> """<STR_LIT>""" <EOL> import netius <EOL> from . import base <EOL> class MemoryAuth ( base . Auth ) : <EOL> def __init__ ( self , registry = None , * args , ** kwargs ) : <EOL> base . Auth . __init__ ( self , * args , ** kwargs ) <EOL> self . registry = registry <EOL> @ classmethod <EOL> def auth ( cls , username , password , registry = None , * args , ** kwargs ) : <EOL> registry = registry or cls . get_registry ( ) <EOL> register = registry . get ( username , None ) <EOL> if not register : return False <EOL> _password = register . get ( "<STR_LIT:password>" ) <EOL> return cls . verify ( _password , password ) <EOL> @ classmethod <EOL> def get_registry ( cls ) : <EOL> if hasattr ( cls , "<STR_LIT>" ) : return cls . registry <EOL> cls . registry = cls . load_registry ( ) <EOL> return cls . registry <EOL> @ classmethod <EOL> def load_registry ( cls ) : <EOL> return netius . conf ( "<STR_LIT>" , { } ) <EOL> def auth_i ( self , username , password , * args , ** kwargs ) : <EOL> return self . __class__ . auth ( <EOL> username , <EOL> password , <EOL> registry = self . registry , <EOL> * args , <EOL> ** kwargs <EOL> ) </s>
<s> from pycukes import BeforeAll , AfterAll , BeforeEach , AfterEach <EOL> @ BeforeAll <EOL> def add_message1_attr ( context ) : <EOL> context . counter = <NUM_LIT:1> <EOL> @ BeforeEach <EOL> def add_message_attr ( context ) : <EOL> context . counter += <NUM_LIT:1> <EOL> setattr ( context , '<STR_LIT>' % context . counter , '<STR_LIT>' ) <EOL> @ AfterEach <EOL> def increment_one ( context ) : <EOL> context . counter += <NUM_LIT:1> <EOL> @ AfterAll <EOL> def show_hello_world ( context ) : <EOL> print '<STR_LIT>' </s>
<s> from django . conf . urls . defaults import * <EOL> from django . contrib . auth . views import login , logout <EOL> from mumblr . views . core import ( recent_entries , tagged_entries , entry_detail , <EOL> tag_cloud , archive , RssFeed , AtomFeed ) <EOL> from mumblr . views . admin import ( dashboard , delete_entry , add_entry , edit_entry , <EOL> delete_comment ) <EOL> feeds = { <EOL> '<STR_LIT>' : RssFeed , <EOL> '<STR_LIT>' : AtomFeed , <EOL> } <EOL> urlpatterns = patterns ( '<STR_LIT>' , <EOL> url ( '<STR_LIT>' , recent_entries , name = '<STR_LIT>' ) , <EOL> url ( '<STR_LIT>' , recent_entries , name = '<STR_LIT>' ) , <EOL> url ( '<STR_LIT>' , entry_detail , name = '<STR_LIT>' ) , <EOL> url ( '<STR_LIT>' , tagged_entries , name = '<STR_LIT>' ) , <EOL> url ( '<STR_LIT>' , tagged_entries , <EOL> name = '<STR_LIT>' ) , <EOL> url ( '<STR_LIT>' , archive , name = '<STR_LIT>' ) , <EOL> url ( '<STR_LIT>' , archive , name = '<STR_LIT>' ) , <EOL> url ( '<STR_LIT>' , archive , name = '<STR_LIT>' ) , <EOL> url ( '<STR_LIT>' , <EOL> archive , name = '<STR_LIT>' ) , <EOL> url ( '<STR_LIT>' , tag_cloud , name = '<STR_LIT>' ) , <EOL> url ( '<STR_LIT>' , dashboard , name = '<STR_LIT>' ) , <EOL> url ( '<STR_LIT>' , add_entry , name = '<STR_LIT>' ) , <EOL> url ( '<STR_LIT>' , edit_entry , name = '<STR_LIT>' ) , <EOL> url ( '<STR_LIT>' , delete_entry , name = '<STR_LIT>' ) , <EOL> url ( '<STR_LIT>' , delete_comment , name = '<STR_LIT>' ) , <EOL> url ( '<STR_LIT>' , login , { '<STR_LIT>' : '<STR_LIT>' } , <EOL> name = '<STR_LIT>' ) , <EOL> url ( '<STR_LIT>' , logout , { '<STR_LIT>' : '<STR_LIT:/>' } , name = '<STR_LIT>' ) , <EOL> url ( '<STR_LIT>' , '<STR_LIT>' , <EOL> { '<STR_LIT>' : feeds } , name = '<STR_LIT>' ) , <EOL> ) </s>
<s> from __future__ import absolute_import <EOL> import numpy as np <EOL> import pytest <EOL> from hmmlearn import hmm <EOL> from . import log_likelihood_increasing , normalized <EOL> class TestMultinomialAgainstWikipedia ( object ) : <EOL> """<STR_LIT>""" <EOL> def setup_method ( self , method ) : <EOL> n_components = <NUM_LIT:2> <EOL> n_features = <NUM_LIT:3> <EOL> self . h = hmm . MultinomialHMM ( n_components ) <EOL> self . h . n_features = n_features <EOL> self . h . startprob_ = np . array ( [ <NUM_LIT> , <NUM_LIT> ] ) <EOL> self . h . transmat_ = np . array ( [ [ <NUM_LIT> , <NUM_LIT> ] , [ <NUM_LIT> , <NUM_LIT> ] ] ) <EOL> self . h . emissionprob_ = np . array ( [ [ <NUM_LIT:0.1> , <NUM_LIT> , <NUM_LIT:0.5> ] , <EOL> [ <NUM_LIT> , <NUM_LIT> , <NUM_LIT:0.1> ] ] ) <EOL> def test_decode_viterbi ( self ) : <EOL> X = [ [ <NUM_LIT:0> ] , [ <NUM_LIT:1> ] , [ <NUM_LIT:2> ] ] <EOL> logprob , state_sequence = self . h . decode ( X , algorithm = "<STR_LIT>" ) <EOL> assert round ( np . exp ( logprob ) , <NUM_LIT:5> ) == <NUM_LIT> <EOL> assert np . allclose ( state_sequence , [ <NUM_LIT:1> , <NUM_LIT:0> , <NUM_LIT:0> ] ) <EOL> def test_decode_map ( self ) : <EOL> X = [ [ <NUM_LIT:0> ] , [ <NUM_LIT:1> ] , [ <NUM_LIT:2> ] ] <EOL> _logprob , state_sequence = self . h . decode ( X , algorithm = "<STR_LIT>" ) <EOL> assert np . allclose ( state_sequence , [ <NUM_LIT:1> , <NUM_LIT:0> , <NUM_LIT:0> ] ) <EOL> def test_predict ( self ) : <EOL> X = [ [ <NUM_LIT:0> ] , [ <NUM_LIT:1> ] , [ <NUM_LIT:2> ] ] <EOL> state_sequence = self . h . predict ( X ) <EOL> posteriors = self . h . predict_proba ( X ) <EOL> assert np . allclose ( state_sequence , [ <NUM_LIT:1> , <NUM_LIT:0> , <NUM_LIT:0> ] ) <EOL> assert np . allclose ( posteriors , [ <EOL> [ <NUM_LIT> , <NUM_LIT> ] , <EOL> [ <NUM_LIT> , <NUM_LIT> ] , <EOL> [ <NUM_LIT> , <NUM_LIT> ] , <EOL> ] ) <EOL> class TestMultinomailHMM ( object ) : <EOL> def setup_method ( self , method ) : <EOL> self . n_components = <NUM_LIT:2> <EOL> self . n_features = <NUM_LIT:3> <EOL> self . h = hmm . MultinomialHMM ( self . n_components ) <EOL> self . h . startprob_ = np . array ( [ <NUM_LIT> , <NUM_LIT> ] ) <EOL> self . h . transmat_ = np . array ( [ [ <NUM_LIT> , <NUM_LIT> ] , [ <NUM_LIT> , <NUM_LIT> ] ] ) <EOL> self . h . emissionprob_ = np . array ( [ [ <NUM_LIT:0.1> , <NUM_LIT> , <NUM_LIT:0.5> ] , [ <NUM_LIT> , <NUM_LIT> , <NUM_LIT:0.1> ] ] ) <EOL> def test_attributes ( self ) : <EOL> with pytest . raises ( ValueError ) : <EOL> self . h . emissionprob_ = [ ] <EOL> self . h . _check ( ) <EOL> with pytest . raises ( ValueError ) : <EOL> self . h . emissionprob_ = np . zeros ( ( self . n_components - <NUM_LIT:2> , <EOL> self . n_features ) ) <EOL> self . h . _check ( ) <EOL> def test_score_samples ( self ) : <EOL> idx = np . repeat ( np . arange ( self . n_components ) , <NUM_LIT:10> ) <EOL> n_samples = len ( idx ) <EOL> X = np . random . randint ( self . n_features , size = ( n_samples , <NUM_LIT:1> ) ) <EOL> ll , posteriors = self . h . score_samples ( X ) <EOL> assert posteriors . shape == ( n_samples , self . n_components ) <EOL> assert np . allclose ( posteriors . sum ( axis = <NUM_LIT:1> ) , np . ones ( n_samples ) ) <EOL> def test_sample ( self , n_samples = <NUM_LIT:1000> ) : <EOL> X , state_sequence = self . h . sample ( n_samples ) <EOL> assert X . ndim == <NUM_LIT:2> <EOL> assert len ( X ) == len ( state_sequence ) == n_samples <EOL> assert len ( np . unique ( X ) ) == self . n_features <EOL> def test_fit ( self , params = '<STR_LIT>' , n_iter = <NUM_LIT:5> ) : <EOL> h = self . h <EOL> h . params = params <EOL> lengths = np . array ( [ <NUM_LIT:10> ] * <NUM_LIT:10> ) <EOL> X , _state_sequence = h . sample ( lengths . sum ( ) ) <EOL> h . startprob_ = normalized ( np . random . random ( self . n_components ) ) <EOL> h . transmat_ = normalized ( <EOL> np . random . random ( ( self . n_components , self . n_components ) ) , <EOL> axis = <NUM_LIT:1> ) <EOL> h . emissionprob_ = normalized ( <EOL> np . random . random ( ( self . n_components , self . n_features ) ) , <EOL> axis = <NUM_LIT:1> ) <EOL> assert log_likelihood_increasing ( h , X , lengths , n_iter ) <EOL> def test_fit_emissionprob ( self ) : <EOL> self . test_fit ( '<STR_LIT:e>' ) <EOL> def test_fit_with_init ( self , params = '<STR_LIT>' , n_iter = <NUM_LIT:5> ) : <EOL> lengths = [ <NUM_LIT:10> ] * <NUM_LIT:10> <EOL> X , _state_sequence = self . h . sample ( sum ( lengths ) ) <EOL> h = hmm . MultinomialHMM ( self . n_components , params = params , <EOL> init_params = params ) <EOL> h . _init ( X , lengths = lengths ) <EOL> assert log_likelihood_increasing ( h , X , lengths , n_iter ) <EOL> def test__check_input_symbols ( self ) : <EOL> assert self . h . _check_input_symbols ( [ [ <NUM_LIT:0> , <NUM_LIT:0> , <NUM_LIT:2> , <NUM_LIT:1> , <NUM_LIT:3> , <NUM_LIT:1> , <NUM_LIT:1> ] ] ) <EOL> assert not self . h . _check_input_symbols ( [ [ <NUM_LIT:0> , <NUM_LIT:0> , <NUM_LIT:3> , <NUM_LIT:5> , <NUM_LIT:10> ] ] ) <EOL> assert not self . h . _check_input_symbols ( [ [ <NUM_LIT:0> ] ] ) <EOL> assert not self . h . _check_input_symbols ( [ [ <NUM_LIT:0.> , <NUM_LIT> , <NUM_LIT:1.> , <NUM_LIT> ] ] ) <EOL> assert not self . h . _check_input_symbols ( [ [ <NUM_LIT:0> , <NUM_LIT:0> , - <NUM_LIT:2> , <NUM_LIT:1> , <NUM_LIT:3> , <NUM_LIT:1> , <NUM_LIT:1> ] ] ) </s>
<s> from __future__ import unicode_literals <EOL> from django . db import models , migrations <EOL> class Migration ( migrations . Migration ) : <EOL> dependencies = [ <EOL> ( '<STR_LIT>' , '<STR_LIT>' ) , <EOL> ] <EOL> operations = [ <EOL> migrations . AlterModelOptions ( <EOL> name = '<STR_LIT>' , <EOL> options = { '<STR_LIT>' : [ '<STR_LIT:name>' ] , '<STR_LIT>' : '<STR_LIT>' , '<STR_LIT>' : '<STR_LIT>' } , <EOL> ) , <EOL> migrations . AddField ( <EOL> model_name = '<STR_LIT>' , <EOL> name = '<STR_LIT>' , <EOL> field = models . DateTimeField ( null = True , blank = True ) , <EOL> ) , <EOL> migrations . AddField ( <EOL> model_name = '<STR_LIT>' , <EOL> name = '<STR_LIT>' , <EOL> field = models . DateTimeField ( null = True , blank = True ) , <EOL> ) , <EOL> ] </s>
<s> from __future__ import unicode_literals <EOL> from builtins import str <EOL> from builtins import object <EOL> import logging <EOL> from django . db . utils import IntegrityError <EOL> from scrapy . exceptions import DropItem <EOL> from dynamic_scraper . models import SchedulerRuntime <EOL> class DjangoWriterPipeline ( object ) : <EOL> def process_item ( self , item , spider ) : <EOL> if spider . conf [ '<STR_LIT>' ] : <EOL> try : <EOL> item [ '<STR_LIT>' ] = spider . ref_object <EOL> checker_rt = SchedulerRuntime ( runtime_type = '<STR_LIT:C>' ) <EOL> checker_rt . save ( ) <EOL> item [ '<STR_LIT>' ] = checker_rt <EOL> item . save ( ) <EOL> spider . action_successful = True <EOL> spider . log ( "<STR_LIT>" , logging . INFO ) <EOL> except IntegrityError , e : <EOL> spider . log ( str ( e ) , logging . ERROR ) <EOL> raise DropItem ( "<STR_LIT>" ) <EOL> return item </s>
<s> from __future__ import unicode_literals <EOL> from settings . base_settings import * <EOL> DSCRAPER_IMAGES_STORE_FORMAT = '<STR_LIT>' </s>
<s> """<STR_LIT>""" <EOL> import logging <EOL> import voluptuous as vol <EOL> from homeassistant . const import ( <EOL> CONF_VALUE_TEMPLATE , CONF_PLATFORM , CONF_ENTITY_ID , <EOL> CONF_BELOW , CONF_ABOVE ) <EOL> from homeassistant . helpers . event import track_state_change <EOL> from homeassistant . helpers import condition , config_validation as cv <EOL> TRIGGER_SCHEMA = vol . All ( vol . Schema ( { <EOL> vol . Required ( CONF_PLATFORM ) : '<STR_LIT>' , <EOL> vol . Required ( CONF_ENTITY_ID ) : cv . entity_id , <EOL> CONF_BELOW : vol . Coerce ( float ) , <EOL> CONF_ABOVE : vol . Coerce ( float ) , <EOL> vol . Optional ( CONF_VALUE_TEMPLATE ) : cv . template , <EOL> } ) , cv . has_at_least_one_key ( CONF_BELOW , CONF_ABOVE ) ) <EOL> _LOGGER = logging . getLogger ( __name__ ) <EOL> def trigger ( hass , config , action ) : <EOL> """<STR_LIT>""" <EOL> entity_id = config . get ( CONF_ENTITY_ID ) <EOL> below = config . get ( CONF_BELOW ) <EOL> above = config . get ( CONF_ABOVE ) <EOL> value_template = config . get ( CONF_VALUE_TEMPLATE ) <EOL> def state_automation_listener ( entity , from_s , to_s ) : <EOL> """<STR_LIT>""" <EOL> if to_s is None : <EOL> return <EOL> variables = { <EOL> '<STR_LIT>' : { <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : entity_id , <EOL> '<STR_LIT>' : below , <EOL> '<STR_LIT>' : above , <EOL> } <EOL> } <EOL> if not condition . numeric_state ( <EOL> hass , to_s , below , above , value_template , variables ) : <EOL> return <EOL> if from_s is not None and condition . numeric_state ( <EOL> hass , from_s , below , above , value_template , variables ) : <EOL> return <EOL> variables [ '<STR_LIT>' ] [ '<STR_LIT>' ] = from_s <EOL> variables [ '<STR_LIT>' ] [ '<STR_LIT>' ] = to_s <EOL> action ( variables ) <EOL> track_state_change ( <EOL> hass , entity_id , state_automation_listener ) <EOL> return True </s>
<s> """<STR_LIT>""" <EOL> import logging <EOL> import threading <EOL> from homeassistant import bootstrap <EOL> from homeassistant . const import ( <EOL> ATTR_DISCOVERED , ATTR_SERVICE , EVENT_HOMEASSISTANT_START , <EOL> EVENT_PLATFORM_DISCOVERED ) <EOL> DOMAIN = "<STR_LIT>" <EOL> REQUIREMENTS = [ '<STR_LIT>' ] <EOL> SCAN_INTERVAL = <NUM_LIT> <EOL> SERVICE_WEMO = '<STR_LIT>' <EOL> SERVICE_HUE = '<STR_LIT>' <EOL> SERVICE_CAST = '<STR_LIT>' <EOL> SERVICE_NETGEAR = '<STR_LIT>' <EOL> SERVICE_SONOS = '<STR_LIT>' <EOL> SERVICE_PLEX = '<STR_LIT>' <EOL> SERVICE_SQUEEZEBOX = '<STR_LIT>' <EOL> SERVICE_PANASONIC_VIERA = '<STR_LIT>' <EOL> SERVICE_HANDLERS = { <EOL> SERVICE_WEMO : "<STR_LIT>" , <EOL> SERVICE_CAST : "<STR_LIT>" , <EOL> SERVICE_HUE : "<STR_LIT>" , <EOL> SERVICE_NETGEAR : '<STR_LIT>' , <EOL> SERVICE_SONOS : '<STR_LIT>' , <EOL> SERVICE_PLEX : '<STR_LIT>' , <EOL> SERVICE_SQUEEZEBOX : '<STR_LIT>' , <EOL> SERVICE_PANASONIC_VIERA : '<STR_LIT>' , <EOL> } <EOL> def listen ( hass , service , callback ) : <EOL> """<STR_LIT>""" <EOL> if isinstance ( service , str ) : <EOL> service = ( service , ) <EOL> else : <EOL> service = tuple ( service ) <EOL> def discovery_event_listener ( event ) : <EOL> """<STR_LIT>""" <EOL> if event . data [ ATTR_SERVICE ] in service : <EOL> callback ( event . data [ ATTR_SERVICE ] , event . data . get ( ATTR_DISCOVERED ) ) <EOL> hass . bus . listen ( EVENT_PLATFORM_DISCOVERED , discovery_event_listener ) <EOL> def discover ( hass , service , discovered = None , component = None , hass_config = None ) : <EOL> """<STR_LIT>""" <EOL> if component is not None : <EOL> bootstrap . setup_component ( hass , component , hass_config ) <EOL> data = { <EOL> ATTR_SERVICE : service <EOL> } <EOL> if discovered is not None : <EOL> data [ ATTR_DISCOVERED ] = discovered <EOL> hass . bus . fire ( EVENT_PLATFORM_DISCOVERED , data ) <EOL> def setup ( hass , config ) : <EOL> """<STR_LIT>""" <EOL> logger = logging . getLogger ( __name__ ) <EOL> from netdisco . service import DiscoveryService <EOL> logging . getLogger ( '<STR_LIT>' ) . setLevel ( logging . CRITICAL ) <EOL> lock = threading . Lock ( ) <EOL> def new_service_listener ( service , info ) : <EOL> """<STR_LIT>""" <EOL> with lock : <EOL> logger . info ( "<STR_LIT>" , service , info ) <EOL> component = SERVICE_HANDLERS . get ( service ) <EOL> if not component : <EOL> return <EOL> if not bootstrap . setup_component ( hass , component , config ) : <EOL> return <EOL> hass . bus . fire ( EVENT_PLATFORM_DISCOVERED , { <EOL> ATTR_SERVICE : service , <EOL> ATTR_DISCOVERED : info <EOL> } ) <EOL> def start_discovery ( event ) : <EOL> """<STR_LIT>""" <EOL> netdisco = DiscoveryService ( SCAN_INTERVAL ) <EOL> netdisco . add_listener ( new_service_listener ) <EOL> netdisco . start ( ) <EOL> hass . bus . listen_once ( EVENT_HOMEASSISTANT_START , start_discovery ) <EOL> return True </s>
<s> """<STR_LIT>""" <EOL> import logging <EOL> from homeassistant . components . light import ATTR_RGB_COLOR , Light <EOL> _LOGGER = logging . getLogger ( __name__ ) <EOL> REQUIREMENTS = [ "<STR_LIT>" ] <EOL> def setup_platform ( hass , config , add_devices_callback , discovery_info = None ) : <EOL> """<STR_LIT>""" <EOL> from blinkstick import blinkstick <EOL> stick = blinkstick . find_by_serial ( config [ '<STR_LIT>' ] ) <EOL> add_devices_callback ( [ BlinkStickLight ( stick , config [ '<STR_LIT:name>' ] ) ] ) <EOL> class BlinkStickLight ( Light ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , stick , name ) : <EOL> """<STR_LIT>""" <EOL> self . _stick = stick <EOL> self . _name = name <EOL> self . _serial = stick . get_serial ( ) <EOL> self . _rgb_color = stick . get_color ( ) <EOL> @ property <EOL> def should_poll ( self ) : <EOL> """<STR_LIT>""" <EOL> return True <EOL> @ property <EOL> def name ( self ) : <EOL> """<STR_LIT>""" <EOL> return self . _name <EOL> @ property <EOL> def rgb_color ( self ) : <EOL> """<STR_LIT>""" <EOL> return self . _rgb_color <EOL> @ property <EOL> def is_on ( self ) : <EOL> """<STR_LIT>""" <EOL> return sum ( self . _rgb_color ) > <NUM_LIT:0> <EOL> def update ( self ) : <EOL> """<STR_LIT>""" <EOL> self . _rgb_color = self . _stick . get_color ( ) <EOL> def turn_on ( self , kwargs ) : <EOL> """<STR_LIT>""" <EOL> if ATTR_RGB_COLOR in kwargs : <EOL> self . _rgb_color = kwargs [ ATTR_RGB_COLOR ] <EOL> else : <EOL> self . _rgb_color = [ <NUM_LIT:255> , <NUM_LIT:255> , <NUM_LIT:255> ] <EOL> self . _stick . set_color ( red = self . _rgb_color [ <NUM_LIT:0> ] , <EOL> green = self . _rgb_color [ <NUM_LIT:1> ] , <EOL> blue = self . _rgb_color [ <NUM_LIT:2> ] ) <EOL> def turn_off ( self , kwargs ) : <EOL> """<STR_LIT>""" <EOL> self . _stick . turn_off ( ) </s>
<s> """<STR_LIT>""" <EOL> import logging <EOL> import telnetlib <EOL> from homeassistant . components . media_player import ( <EOL> DOMAIN , SUPPORT_NEXT_TRACK , SUPPORT_PAUSE , SUPPORT_PREVIOUS_TRACK , <EOL> SUPPORT_TURN_OFF , SUPPORT_TURN_ON , SUPPORT_VOLUME_MUTE , SUPPORT_VOLUME_SET , <EOL> MediaPlayerDevice ) <EOL> from homeassistant . const import CONF_HOST , STATE_OFF , STATE_ON , STATE_UNKNOWN <EOL> _LOGGER = logging . getLogger ( __name__ ) <EOL> SUPPORT_DENON = SUPPORT_PAUSE \| SUPPORT_VOLUME_SET \| SUPPORT_VOLUME_MUTE \| SUPPORT_PREVIOUS_TRACK \| SUPPORT_NEXT_TRACK \| SUPPORT_TURN_ON \| SUPPORT_TURN_OFF <EOL> def setup_platform ( hass , config , add_devices , discovery_info = None ) : <EOL> """<STR_LIT>""" <EOL> if not config . get ( CONF_HOST ) : <EOL> _LOGGER . error ( <EOL> "<STR_LIT>" , <EOL> DOMAIN , <EOL> CONF_HOST ) <EOL> return False <EOL> denon = DenonDevice ( <EOL> config . get ( "<STR_LIT:name>" , "<STR_LIT>" ) , <EOL> config . get ( "<STR_LIT:host>" ) <EOL> ) <EOL> if denon . update ( ) : <EOL> add_devices ( [ denon ] ) <EOL> return True <EOL> else : <EOL> return False <EOL> class DenonDevice ( MediaPlayerDevice ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , name , host ) : <EOL> """<STR_LIT>""" <EOL> self . _name = name <EOL> self . _host = host <EOL> self . _pwstate = "<STR_LIT>" <EOL> self . _volume = <NUM_LIT:0> <EOL> self . _muted = False <EOL> self . _mediasource = "<STR_LIT>" <EOL> @ classmethod <EOL> def telnet_request ( cls , telnet , command ) : <EOL> """<STR_LIT>""" <EOL> telnet . write ( command . encode ( "<STR_LIT>" ) + b"<STR_LIT:\r>" ) <EOL> return telnet . read_until ( b"<STR_LIT:\r>" , timeout = <NUM_LIT> ) . decode ( "<STR_LIT>" ) . strip ( ) <EOL> def telnet_command ( self , command ) : <EOL> """<STR_LIT>""" <EOL> telnet = telnetlib . Telnet ( self . _host ) <EOL> telnet . write ( command . encode ( "<STR_LIT>" ) + b"<STR_LIT:\r>" ) <EOL> telnet . read_very_eager ( ) <EOL> telnet . close ( ) <EOL> def update ( self ) : <EOL> """<STR_LIT>""" <EOL> try : <EOL> telnet = telnetlib . Telnet ( self . _host ) <EOL> except ConnectionRefusedError : <EOL> return False <EOL> self . _pwstate = self . telnet_request ( telnet , "<STR_LIT>" ) <EOL> telnet . read_until ( b"<STR_LIT:\r>" , timeout = <NUM_LIT> ) <EOL> volume_str = self . telnet_request ( telnet , "<STR_LIT>" ) [ len ( "<STR_LIT>" ) : ] <EOL> self . _volume = int ( volume_str ) / <NUM_LIT> <EOL> self . _muted = ( self . telnet_request ( telnet , "<STR_LIT>" ) == "<STR_LIT>" ) <EOL> self . _mediasource = self . telnet_request ( telnet , "<STR_LIT>" ) [ len ( "<STR_LIT>" ) : ] <EOL> telnet . close ( ) <EOL> return True <EOL> @ property <EOL> def name ( self ) : <EOL> """<STR_LIT>""" <EOL> return self . _name <EOL> @ property <EOL> def state ( self ) : <EOL> """<STR_LIT>""" <EOL> if self . _pwstate == "<STR_LIT>" : <EOL> return STATE_OFF <EOL> if self . _pwstate == "<STR_LIT>" : <EOL> return STATE_ON <EOL> return STATE_UNKNOWN <EOL> @ property <EOL> def volume_level ( self ) : <EOL> """<STR_LIT>""" <EOL> return self . _volume <EOL> @ property <EOL> def is_volume_muted ( self ) : <EOL> """<STR_LIT>""" <EOL> return self . _muted <EOL> @ property <EOL> def media_title ( self ) : <EOL> """<STR_LIT>""" <EOL> return self . _mediasource <EOL> @ property <EOL> def supported_media_commands ( self ) : <EOL> """<STR_LIT>""" <EOL> return SUPPORT_DENON <EOL> def turn_off ( self ) : <EOL> """<STR_LIT>""" <EOL> self . telnet_command ( "<STR_LIT>" ) <EOL> def volume_up ( self ) : <EOL> """<STR_LIT>""" <EOL> self . telnet_command ( "<STR_LIT>" ) <EOL> def volume_down ( self ) : <EOL> """<STR_LIT>""" <EOL> self . telnet_command ( "<STR_LIT>" ) <EOL> def set_volume_level ( self , volume ) : <EOL> """<STR_LIT>""" <EOL> self . telnet_command ( "<STR_LIT>" + str ( round ( volume * <NUM_LIT> ) ) . zfill ( <NUM_LIT:2> ) ) <EOL> def mute_volume ( self , mute ) : <EOL> """<STR_LIT>""" <EOL> self . telnet_command ( "<STR_LIT>" + ( "<STR_LIT>" if mute else "<STR_LIT>" ) ) <EOL> def media_play ( self ) : <EOL> """<STR_LIT>""" <EOL> self . telnet_command ( "<STR_LIT>" ) <EOL> def media_pause ( self ) : <EOL> """<STR_LIT>""" <EOL> self . telnet_command ( "<STR_LIT>" ) <EOL> def media_next_track ( self ) : <EOL> """<STR_LIT>""" <EOL> self . telnet_command ( "<STR_LIT>" ) <EOL> def media_previous_track ( self ) : <EOL> """<STR_LIT>""" <EOL> self . telnet_command ( "<STR_LIT>" ) <EOL> def turn_on ( self ) : <EOL> """<STR_LIT>""" <EOL> self . telnet_command ( "<STR_LIT>" ) </s>
<s> """<STR_LIT>""" <EOL> import json <EOL> import logging <EOL> import requests <EOL> from homeassistant . components . notify import ( <EOL> ATTR_TITLE , DOMAIN , BaseNotificationService ) <EOL> from homeassistant . const import CONF_API_KEY <EOL> from homeassistant . helpers import validate_config <EOL> _LOGGER = logging . getLogger ( __name__ ) <EOL> _RESOURCE = '<STR_LIT>' <EOL> def get_service ( hass , config ) : <EOL> """<STR_LIT>""" <EOL> if not validate_config ( { DOMAIN : config } , <EOL> { DOMAIN : [ CONF_API_KEY , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' ] } , <EOL> _LOGGER ) : <EOL> return None <EOL> headers = { '<STR_LIT>' : config [ CONF_API_KEY ] , <EOL> '<STR_LIT>' : config [ '<STR_LIT>' ] } <EOL> try : <EOL> response = requests . get ( _RESOURCE + '<STR_LIT>' , <EOL> headers = headers ) . json ( ) <EOL> except ValueError : <EOL> _LOGGER . error ( '<STR_LIT>' ) <EOL> return None <EOL> if '<STR_LIT:error>' in response : <EOL> _LOGGER . error ( response [ '<STR_LIT>' ] ) <EOL> return None <EOL> if len ( [ app for app in response if app [ '<STR_LIT:title>' ] == config [ '<STR_LIT>' ] ] ) == <NUM_LIT:0> : <EOL> _LOGGER . error ( <EOL> "<STR_LIT>" <EOL> "<STR_LIT>" ) <EOL> return None <EOL> return InstapushNotificationService ( <EOL> config [ CONF_API_KEY ] , config [ '<STR_LIT>' ] , config [ '<STR_LIT>' ] , <EOL> config [ '<STR_LIT>' ] ) <EOL> class InstapushNotificationService ( BaseNotificationService ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , api_key , app_secret , event , tracker ) : <EOL> """<STR_LIT>""" <EOL> self . _api_key = api_key <EOL> self . _app_secret = app_secret <EOL> self . _event = event <EOL> self . _tracker = tracker <EOL> self . _headers = { <EOL> '<STR_LIT>' : self . _api_key , <EOL> '<STR_LIT>' : self . _app_secret , <EOL> '<STR_LIT:Content-Type>' : '<STR_LIT:application/json>' } <EOL> def send_message ( self , message = "<STR_LIT>" , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> title = kwargs . get ( ATTR_TITLE ) <EOL> data = { "<STR_LIT>" : self . _event , <EOL> "<STR_LIT>" : { self . _tracker : title + "<STR_LIT>" + message } } <EOL> response = requests . post ( _RESOURCE + '<STR_LIT>' , data = json . dumps ( data ) , <EOL> headers = self . _headers ) <EOL> if response . json ( ) [ '<STR_LIT:status>' ] == <NUM_LIT> : <EOL> _LOGGER . error ( <EOL> response . json ( ) [ '<STR_LIT>' ] , <EOL> "<STR_LIT>" ) </s>
<s> """<STR_LIT>""" <EOL> import logging <EOL> from threading import Lock <EOL> from homeassistant . core import EVENT_HOMEASSISTANT_STOP <EOL> REQUIREMENTS = [ '<STR_LIT>' ] <EOL> DOMAIN = "<STR_LIT>" <EOL> SCSGATE = None <EOL> _LOGGER = logging . getLogger ( __name__ ) <EOL> class SCSGate : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , device , logger ) : <EOL> """<STR_LIT>""" <EOL> self . _logger = logger <EOL> self . _devices = { } <EOL> self . _devices_to_register = { } <EOL> self . _devices_to_register_lock = Lock ( ) <EOL> self . _device_being_registered = None <EOL> self . _device_being_registered_lock = Lock ( ) <EOL> from scsgate . connection import Connection <EOL> connection = Connection ( device = device , logger = self . _logger ) <EOL> from scsgate . reactor import Reactor <EOL> self . _reactor = Reactor ( <EOL> connection = connection , <EOL> logger = self . _logger , <EOL> handle_message = self . handle_message ) <EOL> def handle_message ( self , message ) : <EOL> """<STR_LIT>""" <EOL> from scsgate . messages import StateMessage , ScenarioTriggeredMessage <EOL> self . _logger . debug ( "<STR_LIT>" . format ( message ) ) <EOL> if not isinstance ( message , StateMessage ) and not isinstance ( message , ScenarioTriggeredMessage ) : <EOL> msg = "<STR_LIT>" . format ( <EOL> message ) <EOL> self . _logger . debug ( msg ) <EOL> return <EOL> if message . entity in self . _devices : <EOL> new_device_activated = False <EOL> with self . _devices_to_register_lock : <EOL> if message . entity == self . _device_being_registered : <EOL> self . _device_being_registered = None <EOL> new_device_activated = True <EOL> if new_device_activated : <EOL> self . _activate_next_device ( ) <EOL> try : <EOL> self . _devices [ message . entity ] . process_event ( message ) <EOL> except Exception as exception : <EOL> msg = "<STR_LIT>" . format ( <EOL> exception ) <EOL> self . _logger . error ( msg ) <EOL> else : <EOL> self . _logger . info ( <EOL> "<STR_LIT>" . format ( <EOL> message . entity ) ) <EOL> @ property <EOL> def devices ( self ) : <EOL> """<STR_LIT>""" <EOL> return self . _devices <EOL> def add_device ( self , device ) : <EOL> """<STR_LIT>""" <EOL> self . _devices [ device . scs_id ] = device <EOL> def add_devices_to_register ( self , devices ) : <EOL> """<STR_LIT>""" <EOL> with self . _devices_to_register_lock : <EOL> for device in devices : <EOL> self . _devices_to_register [ device . scs_id ] = device <EOL> self . _activate_next_device ( ) <EOL> def _activate_next_device ( self ) : <EOL> """<STR_LIT>""" <EOL> from scsgate . tasks import GetStatusTask <EOL> with self . _devices_to_register_lock : <EOL> while len ( self . _devices_to_register ) != <NUM_LIT:0> : <EOL> _ , device = self . _devices_to_register . popitem ( ) <EOL> self . _devices [ device . scs_id ] = device <EOL> self . _device_being_registered = device . scs_id <EOL> self . _reactor . append_task ( GetStatusTask ( target = device . scs_id ) ) <EOL> def is_device_registered ( self , device_id ) : <EOL> """<STR_LIT>""" <EOL> with self . _devices_to_register_lock : <EOL> if device_id in self . _devices_to_register . keys ( ) : <EOL> return False <EOL> with self . _device_being_registered_lock : <EOL> if device_id == self . _device_being_registered : <EOL> return False <EOL> return True <EOL> def start ( self ) : <EOL> """<STR_LIT>""" <EOL> self . _reactor . start ( ) <EOL> def stop ( self ) : <EOL> """<STR_LIT>""" <EOL> self . _reactor . stop ( ) <EOL> def append_task ( self , task ) : <EOL> """<STR_LIT>""" <EOL> self . _reactor . append_task ( task ) <EOL> def setup ( hass , config ) : <EOL> """<STR_LIT>""" <EOL> device = config [ '<STR_LIT>' ] [ '<STR_LIT>' ] <EOL> global SCSGATE <EOL> try : <EOL> SCSGATE = SCSGate ( device = device , logger = _LOGGER ) <EOL> SCSGATE . start ( ) <EOL> except Exception as exception : <EOL> _LOGGER . error ( "<STR_LIT>" , exception ) <EOL> return False <EOL> def stop_monitor ( event ) : <EOL> """<STR_LIT>""" <EOL> _LOGGER . info ( "<STR_LIT>" ) <EOL> SCSGATE . stop ( ) <EOL> hass . bus . listen_once ( EVENT_HOMEASSISTANT_STOP , stop_monitor ) <EOL> return True </s>
<s> """<STR_LIT>""" <EOL> import logging <EOL> from datetime import timedelta <EOL> import requests <EOL> from homeassistant . helpers . entity import Entity <EOL> from homeassistant . util import Throttle <EOL> REQUIREMENTS = [ ] <EOL> SENSOR_TYPES = { <EOL> "<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>" , None ) , <EOL> "<STR_LIT>" : ( "<STR_LIT>" , "<STR_LIT>" ) , <EOL> "<STR_LIT>" : ( "<STR_LIT>" , None ) , <EOL> "<STR_LIT>" : ( "<STR_LIT>" , "<STR_LIT>" ) , <EOL> } <EOL> DEFAULT_TYPES = [ <EOL> "<STR_LIT>" , <EOL> "<STR_LIT>" , <EOL> "<STR_LIT>" , <EOL> ] <EOL> _LOGGER = logging . getLogger ( __name__ ) <EOL> def setup_platform ( hass , config , add_devices , discovery_info = None ) : <EOL> """<STR_LIT>""" <EOL> base_url = config . get ( "<STR_LIT>" ) <EOL> name = config . get ( "<STR_LIT:name>" , "<STR_LIT>" ) <EOL> username = config . get ( "<STR_LIT:username>" ) <EOL> password = config . get ( "<STR_LIT:password>" ) <EOL> monitored_types = config . get ( "<STR_LIT>" , DEFAULT_TYPES ) <EOL> if not base_url : <EOL> _LOGGER . error ( "<STR_LIT>" ) <EOL> return False <EOL> url = "<STR_LIT>" . format ( base_url ) <EOL> try : <EOL> nzbgetapi = NZBGetAPI ( api_url = url , <EOL> username = username , <EOL> password = password ) <EOL> nzbgetapi . update ( ) <EOL> except ( requests . exceptions . ConnectionError , <EOL> requests . exceptions . HTTPError ) as conn_err : <EOL> _LOGGER . error ( "<STR_LIT>" , conn_err ) <EOL> return False <EOL> devices = [ ] <EOL> for ng_type in monitored_types : <EOL> if ng_type in SENSOR_TYPES : <EOL> new_sensor = NZBGetSensor ( api = nzbgetapi , <EOL> sensor_type = ng_type , <EOL> client_name = name ) <EOL> devices . append ( new_sensor ) <EOL> else : <EOL> _LOGGER . error ( "<STR_LIT>" , ng_type ) <EOL> add_devices ( devices ) <EOL> class NZBGetAPI ( object ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , api_url , username = None , password = None ) : <EOL> """<STR_LIT>""" <EOL> self . api_url = api_url <EOL> self . status = None <EOL> self . headers = { '<STR_LIT>' : '<STR_LIT:application/json>' } <EOL> if username is not None and password is not None : <EOL> self . auth = ( username , password ) <EOL> else : <EOL> self . auth = None <EOL> self . update ( ) <EOL> def post ( self , method , params = None ) : <EOL> """<STR_LIT>""" <EOL> payload = { "<STR_LIT>" : method } <EOL> if params : <EOL> payload [ '<STR_LIT>' ] = params <EOL> try : <EOL> response = requests . post ( self . api_url , <EOL> json = payload , <EOL> auth = self . auth , <EOL> headers = self . headers , <EOL> timeout = <NUM_LIT:30> ) <EOL> response . raise_for_status ( ) <EOL> return response . json ( ) <EOL> except requests . exceptions . ConnectionError as conn_exc : <EOL> _LOGGER . error ( "<STR_LIT>" , <EOL> self . api_url , conn_exc ) <EOL> raise <EOL> @ Throttle ( timedelta ( seconds = <NUM_LIT:5> ) ) <EOL> def update ( self ) : <EOL> """<STR_LIT>""" <EOL> try : <EOL> self . status = self . post ( '<STR_LIT:status>' ) [ '<STR_LIT:result>' ] <EOL> except requests . exceptions . ConnectionError : <EOL> raise <EOL> class NZBGetSensor ( Entity ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , api , sensor_type , client_name ) : <EOL> """<STR_LIT>""" <EOL> self . _name = client_name + '<STR_LIT:U+0020>' + SENSOR_TYPES [ sensor_type ] [ <NUM_LIT:0> ] <EOL> self . type = sensor_type <EOL> self . client_name = client_name <EOL> self . api = api <EOL> self . _state = None <EOL> self . _unit_of_measurement = SENSOR_TYPES [ sensor_type ] [ <NUM_LIT:1> ] <EOL> self . update ( ) <EOL> _LOGGER . debug ( "<STR_LIT>" , self ) <EOL> @ property <EOL> def name ( self ) : <EOL> """<STR_LIT>""" <EOL> return self . _name <EOL> @ property <EOL> def state ( self ) : <EOL> """<STR_LIT>""" <EOL> return self . _state <EOL> @ property <EOL> def unit_of_measurement ( self ) : <EOL> """<STR_LIT>""" <EOL> return self . _unit_of_measurement <EOL> def update ( self ) : <EOL> """<STR_LIT>""" <EOL> try : <EOL> self . api . update ( ) <EOL> except requests . exceptions . ConnectionError : <EOL> return <EOL> if self . api . status is None : <EOL> _LOGGER . debug ( "<STR_LIT>" , <EOL> self . _name ) <EOL> return <EOL> value = self . api . status . get ( self . type ) <EOL> if value is None : <EOL> _LOGGER . warning ( "<STR_LIT>" , self . type ) <EOL> return <EOL> if "<STR_LIT>" in self . type and value > <NUM_LIT:0> : <EOL> self . _state = value / <NUM_LIT> / <NUM_LIT> <EOL> else : <EOL> self . _state = value </s>
<s> """<STR_LIT>""" <EOL> import logging <EOL> import subprocess <EOL> import voluptuous as vol <EOL> import homeassistant . helpers . config_validation as cv <EOL> DOMAIN = '<STR_LIT>' <EOL> _LOGGER = logging . getLogger ( __name__ ) <EOL> CONFIG_SCHEMA = vol . Schema ( { <EOL> DOMAIN : vol . Schema ( { <EOL> cv . slug : cv . string , <EOL> } ) , <EOL> } , extra = vol . ALLOW_EXTRA ) <EOL> SHELL_COMMAND_SCHEMA = vol . Schema ( { } ) <EOL> def setup ( hass , config ) : <EOL> """<STR_LIT>""" <EOL> conf = config . get ( DOMAIN , { } ) <EOL> def service_handler ( call ) : <EOL> """<STR_LIT>""" <EOL> try : <EOL> subprocess . call ( conf [ call . service ] , shell = True , <EOL> stdout = subprocess . DEVNULL , <EOL> stderr = subprocess . DEVNULL ) <EOL> except subprocess . SubprocessError : <EOL> _LOGGER . exception ( '<STR_LIT>' ) <EOL> for name in conf . keys ( ) : <EOL> hass . services . register ( DOMAIN , name , service_handler , <EOL> schema = SHELL_COMMAND_SCHEMA ) <EOL> return True </s>
<s> """<STR_LIT>""" <EOL> import time <EOL> import logging <EOL> from datetime import timedelta <EOL> import homeassistant . util as util <EOL> from homeassistant . const import ( STATE_ON , STATE_OFF ) <EOL> from homeassistant . helpers . entity import ToggleEntity <EOL> _LOGGER = logging . getLogger ( __name__ ) <EOL> REQUIREMENTS = [ '<STR_LIT>' <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' ] <EOL> MIN_TIME_BETWEEN_SCANS = timedelta ( seconds = <NUM_LIT:10> ) <EOL> MIN_TIME_BETWEEN_FORCED_SCANS = timedelta ( milliseconds = <NUM_LIT:100> ) <EOL> MIN_TIME_TO_WAIT = timedelta ( seconds = <NUM_LIT:5> ) <EOL> MIN_TIME_TO_LOCK_UPDATE = <NUM_LIT:5> <EOL> SWITCH_TYPES = { <EOL> '<STR_LIT>' : [ '<STR_LIT>' , None , None ] , <EOL> '<STR_LIT>' : [ '<STR_LIT>' , None , None ] , <EOL> '<STR_LIT>' : [ '<STR_LIT>' , None , None ] , <EOL> } <EOL> def setup_platform ( hass , config , add_devices , discovery_info = None ) : <EOL> """<STR_LIT>""" <EOL> from pythinkingcleaner import Discovery <EOL> discovery = Discovery ( ) <EOL> devices = discovery . discover ( ) <EOL> @ util . Throttle ( MIN_TIME_BETWEEN_SCANS , MIN_TIME_BETWEEN_FORCED_SCANS ) <EOL> def update_devices ( ) : <EOL> """<STR_LIT>""" <EOL> for device_object in devices : <EOL> device_object . update ( ) <EOL> dev = [ ] <EOL> for device in devices : <EOL> for type_name in SWITCH_TYPES . keys ( ) : <EOL> dev . append ( ThinkingCleanerSwitch ( device , type_name , <EOL> update_devices ) ) <EOL> add_devices ( dev ) <EOL> class ThinkingCleanerSwitch ( ToggleEntity ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , tc_object , switch_type , update_devices ) : <EOL> """<STR_LIT>""" <EOL> self . type = switch_type <EOL> self . _update_devices = update_devices <EOL> self . _tc_object = tc_object <EOL> self . _state = self . _tc_object . is_cleaning if switch_type == '<STR_LIT>' else False <EOL> self . lock = False <EOL> self . last_lock_time = None <EOL> self . graceful_state = False <EOL> def lock_update ( self ) : <EOL> """<STR_LIT>""" <EOL> if self . is_update_locked ( ) : <EOL> return <EOL> self . lock = True <EOL> self . last_lock_time = time . time ( ) <EOL> def reset_update_lock ( self ) : <EOL> """<STR_LIT>""" <EOL> self . lock = False <EOL> self . last_lock_time = None <EOL> def set_graceful_lock ( self , state ) : <EOL> """<STR_LIT>""" <EOL> self . graceful_state = state <EOL> self . reset_update_lock ( ) <EOL> self . lock_update ( ) <EOL> def is_update_locked ( self ) : <EOL> """<STR_LIT>""" <EOL> if self . last_lock_time is None : <EOL> return False <EOL> if time . time ( ) - self . last_lock_time >= MIN_TIME_TO_LOCK_UPDATE : <EOL> self . last_lock_time = None <EOL> return False <EOL> return True <EOL> @ property <EOL> def name ( self ) : <EOL> """<STR_LIT>""" <EOL> return self . _tc_object . name + '<STR_LIT:U+0020>' + SWITCH_TYPES [ self . type ] [ <NUM_LIT:0> ] <EOL> @ property <EOL> def is_on ( self ) : <EOL> """<STR_LIT>""" <EOL> if self . type == '<STR_LIT>' : <EOL> return self . graceful_state if self . is_update_locked ( ) else self . _tc_object . is_cleaning <EOL> return False <EOL> def turn_on ( self , kwargs ) : <EOL> """<STR_LIT>""" <EOL> if self . type == '<STR_LIT>' : <EOL> self . set_graceful_lock ( True ) <EOL> self . _tc_object . start_cleaning ( ) <EOL> elif self . type == '<STR_LIT>' : <EOL> self . _tc_object . dock ( ) <EOL> elif self . type == '<STR_LIT>' : <EOL> self . _tc_object . find_me ( ) <EOL> def turn_off ( self , kwargs ) : <EOL> """<STR_LIT>""" <EOL> if self . type == '<STR_LIT>' : <EOL> self . set_graceful_lock ( False ) <EOL> self . _tc_object . stop_cleaning ( ) <EOL> def update ( self ) : <EOL> """<STR_LIT>""" <EOL> if self . type == '<STR_LIT>' and not self . is_update_locked ( ) : <EOL> self . _tc_object . update ( ) <EOL> self . _state = STATE_ON if self . _tc_object . is_cleaning else STATE_OFF </s>
<s> """<STR_LIT>""" <EOL> import logging <EOL> from homeassistant . components import discovery <EOL> from homeassistant . const import EVENT_HOMEASSISTANT_STOP <EOL> REQUIREMENTS = [ '<STR_LIT>' ] <EOL> DOMAIN = '<STR_LIT>' <EOL> DISCOVER_LIGHTS = '<STR_LIT>' <EOL> DISCOVER_BINARY_SENSORS = '<STR_LIT>' <EOL> DISCOVER_SWITCHES = '<STR_LIT>' <EOL> WEMO_MODEL_DISPATCH = { <EOL> '<STR_LIT>' : DISCOVER_LIGHTS , <EOL> '<STR_LIT>' : DISCOVER_SWITCHES , <EOL> '<STR_LIT>' : DISCOVER_SWITCHES , <EOL> '<STR_LIT>' : DISCOVER_BINARY_SENSORS , <EOL> '<STR_LIT>' : DISCOVER_SWITCHES , <EOL> '<STR_LIT>' : DISCOVER_SWITCHES <EOL> } <EOL> WEMO_SERVICE_DISPATCH = { <EOL> DISCOVER_LIGHTS : '<STR_LIT>' , <EOL> DISCOVER_BINARY_SENSORS : '<STR_LIT>' , <EOL> DISCOVER_SWITCHES : '<STR_LIT>' , <EOL> } <EOL> SUBSCRIPTION_REGISTRY = None <EOL> KNOWN_DEVICES = [ ] <EOL> _LOGGER = logging . getLogger ( __name__ ) <EOL> def setup ( hass , config ) : <EOL> """<STR_LIT>""" <EOL> import pywemo <EOL> global SUBSCRIPTION_REGISTRY <EOL> SUBSCRIPTION_REGISTRY = pywemo . SubscriptionRegistry ( ) <EOL> SUBSCRIPTION_REGISTRY . start ( ) <EOL> def stop_wemo ( event ) : <EOL> """<STR_LIT>""" <EOL> _LOGGER . info ( "<STR_LIT>" ) <EOL> SUBSCRIPTION_REGISTRY . stop ( ) <EOL> hass . bus . listen_once ( EVENT_HOMEASSISTANT_STOP , stop_wemo ) <EOL> def discovery_dispatch ( service , discovery_info ) : <EOL> """<STR_LIT>""" <EOL> _ , model_name , _ , _ , serial = discovery_info <EOL> if serial in KNOWN_DEVICES : <EOL> return <EOL> _LOGGER . debug ( '<STR_LIT>' , serial ) <EOL> KNOWN_DEVICES . append ( serial ) <EOL> service = WEMO_MODEL_DISPATCH . get ( model_name ) or DISCOVER_SWITCHES <EOL> component = WEMO_SERVICE_DISPATCH . get ( service ) <EOL> discovery . discover ( hass , service , discovery_info , <EOL> component , config ) <EOL> discovery . listen ( hass , discovery . SERVICE_WEMO , discovery_dispatch ) <EOL> _LOGGER . info ( "<STR_LIT>" ) <EOL> devices = [ ( device . host , device ) for device in pywemo . discover_devices ( ) ] <EOL> devices . extend ( ( address , None ) <EOL> for address in config . get ( DOMAIN , { } ) . get ( '<STR_LIT>' , [ ] ) ) <EOL> for address , device in devices : <EOL> port = pywemo . ouimeaux_device . probe_wemo ( address ) <EOL> if not port : <EOL> _LOGGER . warning ( '<STR_LIT>' , address ) <EOL> continue <EOL> _LOGGER . info ( '<STR_LIT>' , address , port ) <EOL> url = '<STR_LIT>' % ( address , port ) <EOL> if device is None : <EOL> device = pywemo . discovery . device_from_description ( url , None ) <EOL> discovery_info = ( device . name , device . model_name , url , device . mac , <EOL> device . serialnumber ) <EOL> discovery . discover ( hass , discovery . SERVICE_WEMO , discovery_info ) <EOL> return True </s>
<s> """<STR_LIT>""" <EOL> import collections <EOL> import requests <EOL> from vincenty import vincenty <EOL> ELEVATION_URL = '<STR_LIT>' <EOL> LocationInfo = collections . namedtuple ( <EOL> "<STR_LIT>" , <EOL> [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , <EOL> '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , <EOL> '<STR_LIT>' ] ) <EOL> DATA_SOURCE = [ '<STR_LIT>' , '<STR_LIT>' ] <EOL> def detect_location_info ( ) : <EOL> """<STR_LIT>""" <EOL> success = None <EOL> for source in DATA_SOURCE : <EOL> try : <EOL> raw_info = requests . get ( source , timeout = <NUM_LIT:5> ) . json ( ) <EOL> success = source <EOL> break <EOL> except ( requests . RequestException , ValueError ) : <EOL> success = False <EOL> if success is False : <EOL> return None <EOL> else : <EOL> data = { key : raw_info . get ( key ) for key in LocationInfo . _fields } <EOL> if success is DATA_SOURCE [ <NUM_LIT:1> ] : <EOL> data [ '<STR_LIT>' ] = raw_info . get ( '<STR_LIT>' ) <EOL> data [ '<STR_LIT>' ] = raw_info . get ( '<STR_LIT>' ) <EOL> data [ '<STR_LIT>' ] = raw_info . get ( '<STR_LIT>' ) <EOL> data [ '<STR_LIT>' ] = raw_info . get ( '<STR_LIT>' ) <EOL> data [ '<STR_LIT>' ] = raw_info . get ( '<STR_LIT>' ) <EOL> data [ '<STR_LIT>' ] = raw_info . get ( '<STR_LIT>' ) <EOL> data [ '<STR_LIT>' ] = raw_info . get ( '<STR_LIT>' ) <EOL> data [ '<STR_LIT>' ] = raw_info . get ( '<STR_LIT>' ) <EOL> data [ '<STR_LIT>' ] = raw_info . get ( '<STR_LIT>' ) <EOL> data [ '<STR_LIT>' ] = data [ '<STR_LIT>' ] in ( <EOL> '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ) <EOL> return LocationInfo ( ** data ) <EOL> def distance ( lat1 , lon1 , lat2 , lon2 ) : <EOL> """<STR_LIT>""" <EOL> return vincenty ( ( lat1 , lon1 ) , ( lat2 , lon2 ) ) * <NUM_LIT:1000> <EOL> def elevation ( latitude , longitude ) : <EOL> """<STR_LIT>""" <EOL> req = requests . get ( ELEVATION_URL , params = { <EOL> '<STR_LIT>' : '<STR_LIT>' . format ( latitude , longitude ) , <EOL> '<STR_LIT>' : '<STR_LIT:false>' , <EOL> } ) <EOL> if req . status_code != <NUM_LIT:200> : <EOL> return <NUM_LIT:0> <EOL> try : <EOL> return int ( float ( req . json ( ) [ '<STR_LIT>' ] [ <NUM_LIT:0> ] [ '<STR_LIT>' ] ) ) <EOL> except ( ValueError , KeyError ) : <EOL> return <NUM_LIT:0> </s>
<s> """<STR_LIT>""" <EOL> import requests <EOL> import unittest <EOL> from unittest import mock <EOL> from homeassistant . components . binary_sensor import nx584 <EOL> from nx584 import client as nx584_client <EOL> class StopMe ( Exception ) : <EOL> """<STR_LIT>""" <EOL> pass <EOL> class TestNX584SensorSetup ( unittest . TestCase ) : <EOL> """<STR_LIT>""" <EOL> def setUp ( self ) : <EOL> """<STR_LIT>""" <EOL> self . _mock_client = mock . patch . object ( nx584_client , '<STR_LIT>' ) <EOL> self . _mock_client . start ( ) <EOL> self . fake_zones = [ <EOL> { '<STR_LIT:name>' : '<STR_LIT>' , '<STR_LIT>' : <NUM_LIT:1> } , <EOL> { '<STR_LIT:name>' : '<STR_LIT>' , '<STR_LIT>' : <NUM_LIT:2> } , <EOL> { '<STR_LIT:name>' : '<STR_LIT>' , '<STR_LIT>' : <NUM_LIT:3> } , <EOL> ] <EOL> client = nx584_client . Client . return_value <EOL> client . list_zones . return_value = self . fake_zones <EOL> client . get_version . return_value = '<STR_LIT>' <EOL> def tearDown ( self ) : <EOL> """<STR_LIT>""" <EOL> self . _mock_client . stop ( ) <EOL> @ mock . patch ( '<STR_LIT>' ) <EOL> @ mock . patch ( '<STR_LIT>' ) <EOL> def test_setup_no_config ( self , mock_nx , mock_watcher ) : <EOL> """<STR_LIT>""" <EOL> add_devices = mock . MagicMock ( ) <EOL> hass = mock . MagicMock ( ) <EOL> self . assertTrue ( nx584 . setup_platform ( hass , { } , add_devices ) ) <EOL> mock_nx . assert_has_calls ( [ <EOL> mock . call ( zone , '<STR_LIT>' ) <EOL> for zone in self . fake_zones ] ) <EOL> self . assertTrue ( add_devices . called ) <EOL> nx584_client . Client . assert_called_once_with ( '<STR_LIT>' ) <EOL> @ mock . patch ( '<STR_LIT>' ) <EOL> @ mock . patch ( '<STR_LIT>' ) <EOL> def test_setup_full_config ( self , mock_nx , mock_watcher ) : <EOL> """<STR_LIT>""" <EOL> config = { <EOL> '<STR_LIT:host>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : [ <NUM_LIT:2> ] , <EOL> '<STR_LIT>' : { <NUM_LIT:3> : '<STR_LIT>' } , <EOL> } <EOL> add_devices = mock . MagicMock ( ) <EOL> hass = mock . MagicMock ( ) <EOL> self . assertTrue ( nx584 . setup_platform ( hass , config , add_devices ) ) <EOL> mock_nx . assert_has_calls ( [ <EOL> mock . call ( self . fake_zones [ <NUM_LIT:0> ] , '<STR_LIT>' ) , <EOL> mock . call ( self . fake_zones [ <NUM_LIT:2> ] , '<STR_LIT>' ) , <EOL> ] ) <EOL> self . assertTrue ( add_devices . called ) <EOL> nx584_client . Client . assert_called_once_with ( '<STR_LIT>' ) <EOL> self . assertTrue ( mock_watcher . called ) <EOL> def _test_assert_graceful_fail ( self , config ) : <EOL> """<STR_LIT>""" <EOL> hass = add_devices = mock . MagicMock ( ) <EOL> self . assertFalse ( nx584 . setup_platform ( hass , config , <EOL> add_devices ) ) <EOL> self . assertFalse ( add_devices . called ) <EOL> def test_setup_bad_config ( self ) : <EOL> """<STR_LIT>""" <EOL> bad_configs = [ <EOL> { '<STR_LIT>' : [ '<STR_LIT:a>' ] } , <EOL> { '<STR_LIT>' : { '<STR_LIT:a>' : '<STR_LIT:b>' } } , <EOL> { '<STR_LIT>' : { <NUM_LIT:1> : '<STR_LIT>' } } , <EOL> { '<STR_LIT>' : { '<STR_LIT>' : '<STR_LIT>' } } , <EOL> ] <EOL> for config in bad_configs : <EOL> self . _test_assert_graceful_fail ( config ) <EOL> def test_setup_connect_failed ( self ) : <EOL> """<STR_LIT>""" <EOL> nx584_client . Client . return_value . list_zones . side_effect = requests . exceptions . ConnectionError <EOL> self . _test_assert_graceful_fail ( { } ) <EOL> def test_setup_version_too_old ( self ) : <EOL> """<STR_LIT>""" <EOL> nx584_client . Client . return_value . get_version . return_value = '<STR_LIT:1.0>' <EOL> self . _test_assert_graceful_fail ( { } ) <EOL> def test_setup_no_zones ( self ) : <EOL> """<STR_LIT>""" <EOL> nx584_client . Client . return_value . list_zones . return_value = [ ] <EOL> hass = add_devices = mock . MagicMock ( ) <EOL> self . assertTrue ( nx584 . setup_platform ( hass , { } , <EOL> add_devices ) ) <EOL> self . assertFalse ( add_devices . called ) <EOL> class TestNX584ZoneSensor ( unittest . TestCase ) : <EOL> """<STR_LIT>""" <EOL> def test_sensor_normal ( self ) : <EOL> """<STR_LIT>""" <EOL> zone = { '<STR_LIT>' : <NUM_LIT:1> , '<STR_LIT:name>' : '<STR_LIT:foo>' , '<STR_LIT:state>' : True } <EOL> sensor = nx584 . NX584ZoneSensor ( zone , '<STR_LIT>' ) <EOL> self . assertEqual ( '<STR_LIT:foo>' , sensor . name ) <EOL> self . assertFalse ( sensor . should_poll ) <EOL> self . assertTrue ( sensor . is_on ) <EOL> zone [ '<STR_LIT:state>' ] = False <EOL> self . assertFalse ( sensor . is_on ) <EOL> class TestNX584Watcher ( unittest . TestCase ) : <EOL> """<STR_LIT>""" <EOL> @ mock . patch . object ( nx584 . NX584ZoneSensor , '<STR_LIT>' ) <EOL> def test_process_zone_event ( self , mock_update ) : <EOL> """<STR_LIT>""" <EOL> zone1 = { '<STR_LIT>' : <NUM_LIT:1> , '<STR_LIT:name>' : '<STR_LIT:foo>' , '<STR_LIT:state>' : True } <EOL> zone2 = { '<STR_LIT>' : <NUM_LIT:2> , '<STR_LIT:name>' : '<STR_LIT:bar>' , '<STR_LIT:state>' : True } <EOL> zones = { <EOL> <NUM_LIT:1> : nx584 . NX584ZoneSensor ( zone1 , '<STR_LIT>' ) , <EOL> <NUM_LIT:2> : nx584 . NX584ZoneSensor ( zone2 , '<STR_LIT>' ) , <EOL> } <EOL> watcher = nx584 . NX584Watcher ( None , zones ) <EOL> watcher . _process_zone_event ( { '<STR_LIT>' : <NUM_LIT:1> , '<STR_LIT>' : False } ) <EOL> self . assertFalse ( zone1 [ '<STR_LIT:state>' ] ) <EOL> self . assertEqual ( <NUM_LIT:1> , mock_update . call_count ) <EOL> @ mock . patch . object ( nx584 . NX584ZoneSensor , '<STR_LIT>' ) <EOL> def test_process_zone_event_missing_zone ( self , mock_update ) : <EOL> """<STR_LIT>""" <EOL> watcher = nx584 . NX584Watcher ( None , { } ) <EOL> watcher . _process_zone_event ( { '<STR_LIT>' : <NUM_LIT:1> , '<STR_LIT>' : False } ) <EOL> self . assertFalse ( mock_update . called ) <EOL> def test_run_with_zone_events ( self ) : <EOL> """<STR_LIT>""" <EOL> empty_me = [ <NUM_LIT:1> , <NUM_LIT:2> ] <EOL> def fake_get_events ( ) : <EOL> """<STR_LIT>""" <EOL> if empty_me : <EOL> empty_me . pop ( ) <EOL> else : <EOL> return fake_events <EOL> client = mock . MagicMock ( ) <EOL> fake_events = [ <EOL> { '<STR_LIT>' : <NUM_LIT:1> , '<STR_LIT>' : True , '<STR_LIT:type>' : '<STR_LIT>' } , <EOL> { '<STR_LIT>' : <NUM_LIT:2> , '<STR_LIT:foo>' : False } , <EOL> ] <EOL> client . get_events . side_effect = fake_get_events <EOL> watcher = nx584 . NX584Watcher ( client , { } ) <EOL> @ mock . patch . object ( watcher , '<STR_LIT>' ) <EOL> def run ( fake_process ) : <EOL> fake_process . side_effect = StopMe <EOL> self . assertRaises ( StopMe , watcher . _run ) <EOL> fake_process . assert_called_once_with ( fake_events [ <NUM_LIT:0> ] ) <EOL> run ( ) <EOL> self . assertEqual ( <NUM_LIT:3> , client . get_events . call_count ) <EOL> @ mock . patch ( '<STR_LIT>' ) <EOL> def test_run_retries_failures ( self , mock_sleep ) : <EOL> """<STR_LIT>""" <EOL> empty_me = [ <NUM_LIT:1> , <NUM_LIT:2> ] <EOL> def fake_run ( ) : <EOL> if empty_me : <EOL> empty_me . pop ( ) <EOL> raise requests . exceptions . ConnectionError ( ) <EOL> else : <EOL> raise StopMe ( ) <EOL> watcher = nx584 . NX584Watcher ( None , { } ) <EOL> with mock . patch . object ( watcher , '<STR_LIT>' ) as mock_inner : <EOL> mock_inner . side_effect = fake_run <EOL> self . assertRaises ( StopMe , watcher . run ) <EOL> self . assertEqual ( <NUM_LIT:3> , mock_inner . call_count ) <EOL> mock_sleep . assert_has_calls ( [ mock . call ( <NUM_LIT:10> ) , mock . call ( <NUM_LIT:10> ) ] ) </s>
<s> """<STR_LIT>""" <EOL> import os <EOL> import tempfile <EOL> import unittest <EOL> import homeassistant . components . notify as notify <EOL> from tests . common import get_test_home_assistant <EOL> from unittest . mock import patch <EOL> class TestCommandLine ( unittest . TestCase ) : <EOL> """<STR_LIT>""" <EOL> def setUp ( self ) : <EOL> """<STR_LIT>""" <EOL> self . hass = get_test_home_assistant ( ) <EOL> def tearDown ( self ) : <EOL> """<STR_LIT>""" <EOL> self . hass . stop ( ) <EOL> def test_bad_config ( self ) : <EOL> """<STR_LIT>""" <EOL> self . assertFalse ( notify . setup ( self . hass , { <EOL> '<STR_LIT>' : { <EOL> '<STR_LIT:name>' : '<STR_LIT:test>' , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> } <EOL> } ) ) <EOL> self . assertFalse ( notify . setup ( self . hass , { <EOL> '<STR_LIT>' : { <EOL> '<STR_LIT:name>' : '<STR_LIT:test>' , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> } <EOL> } ) ) <EOL> def test_command_line_output ( self ) : <EOL> """<STR_LIT>""" <EOL> with tempfile . TemporaryDirectory ( ) as tempdirname : <EOL> filename = os . path . join ( tempdirname , '<STR_LIT>' ) <EOL> message = '<STR_LIT>' <EOL> self . assertTrue ( notify . setup ( self . hass , { <EOL> '<STR_LIT>' : { <EOL> '<STR_LIT:name>' : '<STR_LIT:test>' , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT>' . format ( filename ) <EOL> } <EOL> } ) ) <EOL> self . hass . services . call ( '<STR_LIT>' , '<STR_LIT:test>' , { '<STR_LIT:message>' : message } , <EOL> blocking = True ) <EOL> result = open ( filename ) . read ( ) <EOL> self . assertEqual ( result , "<STR_LIT>" . format ( message ) ) <EOL> @ patch ( '<STR_LIT>' ) <EOL> def test_error_for_none_zero_exit_code ( self , mock_error ) : <EOL> """<STR_LIT>""" <EOL> self . assertTrue ( notify . setup ( self . hass , { <EOL> '<STR_LIT>' : { <EOL> '<STR_LIT:name>' : '<STR_LIT:test>' , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT>' <EOL> } <EOL> } ) ) <EOL> self . hass . services . call ( '<STR_LIT>' , '<STR_LIT:test>' , { '<STR_LIT:message>' : '<STR_LIT:error>' } , <EOL> blocking = True ) <EOL> self . assertEqual ( <NUM_LIT:1> , mock_error . call_count ) </s>
<s> """<STR_LIT>""" <EOL> import socket <EOL> import unittest <EOL> from unittest import mock <EOL> import homeassistant . core as ha <EOL> import homeassistant . components . graphite as graphite <EOL> from homeassistant . const import ( <EOL> EVENT_STATE_CHANGED , <EOL> EVENT_HOMEASSISTANT_START , EVENT_HOMEASSISTANT_STOP , <EOL> STATE_ON , STATE_OFF ) <EOL> from tests . common import get_test_home_assistant <EOL> class TestGraphite ( unittest . TestCase ) : <EOL> """<STR_LIT>""" <EOL> def setup_method ( self , method ) : <EOL> """<STR_LIT>""" <EOL> self . hass = get_test_home_assistant ( ) <EOL> self . hass . config . latitude = <NUM_LIT> <EOL> self . hass . config . longitude = <NUM_LIT> <EOL> self . gf = graphite . GraphiteFeeder ( self . hass , '<STR_LIT:foo>' , <NUM_LIT> , '<STR_LIT>' ) <EOL> def teardown_method ( self , method ) : <EOL> """<STR_LIT>""" <EOL> self . hass . stop ( ) <EOL> @ mock . patch ( '<STR_LIT>' ) <EOL> def test_minimal_config ( self , mock_gf ) : <EOL> """<STR_LIT>""" <EOL> self . assertTrue ( graphite . setup ( self . hass , { } ) ) <EOL> mock_gf . assert_called_once_with ( self . hass , '<STR_LIT:localhost>' , <NUM_LIT> , '<STR_LIT>' ) <EOL> @ mock . patch ( '<STR_LIT>' ) <EOL> def test_full_config ( self , mock_gf ) : <EOL> """<STR_LIT>""" <EOL> config = { <EOL> '<STR_LIT>' : { <EOL> '<STR_LIT:host>' : '<STR_LIT:foo>' , <EOL> '<STR_LIT:port>' : <NUM_LIT> , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> } <EOL> } <EOL> self . assertTrue ( graphite . setup ( self . hass , config ) ) <EOL> mock_gf . assert_called_once_with ( self . hass , '<STR_LIT:foo>' , <NUM_LIT> , '<STR_LIT>' ) <EOL> @ mock . patch ( '<STR_LIT>' ) <EOL> def test_config_bad_port ( self , mock_gf ) : <EOL> """<STR_LIT>""" <EOL> config = { <EOL> '<STR_LIT>' : { <EOL> '<STR_LIT:host>' : '<STR_LIT:foo>' , <EOL> '<STR_LIT:port>' : '<STR_LIT>' , <EOL> } <EOL> } <EOL> self . assertFalse ( graphite . setup ( self . hass , config ) ) <EOL> self . assertFalse ( mock_gf . called ) <EOL> def test_subscribe ( self ) : <EOL> """<STR_LIT>""" <EOL> fake_hass = mock . MagicMock ( ) <EOL> gf = graphite . GraphiteFeeder ( fake_hass , '<STR_LIT:foo>' , <NUM_LIT> , '<STR_LIT>' ) <EOL> fake_hass . bus . listen_once . has_calls ( [ <EOL> mock . call ( EVENT_HOMEASSISTANT_START , gf . start_listen ) , <EOL> mock . call ( EVENT_HOMEASSISTANT_STOP , gf . shutdown ) , <EOL> ] ) <EOL> fake_hass . bus . listen . assert_called_once_with ( <EOL> EVENT_STATE_CHANGED , gf . event_listener ) <EOL> def test_start ( self ) : <EOL> """<STR_LIT>""" <EOL> with mock . patch . object ( self . gf , '<STR_LIT:start>' ) as mock_start : <EOL> self . gf . start_listen ( '<STR_LIT>' ) <EOL> mock_start . assert_called_once_with ( ) <EOL> def test_shutdown ( self ) : <EOL> """<STR_LIT>""" <EOL> with mock . patch . object ( self . gf , '<STR_LIT>' ) as mock_queue : <EOL> self . gf . shutdown ( '<STR_LIT>' ) <EOL> mock_queue . put . assert_called_once_with ( self . gf . _quit_object ) <EOL> def test_event_listener ( self ) : <EOL> """<STR_LIT>""" <EOL> with mock . patch . object ( self . gf , '<STR_LIT>' ) as mock_queue : <EOL> self . gf . event_listener ( '<STR_LIT:foo>' ) <EOL> mock_queue . put . assert_called_once_with ( '<STR_LIT:foo>' ) <EOL> @ mock . patch ( '<STR_LIT>' ) <EOL> def test_report_attributes ( self , mock_time ) : <EOL> """<STR_LIT>""" <EOL> mock_time . return_value = <NUM_LIT> <EOL> attrs = { '<STR_LIT:foo>' : <NUM_LIT:1> , <EOL> '<STR_LIT:bar>' : <NUM_LIT> , <EOL> '<STR_LIT>' : True , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> } <EOL> expected = [ <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> ] <EOL> state = mock . MagicMock ( state = <NUM_LIT:0> , attributes = attrs ) <EOL> with mock . patch . object ( self . gf , '<STR_LIT>' ) as mock_send : <EOL> self . gf . _report_attributes ( '<STR_LIT>' , state ) <EOL> actual = mock_send . call_args_list [ <NUM_LIT:0> ] [ <NUM_LIT:0> ] [ <NUM_LIT:0> ] . split ( '<STR_LIT:\n>' ) <EOL> self . assertEqual ( sorted ( expected ) , sorted ( actual ) ) <EOL> @ mock . patch ( '<STR_LIT>' ) <EOL> def test_report_with_string_state ( self , mock_time ) : <EOL> """<STR_LIT>""" <EOL> mock_time . return_value = <NUM_LIT> <EOL> expected = [ <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> ] <EOL> state = mock . MagicMock ( state = '<STR_LIT>' , attributes = { '<STR_LIT:foo>' : <NUM_LIT:1.0> } ) <EOL> with mock . patch . object ( self . gf , '<STR_LIT>' ) as mock_send : <EOL> self . gf . _report_attributes ( '<STR_LIT>' , state ) <EOL> actual = mock_send . call_args_list [ <NUM_LIT:0> ] [ <NUM_LIT:0> ] [ <NUM_LIT:0> ] . split ( '<STR_LIT:\n>' ) <EOL> self . assertEqual ( sorted ( expected ) , sorted ( actual ) ) <EOL> @ mock . patch ( '<STR_LIT>' ) <EOL> def test_report_with_binary_state ( self , mock_time ) : <EOL> """<STR_LIT>""" <EOL> mock_time . return_value = <NUM_LIT> <EOL> state = ha . State ( '<STR_LIT>' , STATE_ON , { '<STR_LIT:foo>' : <NUM_LIT:1.0> } ) <EOL> with mock . patch . object ( self . gf , '<STR_LIT>' ) as mock_send : <EOL> self . gf . _report_attributes ( '<STR_LIT>' , state ) <EOL> expected = [ '<STR_LIT>' , <EOL> '<STR_LIT>' ] <EOL> actual = mock_send . call_args_list [ <NUM_LIT:0> ] [ <NUM_LIT:0> ] [ <NUM_LIT:0> ] . split ( '<STR_LIT:\n>' ) <EOL> self . assertEqual ( sorted ( expected ) , sorted ( actual ) ) <EOL> state . state = STATE_OFF <EOL> with mock . patch . object ( self . gf , '<STR_LIT>' ) as mock_send : <EOL> self . gf . _report_attributes ( '<STR_LIT>' , state ) <EOL> expected = [ '<STR_LIT>' , <EOL> '<STR_LIT>' ] <EOL> actual = mock_send . call_args_list [ <NUM_LIT:0> ] [ <NUM_LIT:0> ] [ <NUM_LIT:0> ] . split ( '<STR_LIT:\n>' ) <EOL> self . assertEqual ( sorted ( expected ) , sorted ( actual ) ) <EOL> @ mock . patch ( '<STR_LIT>' ) <EOL> def test_send_to_graphite_errors ( self , mock_time ) : <EOL> """<STR_LIT>""" <EOL> mock_time . return_value = <NUM_LIT> <EOL> state = ha . State ( '<STR_LIT>' , STATE_ON , { '<STR_LIT:foo>' : <NUM_LIT:1.0> } ) <EOL> with mock . patch . object ( self . gf , '<STR_LIT>' ) as mock_send : <EOL> mock_send . side_effect = socket . error <EOL> self . gf . _report_attributes ( '<STR_LIT>' , state ) <EOL> mock_send . side_effect = socket . gaierror <EOL> self . gf . _report_attributes ( '<STR_LIT>' , state ) <EOL> @ mock . patch ( '<STR_LIT>' ) <EOL> def test_send_to_graphite ( self , mock_socket ) : <EOL> """<STR_LIT>""" <EOL> self . gf . _send_to_graphite ( '<STR_LIT:foo>' ) <EOL> mock_socket . assert_called_once_with ( socket . AF_INET , <EOL> socket . SOCK_STREAM ) <EOL> sock = mock_socket . return_value <EOL> sock . connect . assert_called_once_with ( ( '<STR_LIT:foo>' , <NUM_LIT> ) ) <EOL> sock . sendall . assert_called_once_with ( '<STR_LIT:foo>' . encode ( '<STR_LIT:ascii>' ) ) <EOL> sock . send . assert_called_once_with ( '<STR_LIT:\n>' . encode ( '<STR_LIT:ascii>' ) ) <EOL> sock . close . assert_called_once_with ( ) <EOL> def test_run_stops ( self ) : <EOL> """<STR_LIT>""" <EOL> with mock . patch . object ( self . gf , '<STR_LIT>' ) as mock_queue : <EOL> mock_queue . get . return_value = self . gf . _quit_object <EOL> self . assertEqual ( None , self . gf . run ( ) ) <EOL> mock_queue . get . assert_called_once_with ( ) <EOL> mock_queue . task_done . assert_called_once_with ( ) <EOL> def test_run ( self ) : <EOL> """<STR_LIT>""" <EOL> runs = [ ] <EOL> event = mock . MagicMock ( event_type = EVENT_STATE_CHANGED , <EOL> data = { '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : mock . MagicMock ( ) } ) <EOL> def fake_get ( ) : <EOL> if len ( runs ) >= <NUM_LIT:2> : <EOL> return self . gf . _quit_object <EOL> elif runs : <EOL> runs . append ( <NUM_LIT:1> ) <EOL> return mock . MagicMock ( event_type = '<STR_LIT>' , <EOL> data = { '<STR_LIT>' : None } ) <EOL> else : <EOL> runs . append ( <NUM_LIT:1> ) <EOL> return event <EOL> with mock . patch . object ( self . gf , '<STR_LIT>' ) as mock_queue : <EOL> with mock . patch . object ( self . gf , '<STR_LIT>' ) as mock_r : <EOL> mock_queue . get . side_effect = fake_get <EOL> self . gf . run ( ) <EOL> self . assertEqual ( <NUM_LIT:3> , mock_queue . task_done . call_count ) <EOL> mock_r . assert_called_once_with ( <EOL> '<STR_LIT>' , <EOL> event . data [ '<STR_LIT>' ] ) </s>
<s> """<STR_LIT>""" <EOL> def get_scanner ( hass , config ) : <EOL> """<STR_LIT>""" <EOL> return SCANNER <EOL> class MockScanner ( object ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self ) : <EOL> """<STR_LIT>""" <EOL> self . devices_home = [ ] <EOL> def come_home ( self , device ) : <EOL> """<STR_LIT>""" <EOL> self . devices_home . append ( device ) <EOL> def leave_home ( self , device ) : <EOL> """<STR_LIT>""" <EOL> self . devices_home . remove ( device ) <EOL> def reset ( self ) : <EOL> """<STR_LIT>""" <EOL> self . devices_home = [ ] <EOL> def scan_devices ( self ) : <EOL> """<STR_LIT>""" <EOL> return list ( self . devices_home ) <EOL> def get_device_name ( self , device ) : <EOL> """<STR_LIT>""" <EOL> return None if device == '<STR_LIT>' else device . lower ( ) <EOL> SCANNER = MockScanner ( ) </s>
<s> import json <EOL> import sys <EOL> import demjson <EOL> try : <EOL> from urllib . request import Request , urlopen <EOL> except ImportError : <EOL> from urllib2 import Request , urlopen <EOL> __author__ = '<STR_LIT>' <EOL> googleFinanceKeyToFullName = { <EOL> u'<STR_LIT:id>' : u'<STR_LIT>' , <EOL> u'<STR_LIT:t>' : u'<STR_LIT>' , <EOL> u'<STR_LIT:e>' : u'<STR_LIT>' , <EOL> u'<STR_LIT:l>' : u'<STR_LIT>' , <EOL> u'<STR_LIT>' : u'<STR_LIT>' , <EOL> u'<STR_LIT>' : u'<STR_LIT>' , <EOL> u'<STR_LIT>' : u'<STR_LIT>' , <EOL> u'<STR_LIT>' : u'<STR_LIT>' , <EOL> u'<STR_LIT>' : u'<STR_LIT>' , <EOL> u'<STR_LIT>' : u'<STR_LIT>' , <EOL> u'<STR_LIT:s>' : u'<STR_LIT>' , <EOL> u'<STR_LIT:c>' : u'<STR_LIT>' , <EOL> u'<STR_LIT:c>' : u'<STR_LIT>' , <EOL> u'<STR_LIT>' : u'<STR_LIT>' , <EOL> u'<STR_LIT>' : u'<STR_LIT>' , <EOL> u'<STR_LIT>' : u'<STR_LIT>' , <EOL> u'<STR_LIT>' : u'<STR_LIT>' , <EOL> u'<STR_LIT>' : u'<STR_LIT>' , <EOL> u'<STR_LIT>' : u'<STR_LIT>' <EOL> } <EOL> def buildUrl ( symbols ) : <EOL> symbol_list = '<STR_LIT:U+002C>' . join ( [ symbol for symbol in symbols ] ) <EOL> return '<STR_LIT>' + symbol_list <EOL> def buildNewsUrl ( symbol , qs = '<STR_LIT>' ) : <EOL> return '<STR_LIT>' + symbol + qs <EOL> def request ( symbols ) : <EOL> url = buildUrl ( symbols ) <EOL> req = Request ( url ) <EOL> resp = urlopen ( req ) <EOL> content = resp . read ( ) . decode ( '<STR_LIT:ascii>' , '<STR_LIT:ignore>' ) . strip ( ) <EOL> content = content [ <NUM_LIT:3> : ] <EOL> return content <EOL> def requestNews ( symbol ) : <EOL> url = buildNewsUrl ( symbol ) <EOL> print "<STR_LIT>" , url <EOL> req = Request ( url ) <EOL> resp = urlopen ( req ) <EOL> content = resp . read ( ) <EOL> content_json = demjson . decode ( content ) <EOL> article_json = [ ] <EOL> news_json = content_json [ '<STR_LIT>' ] <EOL> for cluster in news_json : <EOL> for article in cluster : <EOL> if article == '<STR_LIT:a>' : <EOL> article_json . extend ( cluster [ article ] ) <EOL> return article_json <EOL> def replaceKeys ( quotes ) : <EOL> global googleFinanceKeyToFullName <EOL> quotesWithReadableKey = [ ] <EOL> for q in quotes : <EOL> qReadableKey = { } <EOL> for k in googleFinanceKeyToFullName : <EOL> if k in q : <EOL> qReadableKey [ googleFinanceKeyToFullName [ k ] ] = q [ k ] <EOL> quotesWithReadableKey . append ( qReadableKey ) <EOL> return quotesWithReadableKey <EOL> def getQuotes ( symbols ) : <EOL> '''<STR_LIT>''' <EOL> if type ( symbols ) == type ( '<STR_LIT:str>' ) : <EOL> symbols = [ symbols ] <EOL> content = json . loads ( request ( symbols ) ) <EOL> return replaceKeys ( content ) ; <EOL> def getNews ( symbol ) : <EOL> return requestNews ( symbol ) ; <EOL> if __name__ == '<STR_LIT:__main__>' : <EOL> try : <EOL> symbols = sys . argv [ <NUM_LIT:1> ] <EOL> except : <EOL> symbols = "<STR_LIT>" <EOL> symbols = symbols . split ( '<STR_LIT:U+002C>' ) <EOL> print ( json . dumps ( getNews ( "<STR_LIT>" ) , indent = <NUM_LIT:2> ) ) <EOL> print ( json . dumps ( getQuotes ( symbols ) , indent = <NUM_LIT:2> ) ) </s>
<s> import os <EOL> DEBUG = True <EOL> TEMPLATE_DEBUG = DEBUG <EOL> ADMINS = ( <EOL> ) <EOL> MANAGERS = ADMINS <EOL> DATABASES = { <EOL> '<STR_LIT:default>' : { <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> } <EOL> } <EOL> TIME_ZONE = '<STR_LIT>' <EOL> LANGUAGE_CODE = '<STR_LIT>' <EOL> SITE_ID = <NUM_LIT:1> <EOL> USE_I18N = True <EOL> USE_L10N = True <EOL> USE_TZ = True <EOL> MEDIA_ROOT = '<STR_LIT>' <EOL> MEDIA_URL = '<STR_LIT>' <EOL> STATIC_ROOT = '<STR_LIT>' <EOL> STATIC_URL = '<STR_LIT>' <EOL> STATICFILES_DIRS = ( <EOL> ) <EOL> STATICFILES_FINDERS = ( <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> ) <EOL> SECRET_KEY = '<STR_LIT>' <EOL> TEMPLATE_LOADERS = ( <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> ) <EOL> MIDDLEWARE_CLASSES = ( <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> ) <EOL> ROOT_URLCONF = '<STR_LIT>' <EOL> WSGI_APPLICATION = '<STR_LIT>' <EOL> TEMPLATE_DIRS = ( <EOL> ) <EOL> INSTALLED_APPS = ( <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT:data>' <EOL> ) <EOL> LOGGING = { <EOL> '<STR_LIT:version>' : <NUM_LIT:1> , <EOL> '<STR_LIT>' : False , <EOL> '<STR_LIT>' : { <EOL> '<STR_LIT>' : { <EOL> '<STR_LIT>' : '<STR_LIT>' <EOL> } <EOL> } , <EOL> '<STR_LIT>' : { <EOL> '<STR_LIT>' : { <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : [ '<STR_LIT>' ] , <EOL> '<STR_LIT:class>' : '<STR_LIT>' <EOL> } <EOL> } , <EOL> '<STR_LIT>' : { <EOL> '<STR_LIT>' : { <EOL> '<STR_LIT>' : [ '<STR_LIT>' ] , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : True , <EOL> } , <EOL> } <EOL> } <EOL> FRONTEND_KEY = os . environ . get ( '<STR_LIT>' , None ) <EOL> FRONTEND_SECRET = os . environ . get ( '<STR_LIT>' , None ) <EOL> assert FRONTEND_KEY and FRONTEND_SECRET <EOL> CONSUMERS = { <EOL> FRONTEND_KEY : { <EOL> '<STR_LIT:name>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : True , <EOL> '<STR_LIT>' : FRONTEND_SECRET <EOL> } <EOL> } </s>
<s> from __future__ import absolute_import <EOL> from selenium . common . exceptions import WebDriverException , NoSuchElementException <EOL> from selenium . webdriver . common . keys import Keys <EOL> from webdriverwrapper . wrapper import _WebElementWrapper <EOL> from webdriverwrapper . exceptions import _create_exception_msg <EOL> from webdriverwrapper . utils import force_text <EOL> __all__ = ( '<STR_LIT>' , ) <EOL> class Form ( _WebElementWrapper ) : <EOL> def fill_out_and_submit ( self , data , prefix = '<STR_LIT>' , skip_reset = False ) : <EOL> """<STR_LIT>""" <EOL> self . fill_out ( data , prefix , skip_reset ) <EOL> self . submit ( ) <EOL> def fill_out ( self , data , prefix = '<STR_LIT>' , skip_reset = False ) : <EOL> """<STR_LIT>""" <EOL> for elm_name , value in data . items ( ) : <EOL> FormElement ( self , prefix + elm_name ) . fill_out ( value , skip_reset ) <EOL> def submit ( self ) : <EOL> """<STR_LIT>""" <EOL> elm_name = '<STR_LIT>' % self . get_attribute ( '<STR_LIT:id>' ) <EOL> try : <EOL> self . click ( elm_name ) <EOL> except NoSuchElementException : <EOL> super ( Form , self ) . submit ( ) <EOL> def reset ( self ) : <EOL> """<STR_LIT>""" <EOL> elm_name = '<STR_LIT>' % self . get_attribute ( '<STR_LIT:id>' ) <EOL> self . click ( elm_name ) <EOL> class FormElement ( object ) : <EOL> def __init__ ( self , form_elm , elm_name ) : <EOL> self . form_elm = form_elm <EOL> self . elm_name = elm_name <EOL> def convert_value ( self , value ) : <EOL> if not isinstance ( value , ( list , tuple ) ) : <EOL> return self . _convert_value_to_string ( value ) <EOL> values = [ ] <EOL> for item in value : <EOL> values . append ( self . _convert_value_to_string ( item ) ) <EOL> return values <EOL> def _convert_value_to_string ( self , value ) : <EOL> if isinstance ( value , bool ) : <EOL> value = int ( value ) <EOL> elif value is None : <EOL> value = '<STR_LIT>' <EOL> return force_text ( value ) <EOL> def fill_out ( self , value , skip_reset ) : <EOL> tag_name , elm_type = self . analyze_element ( ) <EOL> method_name = ( '<STR_LIT>' % ( tag_name , elm_type ) ) . replace ( '<STR_LIT:->' , '<STR_LIT>' ) <EOL> getattr ( self , method_name , self . fill_common ) ( value , skip_reset ) <EOL> def analyze_element ( self ) : <EOL> elms = self . form_elm . get_elms ( name = self . elm_name ) <EOL> for elm in elms : <EOL> elm_type = elm . get_attribute ( '<STR_LIT:type>' ) <EOL> if elm_type == '<STR_LIT>' : <EOL> continue <EOL> return elm . tag_name , elm_type <EOL> raise NoSuchElementException ( _create_exception_msg ( name = self . elm_name ) ) <EOL> def fill_input_checkbox ( self , value , skip_reset = False ) : <EOL> if isinstance ( value , ( list , tuple ) ) : <EOL> self . fill_input_checkbox_multiple ( value ) <EOL> self . fill_input_checkbox_single ( value ) <EOL> def fill_input_checkbox_single ( self , value , skip_reset = False ) : <EOL> elm = self . form_elm . get_elm ( xpath = '<STR_LIT>' % self . elm_name ) <EOL> if bool ( value ) != elm . is_selected ( ) : <EOL> self . _click_on_elm_or_his_ancestor ( elm ) <EOL> def fill_input_checkbox_multiple ( self , value , skip_reset = False ) : <EOL> for item in value : <EOL> elm = self . form_elm . get_elm ( xpath = '<STR_LIT>' % ( <EOL> self . elm_name , <EOL> self . convert_value ( item ) , <EOL> ) ) <EOL> self . _click_on_elm_or_his_ancestor ( elm ) <EOL> def fill_input_radio ( self , value , skip_reset = False ) : <EOL> elm = self . form_elm . get_elm ( xpath = '<STR_LIT>' % ( <EOL> self . elm_name , <EOL> self . convert_value ( value ) , <EOL> ) ) <EOL> self . _click_on_elm_or_his_ancestor ( elm ) <EOL> def fill_input_file ( self , value , skip_reset = False ) : <EOL> elm = self . form_elm . get_elm ( name = self . elm_name ) <EOL> elm . send_keys ( self . convert_value ( value ) ) <EOL> def fill_select_selectone ( self , value , skip_reset = False ) : <EOL> select = self . form_elm . get_elm ( name = self . elm_name ) <EOL> select . select_by_value ( self . convert_value ( value ) ) <EOL> def fill_select_selectmultiple ( self , value , skip_reset = False ) : <EOL> if not isinstance ( value , ( list , tuple ) ) : <EOL> value = [ value ] <EOL> select = self . form_elm . get_elm ( name = self . elm_name ) <EOL> if not skip_reset : <EOL> select . deselect_all ( ) <EOL> for item in self . convert_value ( value ) : <EOL> select . select_by_value ( item ) <EOL> def fill_common ( self , value , skip_reset = False ) : <EOL> elm = self . form_elm . get_elm ( name = self . elm_name ) <EOL> if not skip_reset : <EOL> elm . clear ( ) <EOL> elm . send_keys ( self . convert_value ( value ) ) <EOL> elm . send_keys ( Keys . TAB ) <EOL> @ classmethod <EOL> def _click_on_elm_or_his_ancestor ( self , elm ) : <EOL> """<STR_LIT>""" <EOL> try : <EOL> elm . click ( ) <EOL> except WebDriverException : <EOL> elm . click ( xpath = '<STR_LIT>' ) </s>
<s> import os <EOL> import sys <EOL> reload ( sys ) <EOL> sys . setdefaultencoding ( '<STR_LIT:utf-8>' ) <EOL> import sqlalchemy as sql <EOL> from item import Item <EOL> class Zotero : <EOL> def __init__ ( self , zotero_dir ) : <EOL> self . zotero_dir = zotero_dir <EOL> self . zotero_db_path = os . path . abspath ( os . path . join ( zotero_dir , '<STR_LIT>' ) ) <EOL> self . zotero_storage_path = os . path . join ( zotero_dir , '<STR_LIT>' ) <EOL> if not os . path . exists ( self . zotero_db_path ) : <EOL> raise Exception ( '<STR_LIT>' % self . zotero_db_path ) <EOL> self . db = sql . create_engine ( '<STR_LIT>' + self . zotero_db_path ) <EOL> self . db . echo = False <EOL> self . metadata = sql . MetaData ( self . db ) <EOL> self . items = sql . Table ( '<STR_LIT>' , self . metadata , autoload = True ) <EOL> self . fields = sql . Table ( '<STR_LIT>' , self . metadata , autoload = True ) <EOL> self . item_data = sql . Table ( '<STR_LIT>' , self . metadata , autoload = True ) <EOL> self . item_data_values = sql . Table ( '<STR_LIT>' , self . metadata , autoload = True ) <EOL> self . item_attachments = sql . Table ( '<STR_LIT>' , self . metadata , autoload = True ) <EOL> self . collections = sql . Table ( '<STR_LIT>' , self . metadata , autoload = True ) <EOL> self . collection_items = sql . Table ( '<STR_LIT>' , self . metadata , autoload = True ) <EOL> self . item_creators = sql . Table ( '<STR_LIT>' , self . metadata , autoload = True ) <EOL> self . creators = sql . Table ( '<STR_LIT>' , self . metadata , autoload = True ) <EOL> self . creator_data = sql . Table ( '<STR_LIT>' , self . metadata , autoload = True ) <EOL> self . item_notes = sql . Table ( '<STR_LIT>' , self . metadata , autoload = True ) <EOL> self . get_items ( ) <EOL> def get_items ( self ) : <EOL> query = sql . select ( [ self . items . c . key , self . fields . c . fieldName , self . item_data_values . c . value ] , <EOL> ( self . items . c . itemID == self . item_data . c . itemID ) & <EOL> ( self . item_data . c . fieldID == self . fields . c . fieldID ) & <EOL> ( self . item_data . c . valueID == self . item_data_values . c . valueID ) <EOL> ) <EOL> result = query . execute ( ) <EOL> items = { } <EOL> for key , field_name , value in result : <EOL> if not key in items : items [ key ] = { '<STR_LIT:key>' : key } <EOL> if field_name == '<STR_LIT:date>' : <EOL> items [ key ] [ '<STR_LIT>' ] = value [ : <NUM_LIT:4> ] <EOL> else : items [ key ] [ field_name ] = value <EOL> query = sql . select ( [ self . items . c . key , self . creator_data . c . lastName , self . creator_data . c . firstName ] , <EOL> ( self . items . c . itemID == self . item_creators . c . itemID ) & <EOL> ( self . creators . c . creatorID == self . item_creators . c . creatorID ) & <EOL> ( self . creators . c . creatorDataID == self . creator_data . c . creatorDataID ) <EOL> ) <EOL> result = query . execute ( ) <EOL> for key , last , first in result : <EOL> if not key in items : items [ key ] = { '<STR_LIT:key>' : key } <EOL> if not '<STR_LIT>' in items [ key ] : items [ key ] [ '<STR_LIT>' ] = [ ] <EOL> items [ key ] [ '<STR_LIT>' ] . append ( ( last , first ) ) <EOL> query = sql . select ( [ self . items . c . key , self . item_attachments . c . path ] , <EOL> ( self . items . c . itemID == self . item_attachments . c . itemID ) & <EOL> ( self . item_attachments . c . mimeType == '<STR_LIT>' ) <EOL> ) <EOL> result = query . execute ( ) <EOL> for key , path in result : <EOL> if not key in items : items [ key ] = { '<STR_LIT:key>' : key } <EOL> if not '<STR_LIT>' in items [ key ] : items [ key ] [ '<STR_LIT>' ] = [ ] <EOL> items [ key ] [ '<STR_LIT>' ] . append ( path ) <EOL> query = sql . select ( [ self . items . c . key , self . item_notes . c . note ] , <EOL> ( self . items . c . itemID == self . item_notes . c . itemID ) <EOL> ) <EOL> result = query . execute ( ) <EOL> for key , note in result : <EOL> if not key in items : items [ key ] = { '<STR_LIT:key>' : key } <EOL> if not '<STR_LIT>' in items [ key ] : items [ key ] [ '<STR_LIT>' ] = [ ] <EOL> items [ key ] [ '<STR_LIT>' ] . append ( note ) <EOL> query = sql . select ( [ self . collections . c . collectionName , self . items . c . key ] , <EOL> ( self . collections . c . collectionID == self . collection_items . c . collectionID ) & <EOL> ( self . collection_items . c . itemID == self . items . c . itemID ) <EOL> ) <EOL> result = query . execute ( ) <EOL> collections = { } <EOL> for collection , key in result : <EOL> if not collection in collections : collections [ collection ] = set ( ) <EOL> collections [ collection ] . add ( key ) <EOL> if not key in items : items [ key ] = { '<STR_LIT:key>' : key } <EOL> if not '<STR_LIT>' in items [ key ] : items [ key ] [ '<STR_LIT>' ] = set ( ) <EOL> items [ key ] [ '<STR_LIT>' ] . add ( collection ) <EOL> self . all_items = { k : Item ( v ) for k , v in items . items ( ) } <EOL> def search ( self , best = False , kwargs ) : <EOL> matches = [ ( item , item . match ( kwargs ) ) for item in self . all_items . values ( ) ] <EOL> if not matches : return [ ] <EOL> if best : return [ sorted ( matches , key = lambda m : m [ <NUM_LIT:1> ] , reverse = True ) [ <NUM_LIT:0> ] [ <NUM_LIT:0> ] ] <EOL> return [ m [ <NUM_LIT:0> ] for m in filter ( lambda m : m [ <NUM_LIT:1> ] > <NUM_LIT:0> , matches ) ] <EOL> def read ( self , keys ) : <EOL> pass <EOL> def notes ( self , keys ) : <EOL> pass <EOL> def add_note ( self , key , note_txt ) : <EOL> pass <EOL> def bib ( self , keys ) : <EOL> pass <EOL> def help_msg ( ) : <EOL> print '''<STR_LIT>''' <EOL> def main ( ) : <EOL> if len ( sys . argv ) < <NUM_LIT:2> : <EOL> help_msg ( ) <EOL> return <EOL> command = sys . argv [ <NUM_LIT:1> ] . lower ( ) <EOL> if command == '<STR_LIT>' : <EOL> help_msg ( ) <EOL> return <EOL> elif command == '<STR_LIT:path>' : <EOL> arg = sys . argv [ <NUM_LIT:2> ] <EOL> from settings import write_zotero_dir <EOL> write_zotero_dir ( arg ) <EOL> sys . exit ( ) <EOL> from settings import get_zotero_dir <EOL> zotero_dir = get_zotero_dir ( ) <EOL> z = Zotero ( zotero_dir ) <EOL> if len ( sys . argv ) > <NUM_LIT:2> : args = sys . argv [ <NUM_LIT:2> : ] <EOL> else : <EOL> args = [ ] <EOL> for line in sys . __stdin__ : <EOL> args . append ( line . strip ( ) ) <EOL> if command in ( '<STR_LIT>' , '<STR_LIT>' ) : <EOL> search_args = { } <EOL> n = <NUM_LIT:0> <EOL> set_arg = '<STR_LIT>' <EOL> while n < len ( args ) : <EOL> if not set_arg in search_args : search_args [ set_arg ] = [ ] <EOL> arg = args [ n ] <EOL> if arg . startswith ( '<STR_LIT>' ) : set_arg = arg [ <NUM_LIT:2> : ] <EOL> else : search_args [ set_arg ] . append ( arg ) <EOL> n += <NUM_LIT:1> <EOL> result = z . search ( best = command == '<STR_LIT>' , ** search_args ) <EOL> for i in result : <EOL> print getattr ( i , '<STR_LIT:key>' ) <EOL> elif command in ( '<STR_LIT>' , '<STR_LIT>' ) : <EOL> for result in [ z . all_items [ key ] . bibliography ( ) for key in args ] : <EOL> print result <EOL> elif command in ( '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ) : <EOL> for result in [ z . all_items [ key ] . citation ( ) for key in args ] : <EOL> print result <EOL> elif command == '<STR_LIT>' : <EOL> for result in [ z . all_items [ key ] for key in args ] : <EOL> if hasattr ( result , '<STR_LIT>' ) : <EOL> for attachment in result . attachments : <EOL> print result . format_filename ( attachment , z . zotero_storage_path ) <EOL> elif command == '<STR_LIT>' : <EOL> for key in args : <EOL> z . all_items [ key ] . get_full_text ( z . zotero_storage_path ) <EOL> elif command == '<STR_LIT>' : <EOL> for result in [ z . all_items [ key ] for key in args ] : <EOL> if hasattr ( result , '<STR_LIT>' ) : <EOL> for note in result . notes : print note <EOL> elif command == '<STR_LIT>' : <EOL> for i in [ item . __dict__ for item in z . all_items . values ( ) ] : print i <EOL> else : <EOL> help_msg ( ) <EOL> return <EOL> if __name__ == '<STR_LIT:__main__>' : <EOL> main ( ) </s>
<s> from django import VERSION <EOL> if VERSION [ : <NUM_LIT:2> ] < ( <NUM_LIT:1> , <NUM_LIT:7> ) : <EOL> from pybb import signals <EOL> signals . setup ( ) <EOL> else : <EOL> default_app_config = '<STR_LIT>' </s>
<s> from __future__ import unicode_literals <EOL> from django . conf import settings <EOL> from django . core . urlresolvers import reverse <EOL> from django . core . validators import validate_email <EOL> from django . template . loader import render_to_string <EOL> from django . utils import translation <EOL> from django . contrib . sites . models import Site <EOL> from pybb import defaults , util , compat <EOL> if defaults . PYBB_USE_DJANGO_MAILER : <EOL> try : <EOL> from mailer import send_mass_mail <EOL> except ImportError : <EOL> from django . core . mail import send_mass_mail <EOL> else : <EOL> from django . core . mail import send_mass_mail <EOL> def notify_topic_subscribers ( post ) : <EOL> topic = post . topic <EOL> if post != topic . head : <EOL> old_lang = translation . get_language ( ) <EOL> delete_url = reverse ( '<STR_LIT>' , args = [ post . topic . id ] ) <EOL> current_site = Site . objects . get_current ( ) <EOL> from_email = settings . DEFAULT_FROM_EMAIL <EOL> subject = render_to_string ( '<STR_LIT>' , <EOL> { '<STR_LIT>' : current_site , <EOL> '<STR_LIT>' : post } ) <EOL> subject = '<STR_LIT>' . join ( subject . splitlines ( ) ) <EOL> mails = tuple ( ) <EOL> for user in topic . subscribers . exclude ( pk = post . user . pk ) : <EOL> try : <EOL> validate_email ( user . email ) <EOL> except : <EOL> continue <EOL> if user . email == '<STR_LIT>' % getattr ( user , compat . get_username_field ( ) ) : <EOL> continue <EOL> lang = util . get_pybb_profile ( user ) . language or settings . LANGUAGE_CODE <EOL> translation . activate ( lang ) <EOL> message = render_to_string ( '<STR_LIT>' , <EOL> { '<STR_LIT>' : current_site , <EOL> '<STR_LIT>' : post , <EOL> '<STR_LIT>' : delete_url , <EOL> '<STR_LIT:user>' : user } ) <EOL> mails += ( ( subject , message , from_email , [ user . email ] ) , ) <EOL> send_mass_mail ( mails , fail_silently = True ) <EOL> translation . activate ( old_lang ) </s>
<s> from django . contrib import admin <EOL> from models import Question , Topic <EOL> class TopicAdmin ( admin . ModelAdmin ) : <EOL> prepopulated_fields = { '<STR_LIT>' : ( '<STR_LIT:name>' , ) } <EOL> class QuestionAdmin ( admin . ModelAdmin ) : <EOL> list_display = [ '<STR_LIT:text>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , <EOL> '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT:status>' ] <EOL> list_editable = [ '<STR_LIT>' , '<STR_LIT:status>' ] <EOL> def save_model ( self , request , obj , form , change ) : <EOL> '''<STR_LIT>''' <EOL> if not change : <EOL> obj . created_by = request . user <EOL> obj . updated_by = request . user <EOL> return super ( QuestionAdmin , self ) . save_model ( request , obj , form , change ) <EOL> admin . site . register ( Question , QuestionAdmin ) <EOL> admin . site . register ( Topic , TopicAdmin ) </s>
<s> import logging <EOL> __custom_handlers = [ ] <EOL> def resetAndInitLogging ( opttree ) : <EOL> global __custom_handlers <EOL> logging . basicConfig </s>
<s> import random , unittest , collections <EOL> from treedict import TreeDict , getTree <EOL> import treedict <EOL> from copy import deepcopy , copy <EOL> from hashlib import md5 <EOL> import random <EOL> from common import * <EOL> class TestPruning ( unittest . TestCase ) : <EOL> def testpruning_01 ( self ) : <EOL> p = makeTDInstance ( '<STR_LIT>' ) <EOL> p . a . b . c = <NUM_LIT> <EOL> h1 = p . hash ( ) <EOL> self . assert_ ( '<STR_LIT>' in p ) <EOL> p . pop ( '<STR_LIT>' ) <EOL> self . assert_ ( '<STR_LIT>' not in p ) <EOL> h2 = p . hash ( ) <EOL> p . a . b . c = <NUM_LIT> <EOL> h3 = p . hash ( ) <EOL> self . assert_ ( h1 != h2 ) <EOL> self . assert_ ( h1 == h3 ) <EOL> def testpruning_02 ( self ) : <EOL> p = makeTDInstance ( '<STR_LIT>' ) <EOL> p . a . b . c = <NUM_LIT> <EOL> h1 = p . hash ( ) <EOL> self . assert_ ( '<STR_LIT>' in p ) <EOL> p . pop ( '<STR_LIT>' , prune_empty = True ) <EOL> self . assert_ ( '<STR_LIT>' not in p ) <EOL> h2 = p . hash ( ) <EOL> p . a . b . c = <NUM_LIT> <EOL> h3 = p . hash ( ) <EOL> self . assert_ ( h1 != h2 ) <EOL> self . assert_ ( h1 == h3 ) <EOL> def testpruning_03 ( self ) : <EOL> p = makeTDInstance ( '<STR_LIT>' ) <EOL> p . a . b . c = <NUM_LIT> <EOL> h1 = p . hash ( ) <EOL> self . assert_ ( '<STR_LIT>' in p ) <EOL> del p . a . b . c <EOL> self . assert_ ( '<STR_LIT>' not in p ) <EOL> h2 = p . hash ( ) <EOL> p . a . b . c = <NUM_LIT> <EOL> h3 = p . hash ( ) <EOL> self . assert_ ( h1 != h2 ) <EOL> self . assert_ ( h1 == h3 ) <EOL> def testpruning_04 ( self ) : <EOL> p1 = sample_tree ( ) <EOL> p1 . testnode = <NUM_LIT> <EOL> p2 = deepcopy ( p1 ) <EOL> self . assert_ ( p1 == p2 ) <EOL> p1 . pop ( "<STR_LIT>" ) <EOL> self . assert_ ( p1 != p2 ) <EOL> self . assert_ ( '<STR_LIT>' not in p1 ) <EOL> def testpruning_05_silent ( self ) : <EOL> p1 = sample_tree ( ) <EOL> p1 . testnode = <NUM_LIT> <EOL> p2 = deepcopy ( p1 ) <EOL> self . assert_ ( p1 == p2 ) <EOL> self . assertRaises ( KeyError , lambda : p1 . pop ( "<STR_LIT>" ) ) <EOL> p1 . pop ( "<STR_LIT>" , silent = True ) <EOL> self . assert_ ( p1 == p2 ) <EOL> self . assert_ ( '<STR_LIT>' in p1 ) <EOL> p1 . pop ( "<STR_LIT>" , silent = True ) <EOL> self . assert_ ( p1 != p2 ) <EOL> self . assert_ ( '<STR_LIT>' not in p1 ) <EOL> def testpruning_06_silent_popitem ( self ) : <EOL> p1 = sample_tree ( ) <EOL> p1 . testnode = <NUM_LIT> <EOL> p2 = deepcopy ( p1 ) <EOL> self . assert_ ( p1 == p2 ) <EOL> self . assertRaises ( KeyError , lambda : p1 . popitem ( "<STR_LIT>" ) ) <EOL> p1 . pop ( "<STR_LIT>" , silent = True ) <EOL> self . assert_ ( p1 == p2 ) <EOL> self . assert_ ( '<STR_LIT>' in p1 ) <EOL> p1 . popitem ( "<STR_LIT>" , silent = True ) <EOL> self . assert_ ( p1 != p2 ) <EOL> self . assert_ ( '<STR_LIT>' not in p1 ) <EOL> class TestDeletion ( unittest . TestCase ) : <EOL> def testDeletion_01 ( self ) : <EOL> p = makeTDInstance ( ) <EOL> p . a = <NUM_LIT:1> <EOL> self . assert_ ( '<STR_LIT:a>' in p ) <EOL> del p [ '<STR_LIT:a>' ] <EOL> self . assert_ ( '<STR_LIT:a>' not in p ) <EOL> def testDeletion_02 ( self ) : <EOL> p = makeTDInstance ( ) <EOL> p . a . b . c = <NUM_LIT:1> <EOL> self . assert_ ( '<STR_LIT>' in p ) <EOL> del p [ '<STR_LIT>' ] <EOL> self . assert_ ( '<STR_LIT:a>' in p ) <EOL> self . assert_ ( '<STR_LIT>' in p ) <EOL> self . assert_ ( '<STR_LIT>' not in p ) <EOL> def testDeletion_03_is_detached ( self ) : <EOL> p = makeTDInstance ( ) <EOL> p . makeBranch ( "<STR_LIT:a>" ) <EOL> a = p . a <EOL> del p [ "<STR_LIT:a>" ] <EOL> self . assert_ ( a . rootNode ( ) is not p ) <EOL> self . assert_ ( a . parentNode ( ) is None ) <EOL> def testDeletion_04_properException_Attribute ( self ) : <EOL> p = makeTDInstance ( ) <EOL> def f ( ) : <EOL> del p . a <EOL> self . assertRaises ( AttributeError , f ) <EOL> def testDeletion_05_properException_Keys_1 ( self ) : <EOL> p = makeTDInstance ( ) <EOL> def f ( ) : <EOL> del p [ "<STR_LIT:a>" ] <EOL> self . assertRaises ( KeyError , f ) <EOL> def testDeletion_05_properException_Keys_2 ( self ) : <EOL> p = makeTDInstance ( ) <EOL> def f ( ) : <EOL> del p [ <NUM_LIT:0> ] <EOL> self . assertRaises ( KeyError , f ) <EOL> def testDeletion_05_properException_Keys_3 ( self ) : <EOL> p = makeTDInstance ( ) <EOL> def f ( ) : <EOL> del p [ None ] <EOL> self . assertRaises ( KeyError , f ) <EOL> def testDeletion_06_Frozen ( self ) : <EOL> p = makeTDInstance ( ) <EOL> p . a . x = <NUM_LIT:1> <EOL> p . freeze ( ) <EOL> def f ( ) : <EOL> del p . a <EOL> self . assertRaises ( TypeError , f ) <EOL> def testDeletion_07_Frozen ( self ) : <EOL> p = makeTDInstance ( ) <EOL> p . a . x = <NUM_LIT:1> <EOL> p . freeze ( '<STR_LIT:a>' ) <EOL> def f ( ) : <EOL> del p . a . x <EOL> self . assertRaises ( TypeError , f ) <EOL> def testDeletion_08_Frozen ( self ) : <EOL> p = makeTDInstance ( ) <EOL> p . a . x = <NUM_LIT:1> <EOL> p . freeze ( '<STR_LIT:a>' ) <EOL> del p . a <EOL> self . assert_ ( '<STR_LIT:a>' not in p ) <EOL> def testDeletion_09_Frozen_StructureOnly ( self ) : <EOL> p = makeTDInstance ( ) <EOL> p . a . x = <NUM_LIT:1> <EOL> p . freeze ( structure_only = True ) <EOL> def f ( ) : <EOL> del p . a <EOL> self . assertRaises ( TypeError , f ) <EOL> def testDeletion_10_Frozen_StructureOnly ( self ) : <EOL> p = makeTDInstance ( ) <EOL> p . a . x = <NUM_LIT:1> <EOL> p . freeze ( '<STR_LIT:a>' , structure_only = True ) <EOL> def f ( ) : <EOL> del p . a . x <EOL> self . assertRaises ( TypeError , f ) <EOL> self . assert_ ( p . a . x == <NUM_LIT:1> ) <EOL> def testDeletion_11_Frozen_StructureOnly ( self ) : <EOL> p = makeTDInstance ( ) <EOL> p . a . x = <NUM_LIT:1> <EOL> p . freeze ( '<STR_LIT:a>' , structure_only = True ) <EOL> del p . a <EOL> self . assert_ ( '<STR_LIT:a>' not in p ) <EOL> def testDeletion_12_Frozen_ValuesOnly ( self ) : <EOL> p = makeTDInstance ( ) <EOL> p . x = <NUM_LIT:1> <EOL> p . freeze ( values_only = True ) <EOL> def f ( ) : <EOL> del p . x <EOL> self . assertRaises ( TypeError , f ) <EOL> self . assert_ ( p . x == <NUM_LIT:1> ) <EOL> def testDeletion_13_Frozen_ValuesOnly ( self ) : <EOL> p = makeTDInstance ( ) <EOL> p . a . x = <NUM_LIT:1> <EOL> p . freeze ( '<STR_LIT:a>' , values_only = True ) <EOL> def f ( ) : <EOL> del p . a . x <EOL> self . assertRaises ( TypeError , f ) <EOL> self . assert_ ( p . a . x == <NUM_LIT:1> ) <EOL> def testDeletion_14_Frozen_ValuesOnly ( self ) : <EOL> p = makeTDInstance ( ) <EOL> p . a . x = <NUM_LIT:1> <EOL> p . freeze ( '<STR_LIT:a>' , values_only = True ) <EOL> del p . a <EOL> self . assert_ ( '<STR_LIT:a>' not in p ) <EOL> def testDeletionPI_06_Frozen ( self ) : <EOL> p = makeTDInstance ( ) <EOL> p . a . x = <NUM_LIT:1> <EOL> p . freeze ( ) <EOL> def f ( ) : <EOL> p . popitem ( '<STR_LIT:a>' ) <EOL> self . assertRaises ( TypeError , f ) <EOL> def testDeletionPI_07_Frozen ( self ) : <EOL> p = makeTDInstance ( ) <EOL> p . a . x = <NUM_LIT:1> <EOL> p . freeze ( '<STR_LIT:a>' ) <EOL> def f ( ) : <EOL> p . popitem ( '<STR_LIT>' ) <EOL> self . assertRaises ( TypeError , f ) <EOL> def testDeletionPI_08_Frozen ( self ) : <EOL> p = makeTDInstance ( ) <EOL> p . a . x = <NUM_LIT:1> <EOL> p . freeze ( '<STR_LIT:a>' ) <EOL> p . popitem ( '<STR_LIT:a>' ) <EOL> self . assert_ ( '<STR_LIT:a>' not in p ) <EOL> def testDeletionPI_09_Frozen_StructureOnly ( self ) : <EOL> p = makeTDInstance ( ) <EOL> p . a . x = <NUM_LIT:1> <EOL> p . freeze ( structure_only = True ) <EOL> def f ( ) : <EOL> p . popitem ( '<STR_LIT:a>' ) <EOL> self . assertRaises ( TypeError , f ) <EOL> def testDeletionPI_10_Frozen_StructureOnly ( self ) : <EOL> p = makeTDInstance ( ) <EOL> p . a . x = <NUM_LIT:1> <EOL> p . freeze ( '<STR_LIT:a>' , structure_only = True ) <EOL> def f ( ) : <EOL> p . popitem ( '<STR_LIT>' ) <EOL> self . assertRaises ( TypeError , f ) <EOL> self . assert_ ( p . a . x == <NUM_LIT:1> ) <EOL> def testDeletionPI_11_Frozen_StructureOnly ( self ) : <EOL> p = makeTDInstance ( ) <EOL> p . a . x = <NUM_LIT:1> <EOL> p . freeze ( '<STR_LIT:a>' , structure_only = True ) <EOL> p . popitem ( '<STR_LIT:a>' ) <EOL> self . assert_ ( '<STR_LIT:a>' not in p ) <EOL> def testDeletionPI_12_Frozen_ValuesOnly ( self ) : <EOL> p = makeTDInstance ( ) <EOL> p . x = <NUM_LIT:1> <EOL> p . freeze ( values_only = True ) <EOL> def f ( ) : <EOL> p . popitem ( '<STR_LIT:x>' ) <EOL> self . assertRaises ( TypeError , f ) <EOL> self . assert_ ( p . x == <NUM_LIT:1> ) <EOL> def testDeletionPI_13_Frozen_ValuesOnly ( self ) : <EOL> p = makeTDInstance ( ) <EOL> p . a . x = <NUM_LIT:1> <EOL> p . freeze ( '<STR_LIT:a>' , values_only = True ) <EOL> def f ( ) : <EOL> p . popitem ( '<STR_LIT>' ) <EOL> self . assertRaises ( TypeError , f ) <EOL> self . assert_ ( p . a . x == <NUM_LIT:1> ) <EOL> def testDeletionPI_14_Frozen_ValuesOnly ( self ) : <EOL> p = makeTDInstance ( ) <EOL> p . a . x = <NUM_LIT:1> <EOL> p . freeze ( '<STR_LIT:a>' , values_only = True ) <EOL> del p . a <EOL> self . assert_ ( '<STR_LIT:a>' not in p ) <EOL> if __name__ == '<STR_LIT:__main__>' : <EOL> unittest . main ( ) </s>
<s> from stravalib . client import Client <EOL> from stravalib . tests import TestBase <EOL> import datetime <EOL> import pytz <EOL> import urlparse <EOL> class ClientUtilsTest ( TestBase ) : <EOL> client = Client ( ) <EOL> def test_utc_datetime_to_epoch_utc_datetime_given_correct_epoch_returned ( self ) : <EOL> dt = pytz . utc . localize ( datetime . datetime ( <NUM_LIT> , <NUM_LIT:1> , <NUM_LIT:1> , <NUM_LIT:0> , <NUM_LIT:0> , <NUM_LIT:0> ) ) <EOL> self . assertEquals ( <NUM_LIT> , self . client . _utc_datetime_to_epoch ( dt ) ) <EOL> class ClientAuthorizationUrlTest ( TestBase ) : <EOL> client = Client ( ) <EOL> def get_url_param ( self , url , key ) : <EOL> """<STR_LIT>""" <EOL> return urlparse . parse_qs ( urlparse . urlparse ( url ) . query ) [ key ] [ <NUM_LIT:0> ] <EOL> def test_incorrect_scope_raises ( self ) : <EOL> self . assertRaises ( Exception , self . client . authorization_url , <NUM_LIT:1> , "<STR_LIT>" , scope = "<STR_LIT>" ) <EOL> self . assertRaises ( Exception , self . client . authorization_url , <NUM_LIT:1> , "<STR_LIT>" , scope = [ "<STR_LIT>" ] ) <EOL> def test_correct_scope ( self ) : <EOL> url = self . client . authorization_url ( <NUM_LIT:1> , "<STR_LIT>" , scope = "<STR_LIT>" ) <EOL> self . assertEqual ( self . get_url_param ( url , "<STR_LIT>" ) , "<STR_LIT>" ) <EOL> url = self . client . authorization_url ( <NUM_LIT:1> , "<STR_LIT>" , scope = "<STR_LIT>" ) <EOL> self . assertEqual ( self . get_url_param ( url , "<STR_LIT>" ) , "<STR_LIT>" ) <EOL> def test_scope_may_be_list ( self ) : <EOL> url = self . client . authorization_url ( <NUM_LIT:1> , "<STR_LIT>" , scope = [ "<STR_LIT>" , "<STR_LIT>" ] ) <EOL> self . assertEqual ( self . get_url_param ( url , "<STR_LIT>" ) , "<STR_LIT>" ) <EOL> def test_incorrect_approval_prompt_raises ( self ) : <EOL> self . assertRaises ( Exception , self . client . authorization_url , <NUM_LIT:1> , "<STR_LIT>" , approval_prompt = "<STR_LIT>" ) <EOL> def test_state_param ( self ) : <EOL> url = self . client . authorization_url ( <NUM_LIT:1> , "<STR_LIT>" , state = "<STR_LIT>" ) <EOL> self . assertEqual ( self . get_url_param ( url , "<STR_LIT:state>" ) , "<STR_LIT>" ) <EOL> def test_params ( self ) : <EOL> url = self . client . authorization_url ( <NUM_LIT:1> , "<STR_LIT>" ) <EOL> self . assertEqual ( self . get_url_param ( url , "<STR_LIT>" ) , "<STR_LIT:1>" ) <EOL> self . assertEqual ( self . get_url_param ( url , "<STR_LIT>" ) , "<STR_LIT>" ) <EOL> self . assertEqual ( self . get_url_param ( url , "<STR_LIT>" ) , "<STR_LIT>" ) </s>
<s> def upgraded_pkgs ( before_pkgs , after_pkgs ) : <EOL> return { k : after_pkgs [ k ] for k in after_pkgs if ( k in before_pkgs and before_pkgs [ k ] [ "<STR_LIT>" ] != after_pkgs [ k ] [ "<STR_LIT>" ] ) } <EOL> class FilterModule ( object ) : <EOL> def filters ( self ) : <EOL> return { '<STR_LIT>' : upgraded_pkgs } </s>
<s> import os <EOL> def split ( string , * sep ) : <EOL> return string . split ( * sep ) <EOL> class FilterModule ( object ) : <EOL> def filters ( self ) : <EOL> return { <EOL> '<STR_LIT>' : split , <EOL> } </s>
<s> from contextlib import contextmanager <EOL> import datetime <EOL> import socket <EOL> from swiftlm . utils . values import Severity <EOL> from swiftlm . utils . utility import timestamp <EOL> def get_base_dimensions ( ) : <EOL> return { <EOL> '<STR_LIT>' : socket . gethostname ( ) , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> } <EOL> class MetricData ( object ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , name , messages , dimensions = None ) : <EOL> if name . startswith ( '<STR_LIT>' ) : <EOL> self . name = name <EOL> else : <EOL> self . name = '<STR_LIT>' + name <EOL> if dimensions is None : <EOL> self . dimensions = get_base_dimensions ( ) <EOL> else : <EOL> self . dimensions = dimensions <EOL> self . messages = messages <EOL> self . timestamp ( ) <EOL> self . _message = '<STR_LIT>' <EOL> self . __value = None <EOL> @ classmethod <EOL> def single ( cls , name , value , message = '<STR_LIT>' , dimensions = None ) : <EOL> m = cls ( name , { '<STR_LIT>' : message } , dimensions ) <EOL> m . message = '<STR_LIT>' <EOL> m . value = value <EOL> return m <EOL> @ property <EOL> def value ( self ) : <EOL> return self . __value <EOL> @ value . setter <EOL> def value ( self , val ) : <EOL> if ( isinstance ( val , Severity ) and <EOL> val . name in self . messages and self . message == '<STR_LIT>' ) : <EOL> self . message = val . name <EOL> self . __value = val <EOL> @ property <EOL> def message ( self ) : <EOL> return self . _message <EOL> @ message . setter <EOL> def message ( self , val ) : <EOL> self . _message = self . messages [ val ] <EOL> try : <EOL> str ( self ) <EOL> except KeyError as e : <EOL> raise ValueError ( '<STR_LIT>' <EOL> '<STR_LIT>' . format ( val , e ) ) <EOL> def timestamp ( self ) : <EOL> self . _timestamp = timestamp ( ) <EOL> @ contextmanager <EOL> def duration ( self ) : <EOL> """<STR_LIT>""" <EOL> start = timestamp ( ) <EOL> yield <EOL> self . _timestamp = end = timestamp ( ) <EOL> if isinstance ( end , datetime . timedelta ) : <EOL> self [ '<STR_LIT>' ] = ( end - start ) . total_seconds ( ) <EOL> else : <EOL> self [ '<STR_LIT>' ] = str ( end - start ) <EOL> def child ( self , name = None , dimensions = None ) : <EOL> d = self . dimensions . copy ( ) <EOL> if dimensions is not None : <EOL> d . update ( dimensions ) <EOL> n = self . name <EOL> if name is not None : <EOL> n += '<STR_LIT:.>' + name <EOL> return MetricData ( n , self . messages , d ) <EOL> def metric ( self ) : <EOL> """<STR_LIT>""" <EOL> metric = { <EOL> '<STR_LIT>' : self . name , <EOL> '<STR_LIT:value>' : self . value , <EOL> '<STR_LIT>' : self . dimensions , <EOL> '<STR_LIT>' : self . _timestamp , <EOL> } <EOL> msg = str ( self ) <EOL> if msg != '<STR_LIT>' : <EOL> if len ( msg ) > <NUM_LIT> : <EOL> msg = msg [ : <NUM_LIT> ] + '<STR_LIT>' <EOL> metric [ '<STR_LIT>' ] = { '<STR_LIT>' : msg } <EOL> return metric <EOL> def __setitem__ ( self , key , val ) : <EOL> self . dimensions [ key ] = str ( val ) <EOL> def __getitem__ ( self , key ) : <EOL> return self . dimensions [ key ] <EOL> def __delitem__ ( self , key ) : <EOL> del self . dimensions [ key ] <EOL> def __contains__ ( self , key ) : <EOL> try : <EOL> self . dimensions [ key ] <EOL> return True <EOL> except KeyError : <EOL> return False <EOL> def __eq__ ( self , other ) : <EOL> if type ( self ) == type ( other ) : <EOL> return self . metric ( ) == other . metric ( ) <EOL> else : <EOL> return False <EOL> def __str__ ( self ) : <EOL> return self . message . format ( ** self . dimensions ) <EOL> def __repr__ ( self ) : <EOL> return '<STR_LIT>' . format ( <EOL> self . __class__ . __name__ , <EOL> self . name , <EOL> str ( self ) <EOL> ) <EOL> CheckFailure = MetricData . single ( <EOL> '<STR_LIT>' , Severity . fail , <EOL> '<STR_LIT>' , <EOL> { '<STR_LIT>' : '<STR_LIT>' , '<STR_LIT:error>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT>' } <EOL> ) </s>
<s> import unittest <EOL> import mock <EOL> from swiftlm . utils . metricdata import MetricData <EOL> from swiftlm . utils . values import Severity <EOL> class TestMetricData ( unittest . TestCase ) : <EOL> dimensions = { '<STR_LIT>' : <NUM_LIT:1> , '<STR_LIT>' : <NUM_LIT:2> } <EOL> messages = { '<STR_LIT>' : '<STR_LIT>' , '<STR_LIT>' : '<STR_LIT>' } <EOL> def test_create_metricdata ( self ) : <EOL> r = MetricData ( name = '<STR_LIT:name>' , messages = { } ) <EOL> self . assertEqual ( '<STR_LIT>' , r . name ) <EOL> self . assertEqual ( '<STR_LIT>' , r . message ) <EOL> self . assertEqual ( None , r . value ) <EOL> self . assertIn ( '<STR_LIT>' , r . dimensions ) <EOL> def test_equality_behaviour ( self ) : <EOL> m_a = MetricData ( '<STR_LIT:name>' , self . messages , self . dimensions ) <EOL> m_b = MetricData ( '<STR_LIT:name>' , self . messages , self . dimensions ) <EOL> self . assertEqual ( m_a , m_b ) <EOL> m_a = MetricData ( '<STR_LIT:name>' , self . messages , self . dimensions ) <EOL> m_b = MetricData ( '<STR_LIT>' , self . messages , self . dimensions ) <EOL> self . assertNotEqual ( m_a , m_b ) <EOL> m_a = MetricData ( '<STR_LIT:name>' , { '<STR_LIT:a>' : <NUM_LIT:1> } , self . dimensions ) <EOL> m_b = MetricData ( '<STR_LIT:name>' , { '<STR_LIT:b>' : <NUM_LIT:2> } , self . dimensions ) <EOL> self . assertEqual ( m_a , m_b , <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' ) <EOL> m_a = MetricData ( '<STR_LIT:name>' , self . messages , self . dimensions ) <EOL> m_b = MetricData ( '<STR_LIT:name>' , self . messages , { } ) <EOL> self . assertNotEqual ( m_a , m_b ) <EOL> m_a = MetricData ( '<STR_LIT:name>' , self . messages , self . dimensions ) <EOL> m_b = MetricData ( '<STR_LIT:name>' , self . messages , self . dimensions ) <EOL> m_a . message = '<STR_LIT>' <EOL> m_b . message = '<STR_LIT>' <EOL> self . assertNotEqual ( m_a , m_b ) <EOL> m_a = MetricData ( '<STR_LIT:name>' , self . messages , self . dimensions ) <EOL> m_b = MetricData ( '<STR_LIT:name>' , self . messages , self . dimensions ) <EOL> m_a . value = <NUM_LIT:1> <EOL> m_b . value = <NUM_LIT:2> <EOL> self . assertNotEqual ( m_a , m_b ) <EOL> def test_dict_behaviour ( self ) : <EOL> r = MetricData ( name = '<STR_LIT:name>' , messages = { } ) <EOL> r [ '<STR_LIT:test>' ] = <NUM_LIT:1000> <EOL> self . assertEqual ( '<STR_LIT>' , r [ '<STR_LIT:test>' ] ) <EOL> del r [ '<STR_LIT:test>' ] <EOL> self . assertNotIn ( '<STR_LIT:test>' , r ) <EOL> def test_response_child ( self ) : <EOL> r = MetricData ( name = '<STR_LIT:name>' , messages = { '<STR_LIT:a>' : '<STR_LIT:b>' } ) <EOL> r [ '<STR_LIT:test>' ] = '<STR_LIT:test>' <EOL> c = r . child ( dimensions = { '<STR_LIT>' : '<STR_LIT>' } ) <EOL> self . assertIn ( '<STR_LIT:test>' , c ) <EOL> self . assertIn ( '<STR_LIT>' , c ) <EOL> self . assertDictEqual ( { '<STR_LIT:a>' : '<STR_LIT:b>' } , c . messages ) <EOL> self . assertEqual ( '<STR_LIT>' , c . name ) <EOL> c = r . child ( ) <EOL> self . assertIn ( '<STR_LIT:test>' , c ) <EOL> self . assertNotIn ( '<STR_LIT>' , c ) <EOL> def test_message ( self ) : <EOL> r = MetricData ( <EOL> name = '<STR_LIT:name>' , <EOL> messages = { <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT:test>' : '<STR_LIT>' , <EOL> } <EOL> ) <EOL> self . assertEqual ( '<STR_LIT>' , r . message ) <EOL> r . value = Severity . ok <EOL> self . assertEqual ( '<STR_LIT>' , r . message ) <EOL> with self . assertRaisesRegexp ( ValueError , '<STR_LIT>' ) : <EOL> r . message = '<STR_LIT:test>' <EOL> r [ '<STR_LIT>' ] = '<STR_LIT>' <EOL> r . message = '<STR_LIT:test>' <EOL> self . assertEqual ( '<STR_LIT>' , str ( r ) ) </s>
<s> from . DependencyElement import DependencyElement <EOL> class DependencyCalculator ( object ) : <EOL> def __init__ ( self , plugins ) : <EOL> self . _plugins = [ ] <EOL> for elem_p in plugins : <EOL> de = DependencyElement ( elem_p ) <EOL> self . _plugins . append ( de ) <EOL> self . _ordered_plugins = [ ] <EOL> self . _errors = [ ] <EOL> def __repr__ ( self ) : <EOL> return '<STR_LIT>' % self . to_string ( ) <EOL> def calculate ( self ) : <EOL> while len ( self . _plugins ) > <NUM_LIT:0> : <EOL> np = self . _process ( ) <EOL> if np == <NUM_LIT:0> and len ( self . _plugins ) > <NUM_LIT:0> : <EOL> if self . _circular ( ) : <EOL> self . _ordered_plugins = [ ] <EOL> break <EOL> def get ( self ) : <EOL> return [ op . slug for op in self . _ordered_plugins ] <EOL> def _circular ( self ) : <EOL> is_circular = False <EOL> for elem_p1 in self . _plugins : <EOL> for elem_p2 in self . _plugins : <EOL> if elem_p1 == elem_p2 : <EOL> continue <EOL> if ( elem_p1 . has_dependency ( elem_p2 . slug ) and <EOL> elem_p2 . has_dependency ( elem_p1 . slug ) ) : <EOL> error1 = '<STR_LIT>' '<STR_LIT>' % ( <EOL> elem_p1 . slug , elem_p2 . slug ) <EOL> error2 = '<STR_LIT>' '<STR_LIT>' % ( <EOL> elem_p2 . slug , elem_p1 . slug ) <EOL> if ( error1 not in self . _errors and <EOL> error2 not in self . _errors ) : <EOL> self . _errors . append ( error1 ) <EOL> is_circular = True <EOL> return is_circular <EOL> @ property <EOL> def ok ( self ) : <EOL> return len ( self . _errors ) == <NUM_LIT:0> <EOL> @ property <EOL> def errors ( self ) : <EOL> return self . _errors <EOL> def to_string ( self ) : <EOL> rv = '<STR_LIT>' <EOL> for elem_op in self . _ordered_plugins : <EOL> rv += '<STR_LIT>' % elem_op . slug <EOL> return rv <EOL> def _process ( self ) : <EOL> for elem_p in self . _plugins : <EOL> if not elem_p . has_dependencies ( ) : <EOL> self . _plugins . remove ( elem_p ) <EOL> self . _ordered_plugins . append ( elem_p ) <EOL> self . _remove_dependency ( elem_p ) <EOL> return <NUM_LIT:1> <EOL> return <NUM_LIT:0> <EOL> def _remove_dependency ( self , plugin ) : <EOL> for elem_op in self . _plugins : <EOL> if elem_op == plugin : <EOL> continue <EOL> elem_op . remove_dependency ( plugin . slug ) </s>
<s> class CloudDescription ( object ) : <EOL> @ staticmethod <EOL> def get_cloud_name ( cloud_description ) : <EOL> return cloud_description [ '<STR_LIT:name>' ] </s>
<s> from helion_configurationprocessor . cp . model . ModelInitializerBase import ModelInitializerBase <EOL> class model_2_0 ( ModelInitializerBase ) : <EOL> def __init__ ( self , version , instructions , config_files , models , <EOL> cloud_path , site_path ) : <EOL> super ( model_2_0 , self ) . __init__ ( version , instructions , config_files , <EOL> models , cloud_path , site_path ) <EOL> def load_models ( self ) : <EOL> self . load_empty_model ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> self . load_empty_model ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> self . load_empty_model ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> self . load_empty_model ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> self . load_empty_model ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> self . load_empty_model ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> self . load_empty_model ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> self . load_empty_model ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> self . load_model ( '<STR_LIT>' , <EOL> file_type = '<STR_LIT>' ) <EOL> version = self . version ( ) <EOL> self . load_versioned_model ( version , '<STR_LIT>' ) <EOL> self . load_versioned_model ( version , '<STR_LIT>' ) <EOL> self . load_versioned_model ( version , '<STR_LIT>' ) <EOL> self . load_versioned_model ( version , '<STR_LIT>' , optional = True ) <EOL> self . load_versioned_model ( version , '<STR_LIT>' ) <EOL> self . load_versioned_model ( version , '<STR_LIT>' ) <EOL> self . load_versioned_model ( version , '<STR_LIT>' , optional = True ) <EOL> self . load_versioned_model ( version , '<STR_LIT>' ) <EOL> self . load_versioned_model ( version , '<STR_LIT>' , alias = '<STR_LIT>' ) <EOL> self . load_versioned_model ( version , '<STR_LIT>' ) <EOL> self . load_versioned_model ( version , '<STR_LIT>' , optional = True ) <EOL> self . load_versioned_model ( version , '<STR_LIT>' ) <EOL> self . load_versioned_model ( version , '<STR_LIT>' , optional = True ) <EOL> self . load_versioned_model ( version , '<STR_LIT>' , optional = True ) <EOL> self . load_versioned_model ( version , '<STR_LIT>' , optional = True ) </s>
<s> import logging <EOL> import logging . config <EOL> from copy import deepcopy <EOL> from helion_configurationprocessor . cp . model . CPLogging import CPLogging as KenLog <EOL> from helion_configurationprocessor . cp . model . GeneratorPlugin import GeneratorPlugin <EOL> from helion_configurationprocessor . cp . model . v2_0 . CloudModel import CloudModel <EOL> from helion_configurationprocessor . cp . model . v2_0 . HlmVariable import HlmVariable <EOL> LOG = logging . getLogger ( __name__ ) <EOL> class ConsumesGenerator ( GeneratorPlugin ) : <EOL> def __init__ ( self , instructions , models , controllers ) : <EOL> super ( ConsumesGenerator , self ) . __init__ ( <EOL> <NUM_LIT> , instructions , models , controllers , <EOL> '<STR_LIT>' ) <EOL> LOG . info ( '<STR_LIT>' % KenLog . fcn ( ) ) <EOL> def generate ( self ) : <EOL> LOG . info ( '<STR_LIT>' % KenLog . fcn ( ) ) <EOL> self . _action = KenLog . fcn ( ) <EOL> cloud_internal = CloudModel . internal ( self . _models [ '<STR_LIT>' ] ) <EOL> components = CloudModel . get ( cloud_internal , '<STR_LIT>' , [ ] ) <EOL> if not components : <EOL> return <EOL> components_by_mnemonic = CloudModel . get ( cloud_internal , '<STR_LIT>' ) <EOL> control_planes = CloudModel . get ( cloud_internal , '<STR_LIT>' ) <EOL> for cp_name , cp in control_planes . iteritems ( ) : <EOL> for comp_name , comp_data in cp . get ( '<STR_LIT>' , [ ] ) . iteritems ( ) : <EOL> comp_data [ '<STR_LIT>' ] = self . _get_consumes ( comp_name , <EOL> components , <EOL> components_by_mnemonic , <EOL> cp ) <EOL> def _get_consumes ( self , component_name , components , components_by_mnemonic , cp ) : <EOL> result = { } <EOL> component = components [ component_name ] <EOL> for consume in component . get ( '<STR_LIT>' , [ ] ) : <EOL> consume_name = "<STR_LIT>" % consume [ '<STR_LIT>' ] . replace ( '<STR_LIT:->' , '<STR_LIT:_>' ) <EOL> result [ consume_name ] = { } <EOL> consumes = result [ consume_name ] <EOL> if '<STR_LIT>' in consume : <EOL> consumes [ '<STR_LIT>' ] = { } <EOL> for var in consume [ '<STR_LIT>' ] : <EOL> payload = var [ '<STR_LIT>' ] if '<STR_LIT>' in var else None <EOL> value = HlmVariable . generate_value ( <EOL> self . _instructions , self . _models , <EOL> self . _controllers , var [ '<STR_LIT:name>' ] , var [ '<STR_LIT:value>' ] , <EOL> payload = payload ) <EOL> consumes [ '<STR_LIT>' ] [ var [ '<STR_LIT:name>' ] ] = value <EOL> consumed_component_name = components_by_mnemonic [ consume [ '<STR_LIT>' ] ] [ '<STR_LIT:name>' ] <EOL> consumed_component = components [ consumed_component_name ] <EOL> consumes [ '<STR_LIT:name>' ] = consumed_component_name <EOL> ep = self . _get_endpoint ( consumed_component_name , cp ) <EOL> if not ep : <EOL> if consume . get ( '<STR_LIT>' , False ) : <EOL> continue <EOL> msg = ( "<STR_LIT>" <EOL> "<STR_LIT>" % <EOL> ( component_name , consumed_component_name , <EOL> consumed_component_name ) ) <EOL> self . add_error ( msg ) <EOL> continue <EOL> for role , role_data in ep . iteritems ( ) : <EOL> if role == '<STR_LIT>' : <EOL> continue <EOL> if role == '<STR_LIT>' : <EOL> role_name = '<STR_LIT>' <EOL> else : <EOL> role_name = role <EOL> for data in role_data : <EOL> if '<STR_LIT:address>' in data . get ( '<STR_LIT>' , { } ) : <EOL> if ( '<STR_LIT>' in consume <EOL> and role not in consume [ '<STR_LIT>' ] ) : <EOL> continue <EOL> if data [ '<STR_LIT>' ] [ '<STR_LIT>' ] : <EOL> protocol = component . get ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> else : <EOL> protocol = component . get ( '<STR_LIT>' , '<STR_LIT:http>' ) <EOL> url = "<STR_LIT>" % ( protocol , <EOL> data [ '<STR_LIT>' ] [ '<STR_LIT>' ] , <EOL> data [ '<STR_LIT>' ] [ '<STR_LIT:port>' ] ) <EOL> if '<STR_LIT>' not in consumes : <EOL> consumes [ '<STR_LIT>' ] = { } <EOL> if role_name not in consumes [ '<STR_LIT>' ] : <EOL> consumes [ '<STR_LIT>' ] [ role_name ] = [ ] <EOL> consumes [ '<STR_LIT>' ] [ role_name ] . append ( { '<STR_LIT>' : data [ '<STR_LIT>' ] [ '<STR_LIT:address>' ] , <EOL> '<STR_LIT>' : data [ '<STR_LIT>' ] [ '<STR_LIT>' ] , <EOL> '<STR_LIT:host>' : data [ '<STR_LIT>' ] [ '<STR_LIT>' ] , <EOL> '<STR_LIT:port>' : data [ '<STR_LIT>' ] [ '<STR_LIT:port>' ] , <EOL> '<STR_LIT>' : protocol , <EOL> '<STR_LIT:url>' : url , <EOL> '<STR_LIT>' : data [ '<STR_LIT>' ] [ '<STR_LIT>' ] } ) <EOL> for data in role_data : <EOL> if '<STR_LIT>' in data . get ( '<STR_LIT>' , { } ) : <EOL> if ( '<STR_LIT>' in consume <EOL> and role not in consume [ '<STR_LIT>' ] ) : <EOL> continue <EOL> if '<STR_LIT>' not in consumes : <EOL> consumes [ '<STR_LIT>' ] = { } <EOL> if '<STR_LIT>' not in consumes [ '<STR_LIT>' ] : <EOL> consumes [ '<STR_LIT>' ] [ role_name ] = [ ] <EOL> for member in data [ '<STR_LIT>' ] [ '<STR_LIT>' ] : <EOL> consumes [ '<STR_LIT>' ] [ role_name ] . append ( { '<STR_LIT:host>' : member [ '<STR_LIT>' ] , <EOL> '<STR_LIT>' : member [ '<STR_LIT>' ] , <EOL> '<STR_LIT>' : member [ '<STR_LIT>' ] , <EOL> '<STR_LIT:port>' : data [ '<STR_LIT>' ] [ '<STR_LIT:port>' ] , <EOL> '<STR_LIT>' : data [ '<STR_LIT>' ] [ '<STR_LIT>' ] } ) <EOL> if consumed_component . get ( '<STR_LIT>' , False ) : <EOL> if '<STR_LIT>' in consumes and '<STR_LIT>' in consumes [ '<STR_LIT>' ] : <EOL> consumes [ '<STR_LIT>' ] [ '<STR_LIT>' ] = deepcopy ( consumes [ '<STR_LIT>' ] [ '<STR_LIT>' ] ) <EOL> if '<STR_LIT>' in consumes and '<STR_LIT>' in consumes [ '<STR_LIT>' ] : <EOL> consumes [ '<STR_LIT>' ] [ '<STR_LIT>' ] = deepcopy ( consumes [ '<STR_LIT>' ] [ '<STR_LIT>' ] ) <EOL> return result <EOL> def _get_endpoint ( self , component_name , cp ) : <EOL> ep = cp [ '<STR_LIT>' ] . get ( component_name , { } ) <EOL> if not ep : <EOL> if '<STR_LIT>' in cp : <EOL> ep = self . _get_endpoint ( component_name , cp [ '<STR_LIT>' ] ) <EOL> return ep <EOL> def get_dependencies ( self ) : <EOL> return [ '<STR_LIT>' ] </s>
<s> from . utils import read_ini <EOL> from . comparator import EQUAL , ADDITIONAL , MISSING <EOL> def ansible_hosts ( d1 , d2 , file ) : <EOL> c1 = read_ini ( d1 , file ) <EOL> c2 = read_ini ( d2 , file ) <EOL> if c1 == c2 : <EOL> return EQUAL , None <EOL> k1 = set ( c1 . keys ( ) ) <EOL> k2 = set ( c2 . keys ( ) ) <EOL> missing = { } <EOL> additional = { } <EOL> differ = { } <EOL> for k in k1 : <EOL> if k not in k2 : <EOL> missing [ k ] = c1 [ k ] <EOL> else : <EOL> if c1 [ k ] != c2 [ k ] : <EOL> differ [ k ] = ( c1 [ k ] , c2 [ k ] ) <EOL> if k1 - k2 : <EOL> for k in k1 - k2 : <EOL> missing [ k ] = c1 [ k ] <EOL> if k2 - k1 : <EOL> for k in k2 - k1 : <EOL> additional [ k ] = c2 [ k ] <EOL> result = "<STR_LIT>" <EOL> ok = EQUAL <EOL> if additional : <EOL> ok = ADDITIONAL <EOL> result += "<STR_LIT>" + "<STR_LIT:U+002CU+0020>" . join ( sorted ( additional . keys ( ) ) ) <EOL> if missing : <EOL> ok = MISSING <EOL> result += "<STR_LIT>" + "<STR_LIT:U+002CU+0020>" . join ( sorted ( missing . keys ( ) ) ) <EOL> if differ : <EOL> ok = ADDITIONAL <EOL> result += "<STR_LIT>" + "<STR_LIT:U+002CU+0020>" . join ( sorted ( differ . keys ( ) ) ) <EOL> return ok , result [ <NUM_LIT:1> : ] </s>
<s> from pytest import fixture <EOL> from Crypto . PublicKey import RSA <EOL> keydata = """<STR_LIT>""" <EOL> @ fixture ( scope = '<STR_LIT>' ) <EOL> def key ( ) : <EOL> from friendsecure . crypto import Key <EOL> return Key ( RSA . importKey ( keydata ) ) </s>
<s> import os <EOL> import sys <EOL> ENVIRONMENT_VARIABLE = "<STR_LIT>" <EOL> class FlexiSettingsProxy ( object ) : <EOL> """<STR_LIT>""" <EOL> _globals = { <EOL> '<STR_LIT>' : [ '<STR_LIT>' , '<STR_LIT>' ] , <EOL> '<STR_LIT>' : True , <EOL> '<STR_LIT>' : False , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , ) , <EOL> } <EOL> _settings_path = None <EOL> _wrapped_modules = { } <EOL> def __init__ ( self ) : <EOL> try : <EOL> settings_module = os . environ [ ENVIRONMENT_VARIABLE ] <EOL> if not settings_module : <EOL> raise KeyError <EOL> except KeyError : <EOL> raise ImportError ( "<STR_LIT>" "<STR_LIT>" % ENVIRONMENT_VARIABLE <EOL> ) <EOL> self . _settings_module = settings_module <EOL> self . _settings_path = self . _get_mod_dir ( settings_module ) <EOL> self . _import_settings ( ) <EOL> if self . _globals [ '<STR_LIT>' ] : <EOL> self . _layout_discovery ( ) <EOL> if self . _globals [ '<STR_LIT>' ] : <EOL> for module , modfile in self . _wrapped_modules . iteritems ( ) : <EOL> sys . modules [ '<STR_LIT>' % module ] = MockModule ( module , modfile ) <EOL> def __getattr__ ( self , name ) : <EOL> return self . __getattribute__ ( name ) <EOL> def __getattribute__ ( self , name ) : <EOL> if name . startswith ( '<STR_LIT:_>' ) and name != name . upper ( ) : <EOL> return object . __getattribute__ ( self , name ) <EOL> if name in self . _globals : <EOL> return self . _globals [ name ] <EOL> return object . __getattribute__ ( self , name ) <EOL> def __dir__ ( self ) : <EOL> return dir ( object ) + self . _globals . keys ( ) <EOL> def _get_package ( self , module ) : <EOL> """<STR_LIT>""" <EOL> return '<STR_LIT:.>' . join ( module . split ( '<STR_LIT:.>' ) [ : - <NUM_LIT:1> ] ) <EOL> def _get_mod_dir ( self , module ) : <EOL> """<STR_LIT>""" <EOL> package = self . _get_package ( module ) <EOL> mod = __import__ ( package ) <EOL> modfile = mod . __file__ <EOL> if not modfile . startswith ( '<STR_LIT:/>' ) : <EOL> modfile = os . path . abspath ( modfile ) <EOL> return os . path . dirname ( modfile ) <EOL> def _import_settings ( self , quiet = True ) : <EOL> """<STR_LIT>""" <EOL> self . _import ( '<STR_LIT>' ) <EOL> if '<STR_LIT>' in os . environ : <EOL> self . _globals [ '<STR_LIT>' ] = os . environ [ '<STR_LIT>' ] <EOL> self . _import ( '<STR_LIT>' , quiet ) <EOL> if '<STR_LIT>' in self . _globals : <EOL> self . _import ( '<STR_LIT>' % self . _globals [ '<STR_LIT>' ] , quiet ) <EOL> self . _import ( '<STR_LIT>' , False ) <EOL> if '<STR_LIT>' in self . _globals : <EOL> self . _import ( '<STR_LIT>' % self . _globals [ '<STR_LIT>' ] , quiet ) <EOL> def _import ( self , modname , quiet = True ) : <EOL> """<STR_LIT>""" <EOL> modfile = os . path . join ( self . _settings_path , modname ) + '<STR_LIT>' <EOL> globals_dict = dict ( globals ( ) . items ( ) + self . _globals . items ( ) ) <EOL> if not os . path . isfile ( modfile ) and quiet : <EOL> return <EOL> execfile ( modfile , globals_dict ) <EOL> settings = set ( globals_dict . keys ( ) ) - set ( globals ( ) . keys ( ) ) <EOL> for setting in settings : <EOL> if setting == setting . upper ( ) : <EOL> self . _globals [ setting ] = globals_dict [ setting ] <EOL> module = '<STR_LIT:.>' . join ( [ <EOL> self . _get_package ( self . _settings_module ) , <EOL> modname <EOL> ] ) <EOL> self . _wrapped_modules [ module ] = modfile <EOL> def _site_dir ( self , folder ) : <EOL> """<STR_LIT>""" <EOL> return os . path . join ( self . _globals [ '<STR_LIT>' ] , folder ) <EOL> def _is_site_dir ( self , folder ) : <EOL> """<STR_LIT>""" <EOL> return os . path . isdir ( self . _site_dir ( folder ) ) <EOL> def _project_dir ( self , folder ) : <EOL> """<STR_LIT>""" <EOL> return os . path . join ( self . _globals [ '<STR_LIT>' ] , folder ) <EOL> def _is_project_dir ( self , folder ) : <EOL> """<STR_LIT>""" <EOL> return os . path . isdir ( self . _project_dir ( folder ) ) <EOL> def _layout_discovery ( self ) : <EOL> """<STR_LIT>""" <EOL> if '<STR_LIT>' not in self . _globals : <EOL> self . _globals [ '<STR_LIT>' ] = os . path . dirname ( <EOL> self . _settings_path ) <EOL> self . _project_path = self . _globals [ '<STR_LIT>' ] <EOL> if '<STR_LIT>' not in self . _globals : <EOL> self . _globals [ '<STR_LIT>' ] = self . _project_path <EOL> self . _site_path = self . _globals [ '<STR_LIT>' ] <EOL> for folder in self . _globals [ '<STR_LIT>' ] : <EOL> if self . _is_project_dir ( folder ) and self . _project_dir ( folder ) not in sys . path : <EOL> sys . path . insert ( <NUM_LIT:0> , self . _project_dir ( folder ) ) <EOL> elif self . _is_site_dir ( folder ) and self . _site_dir ( folder ) not in sys . path : <EOL> sys . path . insert ( <NUM_LIT:0> , self . _site_dir ( folder ) ) <EOL> if '<STR_LIT>' not in self . _globals or not self . _globals [ '<STR_LIT>' ] : <EOL> folder = self . _globals [ '<STR_LIT>' ] <EOL> if self . _is_site_dir ( folder ) : <EOL> self . _globals [ '<STR_LIT>' ] = self . _site_dir ( folder ) <EOL> elif self . _is_project_dir ( folder ) : <EOL> self . _globals [ '<STR_LIT>' ] = self . _project_dir ( folder ) <EOL> if '<STR_LIT>' not in self . _globals or not self . _globals [ '<STR_LIT>' ] : <EOL> folder = self . _globals [ '<STR_LIT>' ] <EOL> if self . _is_site_dir ( folder ) : <EOL> self . _globals [ '<STR_LIT>' ] = self . _site_dir ( folder ) <EOL> elif self . _is_project_dir ( folder ) : <EOL> self . _globals [ '<STR_LIT>' ] = self . _project_dir ( folder ) <EOL> for folder in self . _globals [ '<STR_LIT>' ] : <EOL> if self . _is_project_dir ( folder ) not in self . _globals [ '<STR_LIT>' ] : <EOL> self . _globals [ '<STR_LIT>' ] += ( <EOL> self . _project_dir ( folder ) , <EOL> ) <EOL> class MockModule ( object ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , name , filename ) : <EOL> self . __name__ = name <EOL> self . __file__ = filename <EOL> sys . modules [ __name__ ] = FlexiSettingsProxy ( ) </s>
<s> from geventmemcache import MemcacheError , MemcacheResult <EOL> from geventmemcache . codec import MemcacheCodec <EOL> class MemcacheProtocol ( object ) : <EOL> @ classmethod <EOL> def create ( cls , type_ ) : <EOL> if isinstance ( type_ , MemcacheProtocol ) : <EOL> return type_ <EOL> elif type_ == '<STR_LIT:text>' : <EOL> return MemcacheTextProtocol ( ) <EOL> else : <EOL> raise MemcacheError ( "<STR_LIT>" % type_ ) <EOL> class MemcacheTextProtocol ( MemcacheProtocol ) : <EOL> MAX_KEY_LENGTH = <NUM_LIT> <EOL> MAX_VALUE_LENGTH = <NUM_LIT> * <NUM_LIT> <EOL> def __init__ ( self , codec = "<STR_LIT:default>" ) : <EOL> self . set_codec ( codec ) <EOL> def _check_keys ( self , keys ) : <EOL> for key in keys : <EOL> if not isinstance ( key , str ) : <EOL> raise MemcacheError ( "<STR_LIT>" ) <EOL> if len ( key ) > MemcacheTextProtocol . MAX_KEY_LENGTH : <EOL> raise MemcacheError ( "<STR_LIT>" % MemcacheTextProtocol . MAX_KEY_LENGTH ) <EOL> for c in key : <EOL> if ord ( c ) < <NUM_LIT> or ord ( c ) == <NUM_LIT> : <EOL> raise MemcacheError ( "<STR_LIT>" ) <EOL> def _check_value ( self , value ) : <EOL> if len ( value ) > MemcacheTextProtocol . MAX_VALUE_LENGTH : <EOL> raise MemcacheError ( "<STR_LIT>" % MemcacheTextProtocol . MAX_VALUE_LENGTH ) <EOL> def write_stats ( self , writer ) : <EOL> writer . write_bytes ( "<STR_LIT>" ) <EOL> def read_stats ( self , reader ) : <EOL> response_line = reader . read_line ( ) <EOL> result = { } <EOL> while True : <EOL> response_line = reader . read_line ( ) <EOL> if response_line . startswith ( '<STR_LIT>' ) : <EOL> response_fields = response_line . split ( '<STR_LIT:U+0020>' ) <EOL> key = response_fields [ <NUM_LIT:1> ] <EOL> value = response_fields [ <NUM_LIT:2> ] <EOL> result [ key ] = value <EOL> elif response_line == '<STR_LIT>' : <EOL> return MemcacheResult . OK , result <EOL> else : <EOL> return MemcacheResult . get ( response_line ) , { } <EOL> return MemcacheResult . OK , response_line <EOL> def set_codec ( self , codec ) : <EOL> self . _codec = MemcacheCodec . create ( codec ) <EOL> def _read_result ( self , reader , value = None ) : <EOL> response_line = reader . read_line ( ) <EOL> return MemcacheResult . get ( response_line ) , value <EOL> def write_version ( self , writer ) : <EOL> writer . write_bytes ( "<STR_LIT>" ) <EOL> def read_version ( self , reader ) : <EOL> response_line = reader . read_line ( ) <EOL> if response_line . startswith ( '<STR_LIT>' ) : <EOL> return MemcacheResult . OK , response_line [ <NUM_LIT:8> : ] . strip ( ) <EOL> else : <EOL> return MemcacheResult . get ( response_line ) , None <EOL> def _write_storage ( self , writer , cmd , key , value , expiration , flags , cas_unique = None ) : <EOL> self . _check_keys ( [ key ] ) <EOL> encoded_value , flags = self . _codec . encode ( value , flags ) <EOL> self . _check_value ( encoded_value ) <EOL> if cas_unique is not None : <EOL> writer . write_bytes ( "<STR_LIT>" % ( cmd , key , flags , expiration , len ( encoded_value ) , cas_unique , encoded_value ) ) <EOL> else : <EOL> writer . write_bytes ( "<STR_LIT>" % ( cmd , key , flags , expiration , len ( encoded_value ) , encoded_value ) ) <EOL> def write_cas ( self , writer , key , value , expiration , flags , cas_unique ) : <EOL> self . _write_storage ( writer , "<STR_LIT>" , key , value , expiration , flags , cas_unique ) <EOL> def read_cas ( self , reader ) : <EOL> return self . _read_result ( reader ) <EOL> def _write_incdec ( self , writer , cmd , key , value ) : <EOL> self . _check_keys ( [ key ] ) <EOL> writer . write_bytes ( "<STR_LIT>" % ( cmd , key , value ) ) <EOL> def _read_incdec ( self , reader ) : <EOL> response_line = reader . read_line ( ) <EOL> try : <EOL> return MemcacheResult . OK , int ( response_line ) <EOL> except ValueError : <EOL> return MemcacheResult . get ( response_line ) , None <EOL> def write_incr ( self , writer , key , value ) : <EOL> self . _write_incdec ( writer , "<STR_LIT>" , key , value ) <EOL> def read_incr ( self , reader ) : <EOL> return self . _read_incdec ( reader ) <EOL> def write_decr ( self , writer , key , value ) : <EOL> self . _write_incdec ( writer , "<STR_LIT>" , key , value ) <EOL> def read_decr ( self , reader ) : <EOL> return self . _read_incdec ( reader ) <EOL> def write_get ( self , writer , keys ) : <EOL> self . _check_keys ( keys ) <EOL> writer . write_bytes ( "<STR_LIT>" % "<STR_LIT:U+0020>" . join ( keys ) ) <EOL> def write_gets ( self , writer , keys ) : <EOL> self . _check_keys ( keys ) <EOL> writer . write_bytes ( "<STR_LIT>" % "<STR_LIT:U+0020>" . join ( keys ) ) <EOL> def read_get ( self , reader , with_cas_unique = False ) : <EOL> result = { } <EOL> while True : <EOL> response_line = reader . read_line ( ) <EOL> if response_line . startswith ( '<STR_LIT>' ) : <EOL> response_fields = response_line . split ( '<STR_LIT:U+0020>' ) <EOL> key = response_fields [ <NUM_LIT:1> ] <EOL> flags = int ( response_fields [ <NUM_LIT:2> ] ) <EOL> n = int ( response_fields [ <NUM_LIT:3> ] ) <EOL> if with_cas_unique : <EOL> cas_unique = int ( response_fields [ <NUM_LIT:4> ] ) <EOL> encoded_value = reader . read_bytes ( n ) <EOL> reader . read_line ( ) <EOL> if with_cas_unique : <EOL> result [ key ] = ( self . _codec . decode ( flags , encoded_value ) , cas_unique ) <EOL> else : <EOL> result [ key ] = self . _codec . decode ( flags , encoded_value ) <EOL> elif response_line == '<STR_LIT>' : <EOL> return MemcacheResult . OK , result <EOL> else : <EOL> return MemcacheResult . get ( response_line ) , { } <EOL> def read_gets ( self , reader ) : <EOL> return self . read_get ( reader , with_cas_unique = True ) <EOL> def write_delete ( self , writer , key , expiration ) : <EOL> self . _check_keys ( [ key ] ) <EOL> writer . write_bytes ( "<STR_LIT>" % ( key , expiration ) ) <EOL> def read_delete ( self , reader ) : <EOL> return self . _read_result ( reader ) <EOL> def write_set ( self , writer , key , value , expiration , flags ) : <EOL> return self . _write_storage ( writer , "<STR_LIT>" , key , value , expiration , flags ) <EOL> def read_set ( self , reader ) : <EOL> return self . _read_result ( reader ) <EOL> def write_add ( self , writer , key , value , expiration , flags ) : <EOL> return self . _write_storage ( writer , "<STR_LIT>" , key , value , expiration , flags ) <EOL> def read_add ( self , reader ) : <EOL> return self . _read_result ( reader ) <EOL> def write_replace ( self , writer , key , value , expiration , flags ) : <EOL> return self . _write_storage ( writer , "<STR_LIT:replace>" , key , value , expiration , flags ) <EOL> def read_replace ( self , reader ) : <EOL> return self . _read_result ( reader ) <EOL> def write_append ( self , writer , key , value , expiration , flags ) : <EOL> return self . _write_storage ( writer , "<STR_LIT>" , key , value , expiration , flags ) <EOL> def read_append ( self , reader ) : <EOL> return self . _read_result ( reader ) <EOL> def write_prepend ( self , writer , key , value , expiration , flags ) : <EOL> return self . _write_storage ( writer , "<STR_LIT>" , key , value , expiration , flags ) <EOL> def read_prepend ( self , reader ) : <EOL> return self . _read_result ( reader ) </s>
<s> """<STR_LIT>""" <EOL> from __future__ import absolute_import , division , unicode_literals <EOL> from . . import constants <EOL> from . . utils import default_etree <EOL> __all__ = [ "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" ] <EOL> treeWalkerCache = { } <EOL> def getTreeWalker ( treeType , implementation = None , kwargs ) : <EOL> """<STR_LIT>""" <EOL> treeType = treeType . lower ( ) <EOL> if treeType not in treeWalkerCache : <EOL> if treeType == "<STR_LIT>" : <EOL> from . import dom <EOL> treeWalkerCache [ treeType ] = dom . TreeWalker <EOL> elif treeType == "<STR_LIT>" : <EOL> from . import genshistream <EOL> treeWalkerCache [ treeType ] = genshistream . TreeWalker <EOL> elif treeType == "<STR_LIT>" : <EOL> from . import lxmletree <EOL> treeWalkerCache [ treeType ] = lxmletree . TreeWalker <EOL> elif treeType == "<STR_LIT>" : <EOL> from . import etree <EOL> if implementation is None : <EOL> implementation = default_etree <EOL> return etree . getETreeModule ( implementation , kwargs ) . TreeWalker <EOL> return treeWalkerCache . get ( treeType ) <EOL> def concatenateCharacterTokens ( tokens ) : <EOL> pendingCharacters = [ ] <EOL> for token in tokens : <EOL> type = token [ "<STR_LIT:type>" ] <EOL> if type in ( "<STR_LIT>" , "<STR_LIT>" ) : <EOL> pendingCharacters . append ( token [ "<STR_LIT:data>" ] ) <EOL> else : <EOL> if pendingCharacters : <EOL> yield { "<STR_LIT:type>" : "<STR_LIT>" , "<STR_LIT:data>" : "<STR_LIT>" . join ( pendingCharacters ) } <EOL> pendingCharacters = [ ] <EOL> yield token <EOL> if pendingCharacters : <EOL> yield { "<STR_LIT:type>" : "<STR_LIT>" , "<STR_LIT:data>" : "<STR_LIT>" . join ( pendingCharacters ) } <EOL> def pprint ( walker ) : <EOL> """<STR_LIT>""" <EOL> output = [ ] <EOL> indent = <NUM_LIT:0> <EOL> for token in concatenateCharacterTokens ( walker ) : <EOL> type = token [ "<STR_LIT:type>" ] <EOL> if type in ( "<STR_LIT>" , "<STR_LIT>" ) : <EOL> if token [ "<STR_LIT>" ] and token [ "<STR_LIT>" ] != constants . namespaces [ "<STR_LIT:html>" ] : <EOL> if token [ "<STR_LIT>" ] in constants . prefixes : <EOL> ns = constants . prefixes [ token [ "<STR_LIT>" ] ] <EOL> else : <EOL> ns = token [ "<STR_LIT>" ] <EOL> name = "<STR_LIT>" % ( ns , token [ "<STR_LIT:name>" ] ) <EOL> else : <EOL> name = token [ "<STR_LIT:name>" ] <EOL> output . append ( "<STR_LIT>" % ( "<STR_LIT:U+0020>" * indent , name ) ) <EOL> indent += <NUM_LIT:2> <EOL> attrs = token [ "<STR_LIT:data>" ] <EOL> for ( namespace , localname ) , value in sorted ( attrs . items ( ) ) : <EOL> if namespace : <EOL> if namespace in constants . prefixes : <EOL> ns = constants . prefixes [ namespace ] <EOL> else : <EOL> ns = namespace <EOL> name = "<STR_LIT>" % ( ns , localname ) <EOL> else : <EOL> name = localname <EOL> output . append ( "<STR_LIT>" % ( "<STR_LIT:U+0020>" * indent , name , value ) ) <EOL> if type == "<STR_LIT>" : <EOL> indent -= <NUM_LIT:2> <EOL> elif type == "<STR_LIT>" : <EOL> indent -= <NUM_LIT:2> <EOL> elif type == "<STR_LIT>" : <EOL> output . append ( "<STR_LIT>" % ( "<STR_LIT:U+0020>" * indent , token [ "<STR_LIT:data>" ] ) ) <EOL> elif type == "<STR_LIT>" : <EOL> if token [ "<STR_LIT:name>" ] : <EOL> if token [ "<STR_LIT>" ] : <EOL> output . append ( """<STR_LIT>""" % <EOL> ( "<STR_LIT:U+0020>" * indent , <EOL> token [ "<STR_LIT:name>" ] , <EOL> token [ "<STR_LIT>" ] , <EOL> token [ "<STR_LIT>" ] if token [ "<STR_LIT>" ] else "<STR_LIT>" ) ) <EOL> elif token [ "<STR_LIT>" ] : <EOL> output . append ( """<STR_LIT>""" % <EOL> ( "<STR_LIT:U+0020>" * indent , <EOL> token [ "<STR_LIT:name>" ] , <EOL> token [ "<STR_LIT>" ] ) ) <EOL> else : <EOL> output . append ( "<STR_LIT>" % ( "<STR_LIT:U+0020>" * indent , <EOL> token [ "<STR_LIT:name>" ] ) ) <EOL> else : <EOL> output . append ( "<STR_LIT>" % ( "<STR_LIT:U+0020>" * indent , ) ) <EOL> elif type == "<STR_LIT>" : <EOL> output . append ( "<STR_LIT>" % ( "<STR_LIT:U+0020>" * indent , token [ "<STR_LIT:data>" ] ) ) <EOL> elif type == "<STR_LIT>" : <EOL> assert False , "<STR_LIT>" <EOL> else : <EOL> raise ValueError ( "<STR_LIT>" % type ) <EOL> return "<STR_LIT:\n>" . join ( output ) </s>
<s> import os <EOL> import subprocess <EOL> from campfin . db import * <EOL> class Seeder ( object ) : <EOL> def __init__ ( self ) : <EOL> self . path = os . path . join ( os . getcwd ( ) , '<STR_LIT:data>' ) <EOL> self . db = DB ( ) <EOL> def seed ( self ) : <EOL> filepath = self . download_fec_file ( ) <EOL> self . unzip_fec_file ( filepath ) <EOL> filepath = self . head_fec_file ( ) <EOL> self . load_fec_data ( filepath ) <EOL> def download_fec_file ( self ) : <EOL> print "<STR_LIT>" <EOL> filepath = os . path . join ( self . path , '<STR_LIT>' ) <EOL> fh = open ( filepath , '<STR_LIT:wb>' ) <EOL> with open ( filepath , '<STR_LIT:wb>' ) as fh : <EOL> subprocess . call ( [ "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" ] , stdout = fh ) <EOL> return filepath <EOL> def unzip_fec_file ( self , filepath ) : <EOL> print "<STR_LIT>" <EOL> subprocess . call ( [ "<STR_LIT>" , filepath , "<STR_LIT>" , self . path ] ) <EOL> def head_fec_file ( self , lines = <NUM_LIT> ) : <EOL> print "<STR_LIT>" % lines <EOL> filepath = os . path . join ( self . path , '<STR_LIT>' ) <EOL> with open ( filepath , '<STR_LIT:w>' ) as fh : <EOL> subprocess . call ( [ "<STR_LIT>" , "<STR_LIT>" % lines , os . path . join ( self . path , '<STR_LIT>' ) ] , stdout = fh ) <EOL> return filepath <EOL> def load_fec_data ( self , filepath ) : <EOL> print "<STR_LIT>" <EOL> self . db . execute ( "<STR_LIT>" , """<STR_LIT>""" , args = [ filepath , ] ) </s>
<s> '''<STR_LIT>''' <EOL> __author__ = "<STR_LIT>" <EOL> __copyright__ = "<STR_LIT>" <EOL> __license__ = "<STR_LIT>" <EOL> __maintainer__ = "<STR_LIT>" <EOL> __email__ = "<STR_LIT>" <EOL> __status__ = "<STR_LIT>" <EOL> import numpy as np <EOL> from pandas import DataFrame , Series <EOL> import logging <EOL> logger = logging . getLogger ( __name__ ) <EOL> def _find_nearest ( array , value ) : <EOL> '''<STR_LIT>''' <EOL> idx = ( np . abs ( array - value ) ) . argmin ( ) <EOL> return idx , array [ idx ] <EOL> def dynamic_baseline ( df , slices , style = '<STR_LIT>' , weightstyle = None , axis = <NUM_LIT:1> ) : <EOL> '''<STR_LIT>''' <EOL> if style != '<STR_LIT>' or axis != <NUM_LIT:1> : <EOL> raise NotImplementedError ( '<STR_LIT>' ) <EOL> if weightstyle : <EOL> if weightstyle != '<STR_LIT>' : <EOL> raise NotImplemented ( '<STR_LIT>' % weightstyle ) <EOL> xp = [ ] <EOL> logger . info ( '<STR_LIT>' % style ) <EOL> for val in slices : <EOL> if len ( val ) == <NUM_LIT:1> : <EOL> xp . append ( _find_nearest ( df . index , val ) [ <NUM_LIT:1> ] ) <EOL> elif len ( val ) == <NUM_LIT:2> : <EOL> xvals = np . asarray ( df . ix [ val [ <NUM_LIT:0> ] : val [ <NUM_LIT:1> ] ] . index ) <EOL> if weightstyle == '<STR_LIT>' : <EOL> xp . append ( np . mean ( xvals ) ) <EOL> else : <EOL> xp = xp + list ( xvals ) <EOL> else : <EOL> raise AttributeError ( '<STR_LIT>' <EOL> '<STR_LIT>' % ( val , len ( val ) ) ) <EOL> bout = { } <EOL> for col in df . columns : <EOL> curve = df [ col ] <EOL> z = np . polyfit ( xp , curve [ xp ] , <NUM_LIT:1> ) <EOL> p = np . poly1d ( z ) <EOL> array = p ( np . asarray ( list ( curve . index ) ) ) <EOL> reference = Series ( array , name = col , index = curve . index ) <EOL> bout [ col ] = reference <EOL> bout = DataFrame ( bout ) <EOL> bout . reindex ( columns = df . columns ) <EOL> return bout </s>
<s> '''<STR_LIT>''' <EOL> __author__ = "<STR_LIT>" <EOL> __maintainer__ = "<STR_LIT>" <EOL> __email__ = "<STR_LIT>" <EOL> __status__ = "<STR_LIT>" <EOL> import cPickle <EOL> from operator import attrgetter <EOL> from pandas import DataFrame <EOL> from numpy . random import randn <EOL> class TempDump ( object ) : <EOL> '''<STR_LIT>''' <EOL> def __init__ ( self , dataframe , metadict ) : <EOL> self . dataframe = dataframe <EOL> self . _metadict = metadict <EOL> dfempty = DataFrame ( ) <EOL> defattrs = dir ( dfempty ) <EOL> def print_customattr ( df ) : <EOL> '''<STR_LIT>''' <EOL> metadict = _get_metadict ( df ) <EOL> if len ( metadict ) > <NUM_LIT:0> : <EOL> print '<STR_LIT>' % len ( metadict ) <EOL> print '<STR_LIT:\n>' . join ( [ ( k + '<STR_LIT:\t>' + v ) for k , v in sorted ( metadict . items ( ) ) ] ) <EOL> else : <EOL> print '<STR_LIT>' <EOL> def _get_metadict ( df ) : <EOL> '''<STR_LIT>''' <EOL> attrs = dir ( df ) <EOL> newattr = [ att for att in attrs if att not in defattrs ] <EOL> if len ( newattr ) > <NUM_LIT:1> : <EOL> fget = attrgetter ( * newattr ) <EOL> return dict ( zip ( newattr , fget ( df ) ) ) <EOL> else : <EOL> return { } <EOL> def df_dumps ( df ) : <EOL> '''<STR_LIT>''' <EOL> metadict = _get_metadict ( df ) <EOL> return cPickle . dumps ( TempDump ( df , metadict ) ) <EOL> def df_dump ( df , outfile ) : <EOL> '''<STR_LIT>''' <EOL> outstream = df_dumps ( df ) <EOL> f = open ( outfile , '<STR_LIT:w>' ) <EOL> f . write ( outstream ) <EOL> f . close ( ) <EOL> return None <EOL> def df_load ( infile ) : <EOL> '''<STR_LIT>''' <EOL> f = open ( infile , '<STR_LIT:r>' ) <EOL> tempobj = cPickle . load ( f ) <EOL> f . close ( ) <EOL> df = tempobj . dataframe <EOL> for attr , value in tempobj . _metadict . items ( ) : <EOL> setattr ( df , attr , value ) <EOL> return df <EOL> def df_loads ( stream ) : <EOL> '''<STR_LIT>''' <EOL> tempobj = cPickle . loads ( stream ) <EOL> df = tempobj . dataframe <EOL> for attr , value in tempobj . _metadict . items ( ) : <EOL> setattr ( df , attr , value ) <EOL> return df <EOL> if __name__ == '<STR_LIT:__main__>' : <EOL> df = DataFrame ( ( ( randn ( <NUM_LIT:3> , <NUM_LIT:3> ) ) ) , columns = [ '<STR_LIT:a>' , '<STR_LIT:b>' , '<STR_LIT:c>' ] ) <EOL> print_customattr ( df ) <EOL> print '<STR_LIT>' <EOL> df . name = '<STR_LIT>' <EOL> df . junk = '<STR_LIT>' <EOL> print_customattr ( df ) <EOL> stream = df_dumps ( df ) <EOL> print '<STR_LIT>' <EOL> dfnew = df_loads ( stream ) <EOL> print '<STR_LIT>' <EOL> print_customattr ( dfnew ) <EOL> outfile = '<STR_LIT>' <EOL> df_dump ( df , outfile ) <EOL> print '<STR_LIT>' % outfile <EOL> dfnewnew = df_load ( outfile ) <EOL> print '<STR_LIT>' % outfile <EOL> print_customattr ( dfnewnew ) </s>
<s> import os <EOL> import tempfile <EOL> import unittest <EOL> from flask import current_app <EOL> from flask_reveal . app import FlaskReveal <EOL> from flask_reveal . blueprints . reveal import reveal_blueprint <EOL> from flask_reveal . config import REVEAL_CONFIG , REVEAL_META <EOL> class BaseAppTestCase ( unittest . TestCase ) : <EOL> def setUp ( self ) : <EOL> self . app = FlaskReveal ( '<STR_LIT>' ) <EOL> self . app . config [ '<STR_LIT>' ] = True <EOL> fd , self . config = tempfile . mkstemp ( '<STR_LIT>' ) <EOL> os . close ( fd ) <EOL> def tearDown ( self ) : <EOL> os . remove ( self . config ) <EOL> def test_start_invalid_config ( self ) : <EOL> self . assertRaises ( FileNotFoundError , <EOL> self . app . start , <EOL> '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ) <EOL> def test_current_app ( self ) : <EOL> with self . app . app_context ( ) : <EOL> self . assertEqual ( current_app . name , '<STR_LIT>' ) <EOL> def test_blueprint_loading ( self ) : <EOL> with self . app . app_context ( ) : <EOL> self . assertDictEqual ( current_app . blueprints , <EOL> { '<STR_LIT>' : reveal_blueprint } ) <EOL> def test_default_config_loading ( self ) : <EOL> with self . app . app_context ( ) : <EOL> self . assertDictEqual ( current_app . config [ '<STR_LIT>' ] , <EOL> REVEAL_META ) <EOL> self . assertDictEqual ( current_app . config [ '<STR_LIT>' ] , <EOL> REVEAL_CONFIG ) <EOL> def test_user_config_loading ( self ) : <EOL> with open ( self . config , '<STR_LIT:w>' ) as config : <EOL> config . write ( '<STR_LIT>' ) <EOL> self . app . load_user_config ( '<STR_LIT>' , '<STR_LIT>' , self . config ) <EOL> with self . app . app_context ( ) : <EOL> self . assertEqual ( current_app . config [ '<STR_LIT>' ] , '<STR_LIT>' ) <EOL> def test_user_config_loading_invalid_config_file ( self ) : <EOL> self . assertRaises ( FileNotFoundError , <EOL> self . app . load_user_config , <EOL> '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ) </s>
<s> DEBUG = True <EOL> TEMPLATE_DEBUG = DEBUG <EOL> ADMINS = ( <EOL> ) <EOL> MANAGERS = ADMINS <EOL> DATABASES = { <EOL> '<STR_LIT:default>' : { <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> } <EOL> } <EOL> ALLOWED_HOSTS = [ ] <EOL> TIME_ZONE = '<STR_LIT>' <EOL> LANGUAGE_CODE = '<STR_LIT>' <EOL> SITE_ID = <NUM_LIT:1> <EOL> USE_I18N = True <EOL> USE_L10N = True <EOL> USE_TZ = True <EOL> MEDIA_ROOT = '<STR_LIT>' <EOL> MEDIA_URL = '<STR_LIT>' <EOL> STATIC_ROOT = '<STR_LIT>' <EOL> STATIC_URL = '<STR_LIT>' <EOL> STATICFILES_DIRS = ( <EOL> ) <EOL> STATICFILES_FINDERS = ( <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> ) <EOL> SECRET_KEY = '<STR_LIT>' <EOL> TEMPLATE_LOADERS = ( <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> ) <EOL> MIDDLEWARE_CLASSES = ( <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> ) <EOL> ROOT_URLCONF = '<STR_LIT>' <EOL> WSGI_APPLICATION = '<STR_LIT>' <EOL> TEMPLATE_DIRS = ( <EOL> '<STR_LIT>' , <EOL> ) <EOL> INSTALLED_APPS = ( <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> LOGGING = { <EOL> '<STR_LIT:version>' : <NUM_LIT:1> , <EOL> '<STR_LIT>' : False , <EOL> '<STR_LIT>' : { <EOL> '<STR_LIT>' : { <EOL> '<STR_LIT>' : '<STR_LIT>' <EOL> } <EOL> } , <EOL> '<STR_LIT>' : { <EOL> '<STR_LIT>' : { <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : [ '<STR_LIT>' ] , <EOL> '<STR_LIT:class>' : '<STR_LIT>' <EOL> } <EOL> } , <EOL> '<STR_LIT>' : { <EOL> '<STR_LIT>' : { <EOL> '<STR_LIT>' : [ '<STR_LIT>' ] , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : True , <EOL> } , <EOL> } <EOL> } <EOL> WORKER_TIMEOUT = <NUM_LIT:5> * <NUM_LIT> <EOL> NUMBER_OF_TASK_PER_PAGE = <NUM_LIT> <EOL> ANSIBLE_FORKS = <NUM_LIT:30> <EOL> ANSIBLE_INVENTORY = '<STR_LIT>' </s>
<s> from threading import Thread <EOL> import time <EOL> def loop ( idx , nsec ) : <EOL> print ( "<STR_LIT>" , idx , "<STR_LIT>" , time . ctime ( ) ) <EOL> time . sleep ( nsec ) <EOL> print ( "<STR_LIT>" , idx , "<STR_LIT>" , time . ctime ( ) ) <EOL> def main ( ) : <EOL> print ( "<STR_LIT>" , time . ctime ( ) ) <EOL> thread0 = Thread ( target = loop , args = ( <NUM_LIT:0> , <NUM_LIT:4> ) ) <EOL> thread0 . start ( ) <EOL> thread1 = Thread ( target = loop , args = ( <NUM_LIT:1> , <NUM_LIT:2> ) ) <EOL> thread1 . start ( ) <EOL> thread0 . join ( ) <EOL> thread1 . join ( ) <EOL> print ( "<STR_LIT>" , time . ctime ( ) ) <EOL> if "<STR_LIT:__main__>" == __name__ : <EOL> main ( ) </s>
<s> """<STR_LIT>""" <EOL> import calendar <EOL> from datetime import datetime , timedelta <EOL> import re <EOL> DT_FORMAT = "<STR_LIT>" <EOL> INTERNAL_DT_FORMAT_NO_TZ = "<STR_LIT>" <EOL> def utc_to_local ( utc_dt ) : <EOL> """<STR_LIT>""" <EOL> timestamp = calendar . timegm ( utc_dt . timetuple ( ) ) <EOL> local_dt = datetime . fromtimestamp ( timestamp ) <EOL> assert utc_dt . resolution >= timedelta ( microseconds = <NUM_LIT:1> ) <EOL> return local_dt . replace ( microsecond = utc_dt . microsecond ) <EOL> def parse_to_local_dt ( dt_s ) : <EOL> return utc_to_local ( parse_to_utc_dt ( dt_s ) ) <EOL> def parse_to_utc_dt ( dt_s ) : <EOL> dt_no_tz = dt_s [ : - <NUM_LIT:6> ] <EOL> tz = dt_s [ - <NUM_LIT:5> : ] <EOL> dt = datetime . strptime ( dt_no_tz , INTERNAL_DT_FORMAT_NO_TZ ) <EOL> td , is_neg = _tz_to_timedelta ( tz ) <EOL> if is_neg : <EOL> dt += td <EOL> else : <EOL> dt -= td <EOL> return dt <EOL> TZ_RE = re . compile ( r"<STR_LIT>" ) <EOL> def _tz_to_timedelta ( tz ) : <EOL> match = TZ_RE . match ( tz ) <EOL> hours = int ( match . group ( <NUM_LIT:2> ) ) <EOL> minutes = int ( match . group ( <NUM_LIT:3> ) ) <EOL> return ( timedelta ( seconds = ( ( <NUM_LIT> * minutes ) + <EOL> ( <NUM_LIT> * <NUM_LIT> * hours ) ) ) , <EOL> match . group ( <NUM_LIT:1> ) == "<STR_LIT:->" ) </s>
<s> import time <EOL> import warnings <EOL> try : <EOL> import requests <EOL> REQUESTS_AVAILABLE = True <EOL> except ImportError : <EOL> REQUESTS_AVAILABLE = False <EOL> from . base import Connection <EOL> from . . exceptions import ConnectionError , ImproperlyConfigured , ConnectionTimeout , SSLError <EOL> from . . compat import urlencode <EOL> class RequestsHttpConnection ( Connection ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , host = '<STR_LIT:localhost>' , port = <NUM_LIT> , http_auth = None , <EOL> use_ssl = False , verify_certs = False , ca_certs = None , client_cert = None , <EOL> kwargs ) : <EOL> if not REQUESTS_AVAILABLE : <EOL> raise ImproperlyConfigured ( "<STR_LIT>" ) <EOL> super ( RequestsHttpConnection , self ) . __init__ ( host = host , port = port , kwargs ) <EOL> self . session = requests . session ( ) <EOL> if http_auth is not None : <EOL> if not isinstance ( http_auth , ( tuple , list ) ) : <EOL> http_auth = http_auth . split ( '<STR_LIT::>' , <NUM_LIT:1> ) <EOL> http_auth = tuple ( http_auth ) <EOL> self . session . auth = http_auth <EOL> self . base_url = '<STR_LIT>' % ( <EOL> '<STR_LIT:s>' if use_ssl else '<STR_LIT>' , <EOL> host , port , self . url_prefix <EOL> ) <EOL> self . session . verify = verify_certs <EOL> self . session . cert = client_cert <EOL> if ca_certs : <EOL> if not verify_certs : <EOL> raise ImproperlyConfigured ( "<STR_LIT>" ) <EOL> self . session . verify = ca_certs <EOL> if use_ssl and not verify_certs : <EOL> warnings . warn ( <EOL> '<STR_LIT>' % self . base_url ) <EOL> def perform_request ( self , method , url , params = None , body = None , timeout = None , ignore = ( ) ) : <EOL> url = self . base_url + url <EOL> if params : <EOL> url = '<STR_LIT>' % ( url , urlencode ( params or { } ) ) <EOL> start = time . time ( ) <EOL> try : <EOL> response = self . session . request ( method , url , data = body , timeout = timeout or self . timeout ) <EOL> duration = time . time ( ) - start <EOL> raw_data = response . text <EOL> except requests . exceptions . SSLError as e : <EOL> self . log_request_fail ( method , url , body , time . time ( ) - start , exception = e ) <EOL> raise SSLError ( '<STR_LIT>' , str ( e ) , e ) <EOL> except requests . Timeout as e : <EOL> self . log_request_fail ( method , url , body , time . time ( ) - start , exception = e ) <EOL> raise ConnectionTimeout ( '<STR_LIT>' , str ( e ) , e ) <EOL> except requests . ConnectionError as e : <EOL> self . log_request_fail ( method , url , body , time . time ( ) - start , exception = e ) <EOL> raise ConnectionError ( '<STR_LIT>' , str ( e ) , e ) <EOL> if not ( <NUM_LIT:200> <= response . status_code < <NUM_LIT> ) and response . status_code not in ignore : <EOL> self . log_request_fail ( method , url , body , duration , response . status_code ) <EOL> self . _raise_error ( response . status_code , raw_data ) <EOL> self . log_request_success ( method , url , response . request . path_url , body , response . status_code , raw_data , duration ) <EOL> return response . status_code , response . headers , raw_data </s>
<s> from __future__ import absolute_import <EOL> from splunklib . client import Service <EOL> try : <EOL> from collections import OrderedDict <EOL> except ImportError : <EOL> from ordereddict import OrderedDict <EOL> from logging import _levelNames , getLevelName <EOL> from inspect import getmembers <EOL> from os import environ , path <EOL> from sys import argv , exit , stdin , stdout <EOL> from urlparse import urlsplit <EOL> from xml . etree import ElementTree <EOL> from . import logging , splunk_csv <EOL> from . decorators import Option <EOL> from . validators import Boolean , Fieldname <EOL> from . search_command_internals import InputHeader , MessagesHeader , SearchCommandParser <EOL> class SearchCommand ( object ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self ) : <EOL> self . logger , self . _logging_configuration = logging . configure ( type ( self ) . __name__ ) <EOL> self . input_header = InputHeader ( ) <EOL> self . messages = MessagesHeader ( ) <EOL> if u'<STR_LIT>' not in environ : <EOL> self . logger . warning ( <EOL> u'<STR_LIT>' <EOL> u'<STR_LIT>' <EOL> u'<STR_LIT>' <EOL> u'<STR_LIT>' <EOL> u'<STR_LIT>' , self ) <EOL> self . _default_logging_level = self . logger . level <EOL> self . _configuration = None <EOL> self . _fieldnames = None <EOL> self . _option_view = None <EOL> self . _output_file = None <EOL> self . _search_results_info = None <EOL> self . _service = None <EOL> self . parser = SearchCommandParser ( ) <EOL> def __repr__ ( self ) : <EOL> return str ( self ) <EOL> def __str__ ( self ) : <EOL> values = [ type ( self ) . name , str ( self . options ) ] + self . fieldnames <EOL> text = '<STR_LIT:U+0020>' . join ( [ value for value in values if len ( value ) > <NUM_LIT:0> ] ) <EOL> return text <EOL> @ Option <EOL> def logging_configuration ( self ) : <EOL> """<STR_LIT>""" <EOL> return self . _logging_configuration <EOL> @ logging_configuration . setter <EOL> def logging_configuration ( self , value ) : <EOL> self . logger , self . _logging_configuration = logging . configure ( <EOL> type ( self ) . __name__ , value ) <EOL> return <EOL> @ Option <EOL> def logging_level ( self ) : <EOL> """<STR_LIT>""" <EOL> return getLevelName ( self . logger . getEffectiveLevel ( ) ) <EOL> @ logging_level . setter <EOL> def logging_level ( self , value ) : <EOL> if value is None : <EOL> value = self . _default_logging_level <EOL> if type ( value ) is str : <EOL> try : <EOL> level = _levelNames [ value . upper ( ) ] <EOL> except KeyError : <EOL> raise ValueError ( '<STR_LIT>' % value ) <EOL> else : <EOL> try : <EOL> level = int ( value ) <EOL> except ValueError : <EOL> raise ValueError ( '<STR_LIT>' % value ) <EOL> self . logger . setLevel ( level ) <EOL> return <EOL> show_configuration = Option ( doc = '''<STR_LIT>''' , default = False , validate = Boolean ( ) ) <EOL> @ property <EOL> def configuration ( self ) : <EOL> """<STR_LIT>""" <EOL> return self . _configuration <EOL> @ property <EOL> def fieldnames ( self ) : <EOL> """<STR_LIT>""" <EOL> return self . _fieldnames <EOL> @ fieldnames . setter <EOL> def fieldnames ( self , value ) : <EOL> self . _fieldnames = value <EOL> @ property <EOL> def options ( self ) : <EOL> """<STR_LIT>""" <EOL> if self . _option_view is None : <EOL> self . _option_view = Option . View ( self ) <EOL> return self . _option_view <EOL> @ property <EOL> def search_results_info ( self ) : <EOL> """<STR_LIT>""" <EOL> if self . _search_results_info is not None : <EOL> return self . _search_results_info <EOL> try : <EOL> info_path = self . input_header [ '<STR_LIT>' ] <EOL> except KeyError : <EOL> return None <EOL> def convert_field ( field ) : <EOL> return ( field [ <NUM_LIT:1> : ] if field [ <NUM_LIT:0> ] == '<STR_LIT:_>' else field ) . replace ( '<STR_LIT:.>' , '<STR_LIT:_>' ) <EOL> def convert_value ( field , value ) : <EOL> if field == '<STR_LIT>' : <EOL> split = value . split ( '<STR_LIT:;>' ) <EOL> value = dict ( ( key , int ( value ) ) <EOL> for key , value in zip ( split [ <NUM_LIT:0> : : <NUM_LIT:2> ] , split [ <NUM_LIT:1> : : <NUM_LIT:2> ] ) ) <EOL> elif field == '<STR_LIT>' : <EOL> value = ElementTree . fromstring ( value ) <EOL> elif value == '<STR_LIT>' : <EOL> value = None <EOL> else : <EOL> try : <EOL> value = float ( value ) <EOL> if value . is_integer ( ) : <EOL> value = int ( value ) <EOL> except ValueError : <EOL> pass <EOL> return value <EOL> with open ( info_path , '<STR_LIT:rb>' ) as f : <EOL> from collections import namedtuple <EOL> import csv <EOL> reader = csv . reader ( f , dialect = '<STR_LIT>' ) <EOL> fields = [ convert_field ( x ) for x in reader . next ( ) ] <EOL> values = [ convert_value ( f , v ) for f , v in zip ( fields , reader . next ( ) ) ] <EOL> search_results_info_type = namedtuple ( '<STR_LIT>' , fields ) <EOL> self . _search_results_info = search_results_info_type . _make ( values ) <EOL> return self . _search_results_info <EOL> @ property <EOL> def service ( self ) : <EOL> """<STR_LIT>""" <EOL> if self . _service is not None : <EOL> return self . _service <EOL> info = self . search_results_info <EOL> if info is None : <EOL> return None <EOL> splunkd = urlsplit ( info . splunkd_uri , info . splunkd_protocol , allow_fragments = False ) <EOL> self . _service = Service ( <EOL> scheme = splunkd . scheme , host = splunkd . hostname , port = splunkd . port , token = info . auth_token , app = info . ppc_app ) <EOL> return self . _service <EOL> def error_exit ( self , error ) : <EOL> self . logger . error ( '<STR_LIT>' + error ) <EOL> self . write_error ( error ) <EOL> exit ( <NUM_LIT:1> ) <EOL> def process ( self , args = argv , input_file = stdin , output_file = stdout ) : <EOL> """<STR_LIT>""" <EOL> self . logger . debug ( u'<STR_LIT>' , type ( self ) . __name__ , args ) <EOL> self . _configuration = None <EOL> self . _output_file = output_file <EOL> try : <EOL> if len ( args ) >= <NUM_LIT:2> and args [ <NUM_LIT:1> ] == '<STR_LIT>' : <EOL> ConfigurationSettings , operation , args , reader = self . _prepare ( args , input_file = None ) <EOL> self . parser . parse ( args , self ) <EOL> self . _configuration = ConfigurationSettings ( self ) <EOL> writer = splunk_csv . DictWriter ( output_file , self , self . configuration . keys ( ) , mv_delimiter = '<STR_LIT:U+002C>' ) <EOL> writer . writerow ( self . configuration . items ( ) ) <EOL> elif len ( args ) >= <NUM_LIT:2> and args [ <NUM_LIT:1> ] == '<STR_LIT>' : <EOL> self . input_header . read ( input_file ) <EOL> ConfigurationSettings , operation , args , reader = self . _prepare ( args , input_file ) <EOL> self . parser . parse ( args , self ) <EOL> self . _configuration = ConfigurationSettings ( self ) <EOL> if self . show_configuration : <EOL> self . messages . append ( <EOL> '<STR_LIT>' , '<STR_LIT>' <EOL> % ( self . name , self . _configuration ) ) <EOL> writer = splunk_csv . DictWriter ( output_file , self ) <EOL> self . _execute ( operation , reader , writer ) <EOL> else : <EOL> file_name = path . basename ( args [ <NUM_LIT:0> ] ) <EOL> message = ( <EOL> u'<STR_LIT>' <EOL> u'<STR_LIT>' <EOL> u'<STR_LIT>' <EOL> u'<STR_LIT>' <EOL> u'<STR_LIT>' <EOL> u'<STR_LIT>' <EOL> u'<STR_LIT>' <EOL> u'<STR_LIT>' <EOL> u'<STR_LIT>' . format ( type ( self ) . name , file_name ) ) <EOL> raise NotImplementedError ( message ) <EOL> except SystemExit : <EOL> raise <EOL> except : <EOL> import traceback <EOL> import sys <EOL> error_type , error_message , error_traceback = sys . exc_info ( ) <EOL> self . logger . error ( traceback . format_exc ( error_traceback ) ) <EOL> origin = error_traceback <EOL> while origin . tb_next is not None : <EOL> origin = origin . tb_next <EOL> filename = origin . tb_frame . f_code . co_filename <EOL> lineno = origin . tb_lineno <EOL> self . write_error ( '<STR_LIT>' , error_type . __name__ , filename , lineno , error_message ) <EOL> exit ( <NUM_LIT:1> ) <EOL> return <EOL> @ staticmethod <EOL> def records ( reader ) : <EOL> for record in reader : <EOL> yield record <EOL> return <EOL> def write_debug ( self , message , * args ) : <EOL> self . _write_message ( u'<STR_LIT>' , message , * args ) <EOL> return <EOL> def write_error ( self , message , * args ) : <EOL> self . _write_message ( u'<STR_LIT>' , message , * args ) <EOL> return <EOL> def write_info ( self , message , * args ) : <EOL> self . _write_message ( u'<STR_LIT>' , message , * args ) <EOL> return <EOL> def write_warning ( self , message , * args ) : <EOL> self . _write_message ( u'<STR_LIT>' , message , * args ) <EOL> def _execute ( self , operation , reader , writer ) : <EOL> raise NotImplementedError ( u'<STR_LIT>' ) <EOL> def _prepare ( self , argv , input_file ) : <EOL> raise NotImplementedError ( u'<STR_LIT>' ) <EOL> def _write_message ( self , message_type , message_text , * args ) : <EOL> import csv <EOL> if len ( args ) > <NUM_LIT:0> : <EOL> message_text = message_text % args <EOL> writer = csv . writer ( self . _output_file ) <EOL> writer . writerows ( [ [ ] , [ message_type ] , [ message_text ] ] ) <EOL> class ConfigurationSettings ( object ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , command ) : <EOL> self . command = command <EOL> def __str__ ( self ) : <EOL> """<STR_LIT>""" <EOL> text = '<STR_LIT:U+002CU+0020>' . join ( <EOL> [ '<STR_LIT>' % ( k , getattr ( self , k ) ) for k in self . keys ( ) ] ) <EOL> return text <EOL> @ property <EOL> def changes_colorder ( self ) : <EOL> """<STR_LIT>""" <EOL> return type ( self ) . _changes_colorder <EOL> _changes_colorder = True <EOL> @ property <EOL> def clear_required_fields ( self ) : <EOL> """<STR_LIT>""" <EOL> return type ( self ) . _clear_required_fields <EOL> _clear_required_fields = False <EOL> @ property <EOL> def enableheader ( self ) : <EOL> """<STR_LIT>""" <EOL> return True <EOL> @ property <EOL> def generating ( self ) : <EOL> """<STR_LIT>""" <EOL> return False <EOL> @ property <EOL> def maxinputs ( self ) : <EOL> """<STR_LIT>""" <EOL> return type ( self ) . _maxinputs <EOL> _maxinputs = <NUM_LIT:0> <EOL> @ property <EOL> def needs_empty_results ( self ) : <EOL> """<STR_LIT>""" <EOL> return type ( self ) . _needs_empty_results <EOL> _needs_empty_results = True <EOL> @ property <EOL> def outputheader ( self ) : <EOL> """<STR_LIT>""" <EOL> return True <EOL> @ property <EOL> def passauth ( self ) : <EOL> """<STR_LIT>""" <EOL> return type ( self ) . _passauth <EOL> _passauth = False <EOL> @ property <EOL> def perf_warn_limit ( self ) : <EOL> """<STR_LIT>""" <EOL> return type ( self ) . _perf_warn_limit <EOL> _perf_warn_limit = <NUM_LIT:0> <EOL> @ property <EOL> def requires_srinfo ( self ) : <EOL> """<STR_LIT>""" <EOL> return type ( self ) . _requires_srinfo <EOL> _requires_srinfo = False <EOL> @ property <EOL> def run_in_preview ( self ) : <EOL> """<STR_LIT>""" <EOL> return type ( self ) . _run_in_preview <EOL> _run_in_preview = True <EOL> @ property <EOL> def stderr_dest ( self ) : <EOL> """<STR_LIT>""" <EOL> return type ( self ) . _stderr_dest <EOL> _stderr_dest = '<STR_LIT>' <EOL> @ property <EOL> def supports_multivalues ( self ) : <EOL> """<STR_LIT>""" <EOL> return True <EOL> @ property <EOL> def supports_rawargs ( self ) : <EOL> """<STR_LIT>""" <EOL> return True <EOL> @ property <EOL> def required_fields ( self ) : <EOL> """<STR_LIT>""" <EOL> fieldnames = set ( self . command . fieldnames ) <EOL> for name , option in self . command . options . iteritems ( ) : <EOL> if isinstance ( option . validator , Fieldname ) : <EOL> value = option . value <EOL> if value is not None : <EOL> fieldnames . add ( value ) <EOL> text = '<STR_LIT:U+002C>' . join ( fieldnames ) <EOL> return text <EOL> @ classmethod <EOL> def configuration_settings ( cls ) : <EOL> """<STR_LIT>""" <EOL> if cls . _settings is None : <EOL> is_property = lambda x : isinstance ( x , property ) <EOL> cls . _settings = { } <EOL> for name , prop in getmembers ( cls , is_property ) : <EOL> backing_field = '<STR_LIT:_>' + name <EOL> if not hasattr ( cls , backing_field ) : <EOL> backing_field = None <EOL> cls . _settings [ name ] = ( prop , backing_field ) <EOL> return cls . _settings <EOL> @ classmethod <EOL> def fix_up ( cls , command_class ) : <EOL> """<STR_LIT>""" <EOL> raise NotImplementedError ( <EOL> '<STR_LIT>' ) <EOL> def items ( self ) : <EOL> """<STR_LIT>""" <EOL> return OrderedDict ( [ ( k , getattr ( self , k ) ) for k in self . keys ( ) ] ) <EOL> def keys ( self ) : <EOL> """<STR_LIT>""" <EOL> return sorted ( type ( self ) . configuration_settings ( ) . keys ( ) ) <EOL> _settings = None </s>
<s> import os <EOL> import os . path as osp <EOL> import waflib . Utils <EOL> import waflib . Logs as msg <EOL> from waflib . Configure import conf <EOL> _heptooldir = osp . dirname ( osp . abspath ( __file__ ) ) <EOL> def options ( ctx ) : <EOL> ctx . load ( '<STR_LIT>' , tooldir = _heptooldir ) <EOL> ctx . add_option ( <EOL> '<STR_LIT>' , <EOL> default = None , <EOL> help = "<STR_LIT>" ) <EOL> return <EOL> def configure ( ctx ) : <EOL> ctx . load ( '<STR_LIT>' , tooldir = _heptooldir ) <EOL> return <EOL> @ conf <EOL> def find_heppdt ( ctx , kwargs ) : <EOL> ctx . load ( '<STR_LIT>' , tooldir = _heptooldir ) <EOL> if not ctx . env . HWAF_FOUND_C_COMPILER : <EOL> ctx . fatal ( '<STR_LIT>' ) <EOL> pass <EOL> if not ctx . env . HWAF_FOUND_CXX_COMPILER : <EOL> ctx . fatal ( '<STR_LIT>' ) <EOL> pass <EOL> ctx . check_with ( <EOL> ctx . check , <EOL> "<STR_LIT>" , <EOL> features = '<STR_LIT>' , <EOL> header_name = "<STR_LIT>" , <EOL> lib = '<STR_LIT>' , <EOL> uselib_store = '<STR_LIT>' , <EOL> kwargs <EOL> ) <EOL> version = ctx . check_cxx ( <EOL> msg = "<STR_LIT>" , <EOL> okmsg = "<STR_LIT>" , <EOL> fragment = '''<STR_LIT>''' , <EOL> use = "<STR_LIT>" , <EOL> define_name = "<STR_LIT>" , <EOL> define_ret = True , <EOL> execute = True , <EOL> mandatory = True , <EOL> ) <EOL> ctx . start_msg ( "<STR_LIT>" ) <EOL> ctx . end_msg ( version ) <EOL> ctx . env . HEPPDT_VERSION = version <EOL> ctx . env . HWAF_FOUND_HEPPDT = <NUM_LIT:1> <EOL> ctx . check_with ( <EOL> ctx . check , <EOL> "<STR_LIT>" , <EOL> features = '<STR_LIT>' , <EOL> header_name = "<STR_LIT>" , <EOL> lib = '<STR_LIT>' , <EOL> uselib_store = '<STR_LIT>' , <EOL> ** kwargs <EOL> ) <EOL> version = ctx . check_cxx ( <EOL> msg = "<STR_LIT>" , <EOL> okmsg = "<STR_LIT>" , <EOL> fragment = '''<STR_LIT>''' , <EOL> use = "<STR_LIT>" , <EOL> define_name = "<STR_LIT>" , <EOL> define_ret = True , <EOL> execute = True , <EOL> mandatory = True , <EOL> ) <EOL> ctx . start_msg ( "<STR_LIT>" ) <EOL> ctx . end_msg ( version ) <EOL> ctx . env . HEPPID_VERSION = version <EOL> ctx . env . HWAF_FOUND_HEPPID = <NUM_LIT:1> <EOL> return </s>
<s> import os <EOL> import os . path as osp <EOL> import sys <EOL> import waflib . Options <EOL> import waflib . Utils <EOL> import waflib . Logs as msg <EOL> from waflib . Configure import conf <EOL> _heptooldir = osp . dirname ( osp . abspath ( __file__ ) ) <EOL> if not _heptooldir in sys . path : sys . path . append ( _heptooldir ) <EOL> @ conf <EOL> def hwaf_setup_spy_env ( ctx ) : <EOL> import traceback <EOL> import waflib . ConfigSet <EOL> _orig_ConfigSet_setitem = waflib . ConfigSet . ConfigSet . __setitem__ <EOL> _orig_ConfigSet_setattr = waflib . ConfigSet . ConfigSet . __setattr__ <EOL> _orig_ConfigSet_append_value = waflib . ConfigSet . ConfigSet . append_value <EOL> _orig_ConfigSet_prepend_value = waflib . ConfigSet . ConfigSet . prepend_value <EOL> _orig_ConfigSet_append_unique = waflib . ConfigSet . ConfigSet . append_unique <EOL> def _tb_stack_filter ( stack ) : <EOL> '''<STR_LIT>''' <EOL> who = stack [ - <NUM_LIT:1> ] <EOL> fname = who [ <NUM_LIT:0> ] <EOL> if fname . endswith ( ( '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> ) ) : <EOL> return True <EOL> return False <EOL> def _new_ConfigSet_setitem ( self , key , value ) : <EOL> if key == '<STR_LIT>' : <EOL> return _orig_ConfigSet_setitem ( self , key , value ) <EOL> stack = traceback . extract_stack ( ) [ : - <NUM_LIT:1> ] <EOL> if _tb_stack_filter ( stack ) : <EOL> return _orig_ConfigSet_setitem ( self , key , value ) <EOL> old_value = self [ key ] <EOL> ret = _orig_ConfigSet_setitem ( self , key , value ) <EOL> new_value = self [ key ] <EOL> if old_value != new_value or <NUM_LIT:1> : <EOL> _orig_ConfigSet_append_value ( <EOL> self , <EOL> '<STR_LIT>' , <EOL> [ { '<STR_LIT:action>' : '<STR_LIT>' , <EOL> '<STR_LIT:key>' : key , <EOL> '<STR_LIT>' : old_value , <EOL> '<STR_LIT>' : new_value , <EOL> '<STR_LIT>' : value , <EOL> '<STR_LIT>' : stack [ - <NUM_LIT:1> ] , <EOL> } ] <EOL> ) <EOL> return ret <EOL> waflib . ConfigSet . ConfigSet . __setitem__ = _new_ConfigSet_setitem <EOL> def _new_ConfigSet_setattr ( self , key , value ) : <EOL> if key == '<STR_LIT>' : <EOL> return _orig_ConfigSet_setattr ( self , key , value ) <EOL> stack = traceback . extract_stack ( ) [ : - <NUM_LIT:1> ] <EOL> if _tb_stack_filter ( stack ) : <EOL> return _orig_ConfigSet_setattr ( self , key , value ) <EOL> old_value = self [ key ] <EOL> ret = _orig_ConfigSet_setattr ( self , key , value ) <EOL> new_value = self [ key ] <EOL> if old_value != new_value or <NUM_LIT:1> : <EOL> _orig_ConfigSet_append_value ( <EOL> self , <EOL> '<STR_LIT>' , <EOL> [ { '<STR_LIT:action>' : '<STR_LIT>' , <EOL> '<STR_LIT:key>' : key , <EOL> '<STR_LIT>' : old_value , <EOL> '<STR_LIT>' : new_value , <EOL> '<STR_LIT>' : value , <EOL> '<STR_LIT>' : stack [ - <NUM_LIT:1> ] , <EOL> } ] <EOL> ) <EOL> return ret <EOL> waflib . ConfigSet . ConfigSet . __setattr__ = _new_ConfigSet_setattr <EOL> def _new_ConfigSet_append_value ( self , var , val ) : <EOL> if var == '<STR_LIT>' : <EOL> return _orig_ConfigSet_append_value ( self , var , val ) <EOL> stack = traceback . extract_stack ( ) [ : - <NUM_LIT:1> ] <EOL> if _tb_stack_filter ( stack ) : <EOL> return _orig_ConfigSet_append_value ( self , var , val ) <EOL> old_value = self [ var ] <EOL> ret = _orig_ConfigSet_append_value ( self , var , val ) <EOL> new_value = self [ var ] <EOL> if old_value != new_value or <NUM_LIT:1> : <EOL> _orig_ConfigSet_append_value ( <EOL> self , <EOL> '<STR_LIT>' , <EOL> [ { '<STR_LIT:action>' : '<STR_LIT>' , <EOL> '<STR_LIT:key>' : var , <EOL> '<STR_LIT>' : old_value , <EOL> '<STR_LIT>' : new_value , <EOL> '<STR_LIT>' : val , <EOL> '<STR_LIT>' : stack [ - <NUM_LIT:1> ] , <EOL> } ] <EOL> ) <EOL> return ret <EOL> waflib . ConfigSet . ConfigSet . append_value = _new_ConfigSet_append_value <EOL> def _new_ConfigSet_prepend_value ( self , var , val ) : <EOL> if var == '<STR_LIT>' : <EOL> return _orig_ConfigSet_prepend_value ( self , var , val ) <EOL> stack = traceback . extract_stack ( ) [ : - <NUM_LIT:1> ] <EOL> if _tb_stack_filter ( stack ) : <EOL> return _orig_ConfigSet_prepend_value ( self , var , val ) <EOL> old_value = self [ var ] <EOL> ret = _orig_ConfigSet_prepend_value ( self , var , val ) <EOL> new_value = self [ var ] <EOL> if old_value != new_value or <NUM_LIT:1> : <EOL> _orig_ConfigSet_append_value ( <EOL> self , <EOL> '<STR_LIT>' , <EOL> [ { '<STR_LIT:action>' : '<STR_LIT>' , <EOL> '<STR_LIT:key>' : var , <EOL> '<STR_LIT>' : old_value , <EOL> '<STR_LIT>' : new_value , <EOL> '<STR_LIT>' : val , <EOL> '<STR_LIT>' : stack [ - <NUM_LIT:1> ] , <EOL> } ] <EOL> ) <EOL> return ret <EOL> waflib . ConfigSet . ConfigSet . prepend_value = _new_ConfigSet_prepend_value <EOL> def _new_ConfigSet_append_unique ( self , var , val ) : <EOL> if var == '<STR_LIT>' : <EOL> return _orig_ConfigSet_append_unique ( self , var , val ) <EOL> stack = traceback . extract_stack ( ) [ : - <NUM_LIT:1> ] <EOL> if _tb_stack_filter ( stack ) : <EOL> return _orig_ConfigSet_append_unique ( self , var , val ) <EOL> old_value = self [ var ] <EOL> ret = _orig_ConfigSet_append_unique ( self , var , val ) <EOL> new_value = self [ var ] <EOL> if old_value != new_value or <NUM_LIT:1> : <EOL> _orig_ConfigSet_append_value ( <EOL> self , <EOL> '<STR_LIT>' , <EOL> [ { '<STR_LIT:action>' : '<STR_LIT>' , <EOL> '<STR_LIT:key>' : var , <EOL> '<STR_LIT>' : old_value , <EOL> '<STR_LIT>' : new_value , <EOL> '<STR_LIT>' : val , <EOL> '<STR_LIT>' : stack [ - <NUM_LIT:1> ] , <EOL> } ] <EOL> ) <EOL> return ret <EOL> waflib . ConfigSet . ConfigSet . append_unique = _new_ConfigSet_append_unique <EOL> pass </s>
<s> '''<STR_LIT>''' <EOL> import os <EOL> import os . path as osp <EOL> import waflib . Logs as msg <EOL> from waflib . Errors import WafError <EOL> import pprint <EOL> from . import util <EOL> def exec_command ( task , cmd , kw ) : <EOL> '''<STR_LIT>''' <EOL> bld = task . generator . bld <EOL> cwd = getattr ( task , '<STR_LIT>' , bld . out_dir ) <EOL> msg . debug ( '<STR_LIT>' % ( task . name , cmd , cwd ) ) <EOL> if not osp . exists ( cwd ) : <EOL> os . makedirs ( cwd ) <EOL> log_dir = bld . root . make_node ( osp . join ( bld . out_dir , '<STR_LIT>' ) ) <EOL> log_dir . mkdir ( ) <EOL> fnode = log_dir . make_node ( '<STR_LIT>' % task . name ) <EOL> flog = open ( fnode . abspath ( ) , '<STR_LIT:w>' ) <EOL> cmd_dict = dict ( kw ) <EOL> env = kw . get ( '<STR_LIT>' , task . env . env ) <EOL> cmd_dict . update ( { <EOL> '<STR_LIT>' : cwd , <EOL> '<STR_LIT>' : env , <EOL> '<STR_LIT>' : flog , <EOL> '<STR_LIT>' : flog , <EOL> } ) <EOL> try : <EOL> pdict = bld . env [ '<STR_LIT>' ] [ task . name . split ( '<STR_LIT:_>' , <NUM_LIT:1> ) [ <NUM_LIT:0> ] ] <EOL> except KeyError : <EOL> pdict = dict ( ) <EOL> flog . write ( '<STR_LIT>' % cmd ) <EOL> flog . write ( '<STR_LIT>' % cwd ) <EOL> flog . write ( '<STR_LIT>' % str ( task ) ) <EOL> flog . write ( pprint . pformat ( task . __dict__ , indent = <NUM_LIT:2> , depth = <NUM_LIT:2> ) ) <EOL> flog . write ( '<STR_LIT:\n>' ) <EOL> if pdict : <EOL> flog . write ( '<STR_LIT>' ) <EOL> flog . write ( pprint . pformat ( pdict , indent = <NUM_LIT:2> , depth = <NUM_LIT:2> ) ) <EOL> flog . write ( '<STR_LIT>' % '<STR_LIT>' . join ( [ '<STR_LIT>' % kv for kv in sorted ( env . items ( ) ) ] ) ) <EOL> flog . write ( '<STR_LIT>' ) <EOL> flog . flush ( ) <EOL> try : <EOL> ret = task . exec_command ( cmd , cmd_dict ) <EOL> except KeyboardInterrupt : <EOL> raise <EOL> except WafError : <EOL> msg . error ( '<STR_LIT>' % ( cmd , cwd ) ) <EOL> raise <EOL> finally : <EOL> flog . close ( ) <EOL> if msg . verbose and ret == <NUM_LIT:0> and '<STR_LIT>' in msg . zones : <EOL> with open ( flog . abspath ( ) ) as f : <EOL> msg . pprint ( '<STR_LIT>' , '<STR_LIT>' % ( task . name , flog . name , '<STR_LIT>' . join ( f . readlines ( ) ) ) ) <EOL> pass <EOL> pass <EOL> if ret == <NUM_LIT:0> : <EOL> return <NUM_LIT:0> <EOL> msg . error ( '<STR_LIT>' % ( ret , flog . name ) ) <EOL> repo = osp . join ( cwd , "<STR_LIT>" % task . name ) <EOL> with open ( repo , '<STR_LIT:w>' ) as fp : <EOL> fp . write ( '<STR_LIT>' ) <EOL> fp . write ( '<STR_LIT>' % cwd ) <EOL> for var , val in sorted ( env . items ( ) ) : <EOL> if val . startswith ( '<STR_LIT>' ) : <EOL> fp . write ( '<STR_LIT>' % ( var , val ) ) <EOL> else : <EOL> fp . write ( '<STR_LIT>' % ( var , val ) ) <EOL> fp . write ( '<STR_LIT>' % cmd ) <EOL> msg . error ( '<STR_LIT>' % repo ) <EOL> return ret </s>
<s> from twisted . internet import reactor , protocol <EOL> import random <EOL> import sys <EOL> class Echo ( protocol . Protocol ) : <EOL> def dataReceived ( self , data ) : <EOL> pass <EOL> def main ( ) : <EOL> factory = protocol . ServerFactory ( ) <EOL> factory . protocol = Echo <EOL> reactor . listenTCP ( <NUM_LIT> , factory ) <EOL> reactor . callLater ( int ( sys . argv [ <NUM_LIT:1> ] ) , reactor . stop ) <EOL> reactor . run ( ) <EOL> if __name__ == '<STR_LIT:__main__>' : <EOL> main ( ) </s>