Exemplo n.º 1
0
 def test_protocol_load(self):
     a = Adapter()
     a.interfaces = Mock(return_value=[1, 2, 3])
     p = Protocol(a)
     p.load()
     a.interfaces.assert_called_once_with()
     self.assertEqual(len(p.elements), 3)
Exemplo n.º 2
0
 def test_signal_load(self):
     a = Adapter()
     a.functionParameters = Mock(return_value=[1, 2, 3])
     s = Signal(a, None)
     s.load()
     a.functionParameters.assert_called_once_with(None)
     self.assertEqual(len(s.elements), 3)
Exemplo n.º 3
0
	def get_all():
		with DB() as database:
			rows = Adapter.adapt_query(database.execute('''SELECT * FROM questions''').fetchall()) # convert the data into a list of lists
			rows = Adapter.adapt_question_rows(database, rows)
			

			return [Question(*row) for row in rows] # instantiate questions list
Exemplo n.º 4
0
    def generateDataframe(self):
        current_adapter = Adapter(self.retrieveFileName())
        current_dataframe = current_adapter.retrieve_dataframe()
        self.generatedDataframe.setText(
            current_dataframe.dataframe_to_string())

        print("Will generate the Dataframe here")
Exemplo n.º 5
0
    def __init__(self):
        self.utils = Utils()
        self.adapter = Adapter()
        self.current_date = datetime.now().strftime("%Y-%m-%d")
        dir_name = os.path.dirname(__file__)
        self.files_dir_name = os.path.join(dir_name, 'file')

        self.make_xls_file()
Exemplo n.º 6
0
 def test_method_load(self):
     a = Adapter()
     a.functionParameters = Mock(side_effect=[[1, 2, 3], [4, 5]])
     m = Method(a, None, None)
     m.load()
     a.functionParameters.assert_called_with(None)
     self.assertEqual(a.functionParameters.call_count, 2)
     self.assertEqual(len(m.elements), 5)
Exemplo n.º 7
0
class Rotten:
    """
    Contains API calls for communicating with the Rotten Tomatoes API.

    """

    # Initializes with Rotten Tomatoes base URL.
    def __init__(self,
                 base_url=u'http://api.rottentomatoes.com/api/public/v1.0/',
                 api_key=u''):
        self.base_url = base_url
        self.api_key = api_key
        self.adapter = Adapter(base_url)

    # Gets/sets the base URL for connecting to the Rotten Tomatoes API.
    @property
    def base_url(self):
        return self.base_url

    # API Methods

    # Gets box office information for movies
    def box_office(self, limit=u'16', country=u'us'):
        path = self.base_url + u'lists/movies/box_office.json?apikey=%s&limit=%s&country=%s' % (
            self.api_key, limit, country)

        result = self.adapter.get_path(path)

        return result

    # Gets the latest movies in theaters
    def in_theaters(self, page_limit=u'16', page=u'1', country=u'us'):
        path = self.base_url + u'lists/movies/in_theaters.json?apikey=%s&page_limit=%s&page=%s&country=%s' % (
            self.api_key, page_limit, page, country)
        print path

        result = self.adapter.get_path(path)

        return result

    # Get movie opening information
    def opening(self, limit=u'16', country=u'us'):
        path = self.base_url + u'lists/movies/in_theaters.json?apikey=%s&limit=%s&country=%s' % (
            self.api_key, limit, country)

        result = self.adapter.get_path(path)

        return result

    # Gets upcoming movies
    def upcoming(self, page_limit=u'16', page=u'1', country=u'us'):
        path = self.base_url + u'lists/movies/in_theaters.json?apikey=%s&page_limit=%s&page=%s&country=%s' % (
            self.api_key, page_limit, page, country)

        result = self.adapter.get_path(path)

        return result
Exemplo n.º 8
0
def main():
    objects = []
    
    dog = Dog()
    objects.append(Adapter(dog, dict(make_noise=dog.bark)))
    cat = Cat()
    objects.append(Adapter(cat, dict(make_noise=cat.meow)))

    for obj in objects:
        print("A {0} goes {1}".format(obj.name, obj.make_noise()))
Exemplo n.º 9
0
	def find(id):
		with DB() as database:
			row = Adapter.adapt_query(database.execute('''SELECT * FROM questions WHERE id = ?''', (id,)).fetchall())
			
			try:
				row = tuple(Adapter.adapt_question_rows(database, row)[0])
			except IndexError as error:
				return None
			
			return Question(*row)
