View difference between Paste ID: 7VSpinAz and g2Z08JN1

 #!/usr/bin/python
-##### PYADB v1.0 STABLE!
+##### PYADB v1.3
-##### lazy, unfinished library to port ADB and FASTBOOT functions to PYTHON
+##### RELEASE DATE: AUGUST 26, 2014
-##### author: vvn
+##### AUTHOR: vvn
-##### release date: august 18, 2014
+##### unfinished library to port ADB and FASTBOOT functions to PYTHON
 ##### for now it's a required companion to the half-assed one plus one toolkit.
-##### here is the half-assed one plus one toolkit: http://pastebin.com/ciAj8NJy
+##### that's also here on pastebin: http://pastebin.com/y511TjV1
-##### you need python 2.7 and the android SDK installed to run it. go to toolkit link above for download links.
+##### check out the README file too! http://notworth.it/opo/README
-##### this project is vaguely based on something i found on github but had way too many errors.
+##### this project is vaguely based on some github code i found that had too many errors.
 ##### i know it isn't anything new. i know it's probably been done better.
-##### i don't care if you credit me, it'd be nice. though i prefer you buy my EP instead to thank me. :)
+##### but i wanted one that worked for me. if it works for you, go ahead and use it too!
-##### you can stream and buy it here: dreamcorp.bandcamp.com
+
-##### questions, comments, feedback, bugs?
+##### i don't care if you credit me, though that'd be nice.
 ##### to really show your appreciation, you can buy my EP instead!
 ##### you can stream and purchase it at: dreamcorp.bandcamp.com
 ##### questions, comments, feedback, bugs, complaints, death threats, marriage proposals?
-import os, readline
+
-from subprocess import call
+
 
 import os, subprocess, sys
 from subprocess import call, Popen, PIPE
 
 class pyADB(object):
 
-      results = call(command_text, shell=True)
+   # adb commands
-      #while 1:
+
-      #  line = results.readline()
+
-      #  if not line: break
+
-      #  command_result += line
+      output = Popen(command_text, shell=True, stdout=PIPE, stderr=PIPE, stdin=PIPE)
-      return results
+      response = output.communicate()
       # response = output.stdout()
       return response
 
    # fastboot commands
-      results = call(command_text, shell=True)
+
-      return results
+
       command_text = 'fastboot %s' % command
       output = Popen(command_text, shell=True, stdout=PIPE, stderr=PIPE, stdin=PIPE)
-   def fastboot(self, device_id):
+      response, errors = output.communicate()[0][1]
       # response = output.stdout()
       return response
 
    # check for any ADB device
    def adbcallany(self, device_id):
       command = 'devices -s %s' % device_id
-      command = "devices -l"
+
       return result
       pass
 
    # check for any fastboot device
    def fastbootany(self, device_id):
       command = 'devices -s %s' % device_id
       result = self.call_fastboot(command)
-      command = "devices -l"
+
-      result = self.call_adb(command)
+
-      return result
+
    # return list of attached devices
    def attached_devices(self):
       command_text = "adb devices -l"
-      result = self.call_adb("get-state")
+      output = Popen(command_text, shell=True, stdout=PIPE, stderr=PIPE, stdin=PIPE)
-      return result or None
+      response = output.communicate()
       return response or None
 
       # result = self.call_adb(command)
       # devices = result.partition('\n')[2].replace('\n', '').split('\tdevice')
       # return [device for device in devices if len(device) > 2]
       # return result
 
    # fastboot return list of devices
    def fastboot_devices(self):
       command_text = 'fastboot devices'
       output = Popen(command_text, shell=True, stdout=PIPE, stderr=PIPE, stdin=PIPE)
       response = output.communicate()
       return response or None
       # command = "devices -l"
       # result = self.call_adb(command)
       # return result
 
    # get device state
    def get_state(self):
       results = ''
       command_text = 'adb get-state'
       output = Popen(command_text, shell=True, stdout=PIPE, stderr=PIPE, stdin=PIPE)
       response = output.communicate()
       return response or None
       #result = self.call_adb("get-state")
       #return result or None
 
    # install APK
    def install(self, path_to_app):
       command = "install %s" % path_to_app
       result = self.call_adb(command)
       return result
 
    # uninstall APK
    def uninstall(self, path_to_app, args):
-      result = self.call_adb("push -p %s %s" % (local, remote))
+
       if 'keep' in args:
          command = "uninstall -k %s" % path_to_app
       result = self.call_adb(command)
       return result
-      result = self.call_adb("pull -p %s %s" % (remote, local))
+
    # reboot
    def reboot(self, rb_type):
       command = "reboot"
       if 'recovery' in rb_type:
          command += " recovery"
-      if directory:
+
-         command = "sync " + directory
+
       result = self.call_adb(command)
       return result
 
    # fastboot reboot
    def fastreboot(self, rb_type):
       command = "reboot"
       if 'bootloader' in rb_type:
          command = "reboot-bootloader"
       result = self.call_fastboot(command)
       return result
 
    # push files
    def push(self, local, remote):
       command = "push -p %s %s" % (local, remote)
       result = self.call_adb(command)
       return result
 
    # pull files
    def pull(self, remote, local):
       command = "pull -p %s %s" % (remote, local)
       result = self.call_adb(command)
       return result
 
-      command = "boot %s" % boot_file
+
    def sync(self, **directory):
       command = "sync"
       if directory is not None:
          command = "sync %s" % directory
       result = self.call_adb(command)
-      command = "update %s" % update_file
+
 
    # shell command
    def shell(self, shellcmd):
       command = "shell " + shellcmd
       result = self.call_adb(command)
       return result
 
    # backup device
    def backup(self, backupfile):
       command = "backup -f %s -all" % backupfile
       result = self.call_adb(command)
       return result
 
    # restore device
    def restore(self, restorefile):
       command = "restore %s" % restorefile
       result = self.call_adb(command)
       return result
 
    # boot from image file
    def bootimg(self, boot_file):
       command = "boot " + boot_file
       result = self.call_fastboot(command)
       return result
 
    # install update ZIP
    def update(self, update_file):
       command = "update " + update_file
       result = self.call_fastboot(command)
       return result
 
    # fastboot flash image
    def flashf(self, type, file):
       command = "flash %s %s" % (type, file)
       result = self.call_fastboot(command)
       return result
 
    # unlock bootloader
    def unlockboot(self):
       command = "oem unlock"
       result = self.call_fastboot(command)
       return result
 
    # lock bootloader
    def lockboot(self):
       command = "oem lock"
       result = self.call_fastboot(command)
       return result
 
    # sideload installation
    def sideload(self, file):
-         command = "-w erase system"
+
       result = self.call_adb(command)
       return result
 
    # bugreport
    def bugreport(self):
       command = "bugreport"
       result = self.call_adb(command)
       return result
 
    # wipe/erase partitions
    def wipe(self, parts):
       command = "-w erase"
       if 'system' in parts:
          command = "erase system"
       elif 'all' in parts:
          command = "flashall"
       elif 'data' in parts:
          command = "erase data"
       elif 'cache' in parts:
          command = "erase cache"
       elif 'boot' in parts:
          command = "erase boot"
       elif 'recovery' in parts:
          command = "erase recovery"
       elif 'flashall' in parts:
          command = "flashall"
       else:
          command = "-w erase system"
       result = self.call_fastboot(command)
       return result