Exemplo n.º 10
0
def main():

    # Keep a reference to the original stdin. We then replace
    # stdin with an empty stream. This is to protect against
    # code from accessing sys.stdin directly and consuming the
    # request content.

    stdin = sys.stdin

    sys.stdin = cStringIO.StringIO('')

    # Keep a reference to the original stdout. We then replace
    # stdout with stderr. This is to protect against code that
    # wants to use 'print' to output debugging. If stdout wasn't
    # protected, then anything output using 'print' would end up
    # being sent as part of the response itself and interfere
    # with the operation of the CGI protocol.

    stdout = sys.stdout

    sys.stdout = sys.stderr

    # Use the original stderr as is for errors.

    stderr = sys.stderr

    # Use a copy of the process environment as we want to
    # populate it with additional WSGI specific variables and
    # don't want to be polluting the process environment
    # variables with those as they would then be inherited by
    # sub processes.

    environ = dict(os.environ.items())

    # Target WSGI script file is dictated by value of the
    # variable SCRIPT_FILENAME in CGI environment.

    filename = environ['SCRIPT_FILENAME']

    # Create adapter for the WSGI application contained in
    # the WSGI script file.

    application = Script(filename)

    # Create CGI/WSGI bridge wrapping the 'application' entry
    # point in the target WSGI script file along with the
    # current request context. We only use the object once and
    # then the process exits, so doesn't matter it isn't
    # reusable or thread safe.

    adapter = Adapter(application, environ, stdin, stdout, stderr)

    # Execute the application.

    adapter.handle_request()
Exemplo n.º 11
0
class Rotten:
    """
    Contains API calls for communicating with the Rotten Tomatoes API.

    """

    # Initializes with Rotten Tomatoes base URL.
    def __init__(self, base_url=u'http://api.rottentomatoes.com/api/public/v1.0/', api_key=u''):
        self.base_url = base_url
        self.api_key = api_key
        self.adapter = Adapter(base_url)

    # Gets/sets the base URL for connecting to the Rotten Tomatoes API.
    @property
    def base_url(self):
        return self.base_url


    # API Methods

    # Gets box office information for movies
    def box_office(self, limit=u'16', country=u'us'):
        path = self.base_url + u'lists/movies/box_office.json?apikey=%s&limit=%s&country=%s' % (self.api_key, limit, country)

        result = self.adapter.get_path(path)

        return result


    # Gets the latest movies in theaters
    def in_theaters(self, page_limit=u'16', page=u'1', country=u'us'):
        path = self.base_url + u'lists/movies/in_theaters.json?apikey=%s&page_limit=%s&page=%s&country=%s' % (self.api_key, page_limit, page, country)
        print path

        result = self.adapter.get_path(path)

        return result


    # Get movie opening information
    def opening(self, limit=u'16', country=u'us'):
        path = self.base_url + u'lists/movies/in_theaters.json?apikey=%s&limit=%s&country=%s' % (self.api_key, limit, country)

        result = self.adapter.get_path(path)

        return result


    # Gets upcoming movies
    def upcoming(self, page_limit=u'16', page=u'1', country=u'us'):
        path = self.base_url + u'lists/movies/in_theaters.json?apikey=%s&page_limit=%s&page=%s&country=%s' % (self.api_key, page_limit, page, country)

        result = self.adapter.get_path(path)

        return result
Exemplo n.º 12
0
def gesture():
    data = json.loads(request.data)
    x = data['x']
    y = data['y']
    action = json.loads(data['action'])

    if matrix != None:
        coords = convert_coords(matrix, x, y)
        Adapter.send_gesture(coords[0] * 222 / 275, coords[1], action)
        return jsonify(result='ok')
    else:
        return jsonify(result='cannot draw points'), 404
Exemplo n.º 13
0
def test_service():
    '''should had paired first'''
    def device_discover_services(device):
        # discovery services
        services = device.discover_services()
        import re
        for key in services.keys():
            p = re.compile(">.*?<")
            xml = p.sub("><", services[key].replace("\n", ""))
            print "[ 0x%5x ]" % (key)
            print xml
            print

    def device_get_services(device):
        # get services
        from device_service import DeviceService
        from utils import bluetooth_uuid_to_string

        for serv in device.get_services():
            service = DeviceService(serv)
            uuid = service.get_uuid()
            print "uuid:%s" % uuid
            print bluetooth_uuid_to_string(uuid)

    def device_get_uuids(device):
        from utils import bluetooth_uuid_to_string
        for uuid in device.get_uuids():
            print uuid
            print bluetooth_uuid_to_string(uuid)

    from manager import Manager
    from adapter import Adapter
    from device import Device

    manager = Manager()
    adapter = Adapter(manager.get_default_adapter())
    device = Device(adapter.get_devices()[0])
    if adapter.get_devices():
        device = Device(adapter.get_devices()[0])
    else:
        print "after paired, should exists devices"

    print "device_get_services"
    device_get_services(device)
    print "device_discover_services"
    device_discover_services(device)
    print "device_get_uuids"
    device_get_uuids(device)

    mainloop = gobject.MainLoop()
    mainloop.run()
Exemplo n.º 14
0
def test_service():
    '''should had paired first'''
    def device_discover_services(device):
        # discovery services
        services = device.discover_services()
        import re
        for key in services.keys():
            p = re.compile(">.*?<")
            xml = p.sub("><", services[key].replace("\n", ""))
            print "[ 0x%5x ]" % (key)
            print xml
            print

    def device_get_services(device):
        # get services
        from device_service import DeviceService
        from utils import bluetooth_uuid_to_string

        for serv in device.get_services():
            service = DeviceService(serv)
            uuid = service.get_uuid()
            print "uuid:%s" % uuid
            print bluetooth_uuid_to_string(uuid)

    def device_get_uuids(device):
        from utils import bluetooth_uuid_to_string
        for uuid in device.get_uuids():
            print uuid
            print bluetooth_uuid_to_string(uuid)

    from manager import Manager
    from adapter import Adapter
    from device import Device

    manager = Manager()
    adapter = Adapter(manager.get_default_adapter())
    device = Device(adapter.get_devices()[0])
    if adapter.get_devices():
        device = Device(adapter.get_devices()[0])
    else:
        print "after paired, should exists devices"

    print "device_get_services"
    device_get_services(device)
    print "device_discover_services"
    device_discover_services(device)
    print "device_get_uuids"
    device_get_uuids(device)

    mainloop = gobject.MainLoop()
    mainloop.run()
Exemplo n.º 15
0
    def __init__(self, name=DEFAULT_NAME, topic=None, message_type=None, sub_topic=None, sub_message_type=None,
                 queue_size=10, **kwargs):
        Adapter.__init__(self, name, **kwargs)

        msg_type_class = utils.attempt_import(message_type, _myvars=vars())
        self._js_publisher = ROSPublisher(name=name, topic=topic, message_type=msg_type_class, queue_size=queue_size,
                                          **kwargs)

        if sub_topic is not None and sub_message_type is not None:
            sub_msg_type_class = utils.attempt_import(sub_message_type, _myvars=vars())
            self._js_subscriber = rospy.Subscriber(sub_topic, sub_msg_type_class,
                                                   self.callback) if sub_topic is not None else None
        self._js = None
        self._new_js = JointState()
Exemplo n.º 16
0
    def __init__(self):
        self.settings = Settings()
        self.adapter = Adapter(self)
        self.project = Project(self)
        self.gui = Gui(self)
        self.file_manager = FileManager(self)
        self.terminal = Terminal(self)

        self.function_queue = queue.Queue()
        self.work_thread = threading.Thread(target=self.execute_functions)
        self.work_thread.daemon = True
        self.work_thread.start()
        self.measuring = False
        self.gui_thread_is_free = True
Exemplo n.º 17
0
def background():
    if 'img' in request.files:
        print 'get bg-image file'
        #request.files['img'].save('file.jpg')
        img = request.files['img'].read()
    elif request.data:
        print 'get bg-base64 image'
        data = json.loads(request.data)
        img = grab_image(data['img'])
    else:
        print 'no image'
        return jsonify(result='empty request'), 500

    Adapter.send_background(img)
    return jsonify(result='bg updated'), 200
Exemplo n.º 18
0
def getAdapter():
    parser = argparse.ArgumentParser(
        description=
        'A supervised machine learning approach using SVM to diagnose patients with breast cancer.'
    )

    parser.add_argument('--kernel',
                        dest='kernel',
                        choices=['linear', 'rbf'],
                        type=str,
                        default=DEFAULT_KERNEL,
                        help='Select Kernel of SVM')

    # parser.add_argument('-cv', dest='crossVal', type=int, default=DEFAULT_CROSSVAL, help='Select Cross Validation Value')

    # parser.add_argument('--train', dest='train', default=DEFAULT_TRAIN, type=bool, help='Enable or disable the training of the model')

    parser.add_argument(
        '--plot',
        dest='turnPlot',
        default=DEFAULT_PLOT,
        type=bool,
        help='Turn on the plot (Test erros x C panalty parameter)')
    parser.add_argument('-i',
                        dest='interactions',
                        default=DEFAULT_INTER,
                        type=int,
                        help='Set numbers of interactions for plot')

    args = parser.parse_args()

    adapter = Adapter(args.kernel, args.turnPlot, args.interactions)

    return adapter
Exemplo n.º 19
0
def call_adapter():
    # this is where the node would call the external adapter.
    data = request.get_json()
    if data == '':
        data = {}
    adapter = Adapter(data)
    return jsonify(adapter.result)
Exemplo n.º 20
0
def call_adapter():
    data = request.get_json()
    if data == '':
        data = {}
    adapter = Adapter(data)
    # print(jsonify(adapter.result))
    return jsonify(adapter.result)
Exemplo n.º 21
0
def getAdapter():

    parser = argparse.ArgumentParser(
        description=
        'An Artificial Neural Network model comparison using MLP and FBR to recognise spam.'
    )

    parser.add_argument('--algorithm',
                        dest='algorithm',
                        choices=['mlp', 'fbr'],
                        type=str,
                        default=DEFAULT_ALGORITHM,
                        help='Select Learning Algorithm')
    #
    # parser.add_argument('-cv', dest='crossVal', type=int, default=DEFAULT_CROSSVAL, help='Select Cross Validation Value')
    #
    # parser.add_argument('-n', dest='number_of_trees', type=int, default=DEFAULT_NUMBER_OF_TREES, help='Number of trees in forest')
    #
    # parser.add_argument('--train', dest='train', default=DEFAULT_TRAIN, type=bool, help='Enable or disable the training of the model')
    #
    # parser.add_argument('--plot', dest='confPlot', default=DEFAULT_PLOT ,type=bool, help='Change how confusion matrices are plot.')
    #
    # parser.add_argument('-b', dest='best', default=DEFAULT_BEST ,type=bool, help='Use only the 5 best features')
    #
    args = parser.parse_args()
    #
    adapter = Adapter(args.algorithm)

    return adapter
Exemplo n.º 22
0
 def __call__(self, resourceName):
     handle = self._factoryFunction(resourceName)
     if self._useLegacy:
         print('using legacy library.')
         return Adapter(handle)
     else:
         return alternativeLibrary.FileObject(handle)
Exemplo n.º 23
0
 def pay(self, type: str):
     if type == 'classic':
         print('Tarjeta Classic: Pagando sin ningún tipo de Seguridad')
     elif type in ('gold', 'black'):
         Adapter().pay(type)
     else:
         raise TypeError('card type value unknown')
Exemplo n.º 24
0
def main(fileHandle, useLegacyLib=False):
    if useLegacyLib:
        print('using legacy library.')
        fileObject = Adapter(fileHandle)
    else:
        fileObject = alternativeLibrary.FileObject(fileHandle)
    for data in fileObject:
        print(data)
Exemplo n.º 25
0
def call_adapter():
    if request.method == 'GET':
        return 'true'
    data = json.loads(request.data)
    if data == '':
        data = {}
    adapter = Adapter(data)
    return jsonify(adapter.result)
Exemplo n.º 26
0
def main():
    #plug in
    sockets = Socket()
    adapter = Adapter(sockets)
    kettle = ElectricKettle(adapter)

    kettle.boil()
    return 0
Exemplo n.º 27
0
def call_adapter():
    data = request.get_json()
    if data == '':
        data = {}
    app.logger.debug(data)
    adapter = Adapter(data)
    ret = jsonify(adapter.result)
    app.logger.debug(adapter.result)
    return ret
Exemplo n.º 28
0
 def test_structure_load(self):
     a = Adapter()
     p1 = Mock()
     p1.type = 'Integer'
     p2 = Mock()
     p2.type = 'Boolean'
     p3 = Mock()
     p3.type = 'Interface2.Struct2'
     a.structureParameters = Mock(return_value=[p1, p2, p3])
     i = Mock()
     i.name = 'Struct1'
     i.interface = Mock()
     i.interface.name = 'Interface1'
     Structure.structures = { 'Interface2.Struct2': None }
     s = Structure(a, i)
     s.load()
     a.structureParameters.assert_called_once_with(i)
     self.assertEqual(len(s.elements), 3)
Exemplo n.º 29
0
class Facade:
    def __init__(self):
        self._db = DataBase()
        self._analytics = Analytics()
        self._adapter = Adapter(self._analytics)

    def get_data(self) -> List[str]:
        data_from_db = self._db.get_from_db()
        result = self._adapter.analyze_data(data_from_db)
        return result
Exemplo n.º 30
0
def add(tup):
    entries, begin, end = tup
    adapter = Adapter()

    not_implemented_error_count = 0
    error = 0

    #print (begin,end)
    for entry in entries[begin : end]:
        try:
            adapter.insert(entry)
        except cql.apivalues.OperationalError:
           print sys.exc_info()
           print entry
           error += 1

    if not_implemented_error_count + error > 0:
        print begin, end, not_implemented_error_count, error

    adapter.close()
Exemplo n.º 31
0
 def EnumerateAdapters(self):
     """Enumerate all storage adapters on the system
     
     returns:
         An array of object paths for storage adapters
     """
     l = list()
     for i in self.iface.EnumerateAdapters():
         obj = Adapter(i)
         l.append(obj)
     return l
Exemplo n.º 32
0
def handle(event, context):
    body = event['body']
    if body == None:
        print("NONE")
    data = json.loads(event['body'])
    print(data)
    adapter = Adapter(data)
    return {
        "body": json.dumps(adapter.result, indent=2),
        "statusCode": 200,
        "headers": {
            "Content-Type": "application/json",
        }
    }
Exemplo n.º 33
0
 def test_interface_load(self):
     a = Adapter()
     a.enumerations = Mock(return_value=[1, 2])
     s1 = Mock()
     s1.name = 'name'
     s1.interface = Mock()
     s1.interface.name = 'name'
     a.structures = Mock(return_value=[s1])
     f1 = Mock()
     f1.type = 'notification'
     f2 = Mock()
     f2.name = 'method'
     f2.type = 'request'
     f3 = Mock()
     f3.name = 'method'
     f3.type = 'response'
     a.functions = Mock(return_value=[f1, f2, f3])
     i = Interface(a, None)
     i.load()
     a.enumerations.assert_called_once_with(None)
     a.structures.assert_called_once_with(None)
     a.functions.assert_called_once_with(None)
     self.assertEqual(len(i.elements), 5)
Exemplo n.º 34
0
class Controller:

    def __init__(self):
        self.adapter = Adapter()

    def insert(self, entry):
        self.adapter.insert(entry)

    def get(self, key):
        m = re.search('(\w+)-(\d+)', key)
        if m:
            key = m.groups()[0]
            extra = int(m.groups()[1])
            entry = self.adapter.get(key, extra)
            return [entry] if entry else None

        entries = self.adapter.getmany(key)
        if not entries:
            return None
        if len(entries) is 1:
            entries[0]['extra'] = None
            return [entries[0]]
        return entries
Exemplo n.º 35
0
def getAdapter():
    parser = argparse.ArgumentParser(
        description=
        'A KNN and LDA approach for recognising handwriting numbers using the MNIST Dataset.'
    )

    parser.add_argument('--algorithm',
                        dest='algorithm',
                        choices=['knn', 'lda', 'both'],
                        type=str,
                        default=DEFAULT_ALGORITHM,
                        help='Select Learning Algorithm')

    parser.add_argument('-k',
                        dest='k',
                        type=int,
                        default=DEFAULT_K_VALUE,
                        help='K value for the KNN Algorithm')

    parser.add_argument('--train',
                        dest='train',
                        default=DEFAULT_TRAIN,
                        type=bool,
                        help='Enable or disable the training of the model')

    parser.add_argument('--proc',
                        dest='proc',
                        default=DEFAULT_PROCESSING,
                        choices=['binaryLines', 'normalLines', 'None'],
                        type=str,
                        help='Type of image processing before training')

    parser.add_argument('--confplot',
                        dest='confPlot',
                        default=DEFAULT_PLOT,
                        choices=['False', 'normalized', 'cases'],
                        type=str,
                        help='Change how confusion matrice are plot.')

    args = parser.parse_args()

    adapter = Adapter(args.algorithm, args.k, args.train, args.proc,
                      args.confPlot)

    return adapter
Exemplo n.º 36
0
def getAdapter():
    parser = argparse.ArgumentParser(description='A Random Forests approach for plant species recognition.')

    parser.add_argument('--algorithm', dest='algorithm', choices=[''], type=str, default=DEFAULT_ALGORITHM, help='Select Learning Algorithm')

    parser.add_argument('-cv', dest='crossVal', type=int, default=DEFAULT_CROSSVAL, help='Select Cross Validation Value')
    
    parser.add_argument('-n', dest='number_of_trees', type=int, default=DEFAULT_NUMBER_OF_TREES, help='Number of trees in forest')

    parser.add_argument('--train', dest='train', default=DEFAULT_TRAIN, type=bool, help='Enable or disable the training of the model')

    parser.add_argument('--plot', dest='confPlot', default=DEFAULT_PLOT ,type=bool, help='Change how confusion matrices are plot.')

    parser.add_argument('-b', dest='best', default=DEFAULT_BEST ,type=bool, help='Use only the 5 best features')

    args = parser.parse_args()
    
    adapter = Adapter(args.crossVal,
                      args.confPlot,
                      args.number_of_trees,
                      args.best)

    return adapter
Exemplo n.º 37
0
 def __init__(self):
     self.adapter = Adapter()
     self.seconds = 0
     self.opcao = 0
     self.filepath = ''
Exemplo n.º 38
0
    @dbus.service.method("org.bluez.Agent",
                         in_signature="", out_signature="")
    def Cancel(self):
        print("Cancel")

def create_device_reply(device):
    print("New device (%s)" % (device))
    mainloop.quit()

def create_device_error(error):
    print("Creating device failed: %s" % (error))
    mainloop.quit()


if __name__ == '__main__':
    dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)

    bus = dbus.SystemBus()
    path = "/test/agent"

    agent = Agent(path, bus)

    from manager import Manager
    from adapter import Adapter

    adptr = Adapter(Manager().get_default_adapter())
    adptr.register_agent(path, "")

    mainloop = gobject.MainLoop()
    mainloop.run()
Exemplo n.º 39
0
def test_passive():

    def on_device_found(adapter, address, values):
        print "on device found"
        print "adapter",  adapter
        print "address", address
        print "values", values

    def on_device_created(adapter, dev_path):
        print "on device created"
        print "adapter" ,adapter
        print "dev_path", dev_path

    from manager import Manager
    from adapter import Adapter

    manager = Manager()
    adapter = Adapter(manager.get_default_adapter())
    adapter.set_powered(True)
    adapter.set_discoverable(True)
    adapter.set_pairable(True)
    # print "adapter properties:\n %s" % adapter.get_properties()
    adapter.connect("device-found", on_device_found)
    adapter.connect("device-created", on_device_created)

    mainloop = gobject.MainLoop()
    mainloop.run()
Exemplo n.º 40
0
def test_phone():
    '''must had paired first, use xiaomi for test'''

    def get_device_supported_services(device):
        services = []
        from utils import bluetooth_uuid_to_string
        for uuid in device.get_uuids():
            if bluetooth_uuid_to_string(uuid) != None:
                services.append(bluetooth_uuid_to_string(uuid))
            else:
                continue

        return services

    def send_file(device, files):
        ###please see the example in obex_agent.py
        pass

    def browse_device(device):
        ###please see the example in utils.py
        pass

    ### test phone audio
    def connect_phone_audio(device):
        from device import AudioSource
        from device import Control

        ###AudioSource
        if "AudioSource" not in get_device_supported_services(device):
            print "device not support AudioSource"
            return

        audiosource = AudioSource(device.object_path)
        ###when connect, voice switch from phone to my'pc
        if audiosource.get_state() == "disconnected":
            audiosource.connect()

        ###Control
        if "A/V_RemoteControlTarget" not in get_device_supported_services(device):
            print "device not support A/V control"
            return

        control = Control(device.object_path)
        if not control.get_connected():
            return

        for i in range(10):
            control.volume_up()

        ###HandsFreeGateway
        from device import HandsfreeGateway
        from handsfree_agent import HandsfreeAgent
        if not "HandsfreeAudioGateway" in get_device_supported_services(device):
            print "device not support handsfree gateway"
            return

        hfg = HandsfreeGateway(device.object_path)
        HandsfreeAgent("/org/bluez/HandsfreeAgent")
        hfg.register_agent("/org/bluez/HandsfreeAgent")

        if hfg.get_state() == "disconnected":
            hfg.connect()

    def connect_phone_network(adapter, device):
        '''for my phone, it's nap'''
        from device import Network
        from adapter import NetworkServer

        if "NAP" not in get_device_supported_services(device):
            print "device not support NAP"
            return

        network = Network(device.object_path)
        server = NetworkServer(adapter.object_path)

        server.register("nap", "wlan0")

        network.connect("nap")

    def connect_phone_serial(adapter, device):
        pass

    from manager import Manager
    from adapter import Adapter
    from device import Device

    manager = Manager()
    adapter = Adapter(manager.get_default_adapter())
    if adapter.get_devices():
        device = Device(adapter.get_devices()[0])
    else:
        print "after paired, should exists devices"

    send_file(device, ["/home/zhaixiang/debug"])
    #connect_phone_audio(device)
    # connect_phone_network(adapter, device)

    mainloop = gobject.MainLoop()
    mainloop.run()
Exemplo n.º 41
0
class Command():

    def __init__(self):
        self._command = None
        self._api = ApiTwip(keys.CONSUMER_KEY, keys.CONSUMER_SECRET)
        self._adapter = Adapter()
        self._timeline = None

    def dispatch(self, command):
        self._command = command

        if self._command in COMMAND_TIMELINE:
            content = self._api.get_home_time_line()  # pragma: no cover
            if content:
                self._timeline = self._adapter.create_timeline_object(content)  # pragma: no cover

                cli_adapter = CliAdapter(self._timeline)  # pragma: no cover
                cli_adapter.get_statuses()  # pragma: no cover

        elif self._command in COMMAND_VERSION:
            print version  # pragma: no cover

        elif self._command in COMMAND_EXIT:
            pass  # pragma: no cover

        elif self._command in COMMAND_HELP:
            print COMMAND_HELP_TEXT  # pragma: no cover

        elif self._command in COMMAND_MENTIONS:
            content = self._api.get_mentions()  # pragma: no cover

            if content:
                self._timeline = self._adapter.create_timeline_object(content)  # pragma: no cover

                cli_adapter = CliAdapter(self._timeline)  # pragma: no cover
                cli_adapter.get_statuses()

        elif self._command in COMMAND_FV:
            content = self._api.get_favs()  # pragma: no cover
            if content:
                self._timeline = self._adapter.create_timeline_object(content)  # pragma: no cover

                cli_adapter = CliAdapter(self._timeline)  # pragma: no cover
                cli_adapter.get_statuses()  # pragma: no cover

        elif self._command in COMMAND_DM:
            content = self._api.get_direct_messages()  # pragma: no cover
            if content:
                self._timeline = self._adapter.create_dm_timeline_object(content)  # pragma: no cover

                cli_adapter = CliAdapter(self._timeline)  # pragma: no cover
                cli_adapter.get_direct_messages()  # pragma: no cover

        elif len(self._command) > 2:
            com = self._command[:2].strip()
            text = self._command[2:].strip()
            self._send_info(com, text)

        else:
            print COMMAND_HELP_TEXT

    def _send_info(self, com, text):
        if com in COMMAND_UPDATE:
            self._api.update_status(text)

        elif com in COMMAND_REPLY:
            if not self._timeline:
                print 'Timeline is empty. Execute first "ht" or "m" command'
                return

            cli_adapter = CliAdapter(self._timeline)

            c_id = text[:2].strip()
            text = text[2:]
            if not reg_exp_only_numbers(c_id):
                print 'Bad reply id. Only numbers between 0 and 19'
                return

            c_id = int(c_id)
            if c_id < 0 or c_id > 19:
                print 'Bad reply id. Range: 0..19'
                return

            status = cli_adapter.get_status_from_id(c_id)
            self._api.update_status(text=text, reply_to=status.id_str)

        elif com in COMMAND_RT:
            c_id = self._command[2:].strip()

            if not reg_exp_only_numbers(c_id):
                print 'Bad tweet id. Range 0..19'
                return

            if not self._timeline:
                print 'Timeline is empty. Execute first "ht" or "m" command'
                return

            c_id = int(c_id)
            if c_id < 0 or c_id > 19:
                print 'Bad reply id. Range: 0..19'
                return

            cli_adapter = CliAdapter(self._timeline)
            status = cli_adapter.get_status_from_id(c_id)
            self._api.retweet(tweet_id=status.id_str)

        elif com in COMMAND_FV:
            if not self._timeline:
                print 'Timeline is empty. Execute first "ht" or "m" command'
                return

            cli_adapter = CliAdapter(self._timeline)
            c_id = text[:2].strip()
            text = text[2:]
            if not reg_exp_only_numbers(c_id):
                print 'Bad favorite id. Only numbers between 0 and 19'
                return

            c_id = int(c_id)
            if c_id < 0 or c_id > 19:
                print 'Bad favorite id. Range: 0..19'
                return

            status = cli_adapter.get_status_from_id(c_id)
            self._api.create_fav(tweet_id=status.id_str)

        elif com in COMMAND_DM:
            temp_text = text.split(' ')

            if len(temp_text) < 2:
                print 'Ups! Something wrong with the dm command. Did you write the @<screen user name> and the <text>?'
                return

            if -1 == temp_text[0].find('@') or len(temp_text[0]) < 2:
                print 'I don\'t know who I will send the message. Please add the "@" to the twitter user name'
                return

            screen_name = temp_text[0].strip()
            screen_name = screen_name[1:]
            text = text[len(screen_name)+1:].strip()

            self._api.send_direct_message(text=text, screen_name=screen_name)
Exemplo n.º 42
0
 def __init__(self):
     self.adapter = Adapter()
Exemplo n.º 43
0
 def test_cat_adapter_shall_make_noise(self):
     cat = Cat()
     cat_adapter = Adapter(cat, make_noise=cat.meow)
     noise = cat_adapter.make_noise()
     expected_noise = "meow!"
     self.assertEqual(noise, expected_noise)
Exemplo n.º 44
0
 def test_dog_adapter_shall_make_noise(self):
     dog = Dog()
     dog_adapter = Adapter(dog, make_noise=dog.bark)
     noise = dog_adapter.make_noise()
     expected_noise = "woof!"
     self.assertEqual(noise, expected_noise)
Exemplo n.º 45
0
def test_found_pair():
    '''test_found_pair'''
    def on_device_found(adapter, address, values):
        print "address of found device \n %s " % address
        if address not in adapter.get_address_records():
            print "values of found device \n %s " % values
            print "now create device"
            return adapter.create_device(address)
        else:
            # print "device already exists"
            if adapter.get_discovering():
                print "stop discovery"
                adapter.stop_discovery()
            pass

    def on_device_created(adapter, dev_path):
        print "path of created device \n %s" % dev_path
        device = Device(dev_path)
        pair(device)

    def pair(device):
        from agent import Agent
        path = "/org/bluez/agent"
        agent = Agent(path)
        agent.set_exit_on_release(False)
        device.set_trusted(True)
        if not device.get_paired():
            print "create paired device"
            adapter.create_paired_device(device.get_address(),
                                         path,
                                         "DisplayYesNo",
                                         create_paired_reply,
                                         create_paired_error)

    def create_paired_reply(device):
        print "succeed paired device (%s)" % (device)


    def create_paired_error(error):
        print "paired device failed: %s" % (error)

    from manager import Manager
    from adapter import Adapter
    from device import Device

    manager = Manager()
    adapter = Adapter(manager.get_default_adapter())
    adapter.set_powered(True)
    adapter.set_discoverable(True)
    adapter.set_pairable(True)
    # print "adapter properties:\n %s" % adapter.get_properties()
    adapter.connect("device-found", on_device_found)
    adapter.connect("device-created", on_device_created)

    for dev in  adapter.get_devices():
        print "DEBUG", dev
        adapter.remove_device(dev)
    else:
        pass

    print "begin discovery \n"
    adapter.start_discovery()

    mainloop = gobject.MainLoop()
    mainloop.run()
Exemplo n.º 46
0
 def __init__(self):
     self._command = None
     self._api = ApiTwip(keys.CONSUMER_KEY, keys.CONSUMER_SECRET)
     self._adapter = Adapter()
     self._timeline = None
Exemplo n.º 47
0
class Gui:
    def __init__(self):
        self.adapter = Adapter()
        self.seconds = 0
        self.opcao = 0
        self.filepath = ''
    def run(self):
        app = Tk()
        app.title("Ajustador de Legendas")
        app.geometry('380x180')

        self.labelText2 = StringVar()
        self.labelText2.set("")
        label2 = Label(app, textvariable=self.labelText2, height=2, fg='blue')
        label2.pack(side='top', padx=1, pady=1)

        labelText = StringVar()
        labelText.set("Segundos")
        label1 = Label(app, textvariable=labelText, height=2)
        label1.pack()

        custName= StringVar(None)
        self.entrada = Entry(app, textvariable=custName)
        self.entrada.pack()

        self.var = IntVar()

        R1 = Radiobutton(app, text="Atrasar legenda", variable=self.var, value=1,command=self.sel)
        R1.pack()

        R2 = Radiobutton(app, text="Adiantar legenda", variable=self.var, value=2,command=self.sel)
        R2.pack()

        button1 = Button(app, text="Adaptar", width=10, command = self.changeLabel)
        button1.pack(side='bottom', padx=10, pady=10)
        
        menubar = Menu(app)
        filemenu = Menu(menubar, tearoff=0)
        filemenu.add_command(label="Selecionar Legenda", command=self.filechoose)

        filemenu.add_separator()

        filemenu.add_command(label="Exit", command=app.quit)
        menubar.add_cascade(label="Arquivo", menu=filemenu)
        
        aboutmenu = Menu(menubar, tearoff=0)

        aboutmenu.add_command(label="O App", command=self.newWindow)
        menubar.add_cascade(label="Sobre", menu=aboutmenu)

        app.config(menu=menubar)

        app.mainloop()
    def changeLabel(self):
        try:
            stringInput = self.entrada.get()
            self.seconds = int(stringInput)
            if self.opcao == 0:
                self.notSelected()
            else:
                self.adapter.adjust(self.filepath, self.seconds,self.opcao)
                self.pronto()
        except ValueError:
            self.wrongValue()
        except IOError:
            #traceback.print_exc()
            self.missingFile()
        #except:
            #self.unknowError()
        return

    def sel(self):
        self.opcao = self.var.get()
    def pronto(self):
        tkMessageBox.showinfo("Status", "Pronto!")
    def missingFile(self):
        tkMessageBox.showinfo("Status", "Arquivo nao selecionado!")
    def wrongValue(self):
        tkMessageBox.showinfo("Status", "Por favor insira apenas numeros!")
    def notSelected(self):
        tkMessageBox.showinfo("Status", "Selecione adiantar ou atrasar a legenda.")
    def unknowError(self):
        tkMessageBox.showinfo("Status", "Erro desconhecido!")
   
    def filechoose(self):
        self.filepath = askopenfilename()
        if self.filepath != '':
            self.labelText2.set(ntpath.basename(self.filepath))
    def newWindow(self):
        top = Toplevel()
        top.title("O App")
        top.geometry('380x80')
        labelText = StringVar()
        labelText.set("Aplicativo desenvolvido em Python por Estevao Fonseca")
        label1 = Label(top, textvariable=labelText, height=2)
        label1.pack(side='top', padx=10, pady=15)

        top.mainloop()
Exemplo n.º 48
0
 def test_human_adapter_shall_make_noise(self):
     human = Human()
     human_adapter = Adapter(human, make_noise=human.speak)
     noise = human_adapter.make_noise()
     expected_noise = "'hello'"
     self.assertEqual(noise, expected_noise)
Exemplo n.º 49
0
 def test_car_adapter_shall_make_very_loud_noise(self):
     car = Car()
     car_adapter = Adapter(car, make_noise=car.make_noise)
     noise = car_adapter.make_noise(10)
     expected_noise = "vroom!!!!!!!!!!"
     self.assertEqual(noise, expected_noise)
Exemplo n.º 50
0
def test_adapter_prop():
    from manager import Manager
    from adapter import Adapter
    manager = Manager()
    adapter = Adapter(manager.get_default_adapter())

    from device import Device
    device_address = Device(adapter.get_devices()[0]).get_address()
    print "find device:\n    %s" % adapter.find_device(device_address)
    print "remove device:\n    %s" % adapter.remove_device(adapter.find_device(device_address))
    # print "create device:\n    %s" % adapter.create_device(device_address)

    print "get devices:\n    %s" % adapter.get_devices()

    adapter.set_name("Long Wei's PC")
    print "get name:\n    %s" % adapter.get_name()

    adapter.set_powered(True)
    print "get powered:\n    %s" % adapter.get_powered()

    adapter.set_discoverable(True)
    print "get discoverable:\n    %s" % adapter.get_discoverable()

    print "get discovering:\n    %s" % adapter.get_discovering()

    adapter.set_discoverable_timeout(120)
    print "get discoverable_timeout:\n    %s" % adapter.get_discoverable_timeout()

    adapter.set_pairable(True)
    print "get pairable:\n    %s" % adapter.get_pairable()

    adapter.set_pairable_timeout(180)
    print "get pairable timeout:\n    %s" % adapter.get_pairable_timeout()

    print "get class:\n    %s" % adapter.get_class()
    print "get address:\n    %s" % adapter.get_address()
    print "get uuids:\n    %s" % adapter.get_uuids()
Exemplo n.º 51
0
 def __init__(self, base_url=u'http://api.rottentomatoes.com/api/public/v1.0/', api_key=u''):
     self.base_url = base_url
     self.api_key = api_key
     self.adapter = Adapter(base_url)
Exemplo n.º 52
0
    def s_connect(self, pattern):
        return self.dbus_method("Connect", pattern)

    def connect_fd(self, pattern):
        return self.dbus_method("ConnectFD", pattern)

    def s_disconnect(self, device):
        return self.dbus_method("Disconnect", device)


if __name__ == "__main__":
    from manager import Manager
    from adapter import Adapter

    adapter = Adapter(Manager().get_default_adapter())

    device = Device(adapter.get_devices()[0])

    # print "Name:\n    %s" % device.get_name()
    # device.set_alias("Long's Phone")
    # print "Alias:\n    %s" % device.get_alias()
    # print "Paired:\n    %s" % device.get_paired()
    # print "Adapter:\n   %s" % device.get_adapter()
    # print "Connected:\n   %s" % device.get_connected()
    # print "UUIDs:\n   %s" % device.get_uuids()
    # print "Address:\n   %s" % device.get_address()
    # print "Find Device:\n   %s" %adapter.find_device(device.get_address())
    # print "Services:\n   %s" % device.get_services()
    # print "Class:\n   %s" % device.get_class()
    # device.set_blocked(True)