View difference between Paste ID: dRd37jfK and 7VSpinAz

-#!/usr/bin/python
+#!/usr/bin/env python
-##### PYADB v1.3
+### PYADB (Python 2.7 Library)
-##### RELEASE DATE: AUGUST 26, 2014
+##### VERSION: 1.3.1
 ##### RELEASE DATE: SEPTEMBER 13, 2014
-##### unfinished library to port ADB and FASTBOOT functions to PYTHON
+
 ##### DESCRIPTION: simple library to port ADB and FASTBOOT functions to PYTHON
-##### that's also here on pastebin: http://pastebin.com/y511TjV1
+#####
-##### check out the README file too! http://notworth.it/opo/README
+
 ##### 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.
 ##### but i wanted one that worked for me. if it works for you, go ahead and use it too!
-##### feel free to share, modify, whatever.
+##################################################
-##### i don't care if you credit me, though that'd be nice.
+##################################################
-##### to really show your appreciation, you can buy my EP instead!
+##### USER LICENSE AGREEMENT & DISCLAIMER
 ##### copyright (C) 2014  vvn <vvn@eudemonics.org>
 #####
 ##### This program is FREE software: you can use it, redistribute it and/or modify
 ##### it as you wish. Copying and distribution of this file, with or without modification,
 ##### are permitted in any medium without royalty provided the copyright
-import os, subprocess, sys
+##### notice and this notice are preserved. This program is offered AS-IS,
 ##### WITHOUT ANY WARRANTY; without even the implied warranty of
 ##### MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 ##### GNU General Public License for more details.
 #####
 ##### For more information, please refer to the "LICENSE AND NOTICE" file that should
 ##### accompany all official download releases of this program.
 ##################################################
 ##################################################
 ##### don't ask about the arbitrary versioning. i am totally making this shit up.
 ##### getting credited for my work is nice. so are donations.
 ##### BTC: 1M511j1CHR8x7RYgakNdw1iF3ike2KehXh
 ##### https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=26PWMPCNKN28L
 ##### but to really show your appreciation, you should buy my EP instead!
 ##### you can stream and purchase it at: dreamcorp.bandcamp.com
 ##### (you might even enjoy listening to it)
 ##### questions, comments, feedback, bugs, complaints, death threats, marriage proposals?
 ##### contact me at:
 ##### vvn (at) eudemonics (dot) org
 ##### latest version will always be available HERE: http://notworth.it/opo/pyadb.py
 
 import os, subprocess, sys, datetime
 from subprocess import call, Popen, PIPE
 
 class pyADB(object):
 
    # adb commands
    def call_adb(self, command):
       response = ''
       command_text = 'adb %s' % command
       # command_text = r'"%s"' % command_text
       command_text = command_text + '; exit 0'
       # output = Popen(command_text, shell=True, stdout=PIPE, stderr=PIPE, stdin=PIPE)
       output = subprocess.check_call(command_text, shell=True, stderr=subprocess.STDOUT)
       return output
       # response = output.communicate()
       # return response
 
    # fastboot commands
    def call_fastboot(self, command):
       response = ''
       command_text = 'fastboot %s' % command
       output = Popen(command_text, shell=True, stdout=PIPE, stderr=PIPE, stdin=PIPE)
       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
       result = self.call_adb(command)
       return result or None
       pass
 
    # check for any fastboot device
    def fastbootany(self, device_id):
       command = 'devices -s %s' % device_id
       result = self.call_fastboot(command)
       return result or None
       pass
 
    # return list of attached devices
    def attached_devices(self):
       command_text = "adb devices -l"
       output = Popen(command_text, shell=True, stdout=PIPE, stderr=PIPE, stdin=PIPE)
       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):
       command = "uninstall %s" % path_to_app
       if 'keep' in args:
-      command = "push -p %s %s" % (local, remote)
+
       result = self.call_adb(command)
       return result
 
    # reboot
    def reboot(self, rb_type):
-      command = "pull -p %s %s" % (remote, local)
+
       if 'recovery' in rb_type:
          command += " recovery"
       elif 'bootloader' in rb_type:
          command += " bootloader"
-   def sync(self, **directory):
+
       return result
-      if directory is not None:
+
-         command = "sync %s" % directory
+
    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 " + r'"%s"' % local
-   def backup(self, backupfile):
+      command += " " + r'"%s"' % remote
-      command = "backup -f %s -all" % backupfile
+
       return result
 
    # pull files
    def pull(self, remote, local):
       command = "pull -p " + r'"%s"' % remote
       command += " " + r'"%s"' % local
       result = self.call_adb(command)
       return result
 
    # sync
    def sync(self, local, directory):
       command = "sync"
       if "none" in local:
          if "none" not in directory:
             command = "sync " + directory
       elif "none" not in local:
          command = "-p " + local + " sync"
          if "none" not in directory:
             command = "-p " + local + " sync " + directory
       else:
          command = "sync"
       result = self.call_adb(command)
       return result
 
    # shell command
    def shell(self, shellcmd):
       command = "shell " + shellcmd
       result = self.call_adb(command)
       return result
 
    # backup device
    def backup(self, backupfile, backapk, backobb, backshared, backall, backsys):
       command = "adb backup -f %s" % backupfile
       cmdapk = " -noapk"
       cmdshared = " -noshared"
       cmdall = ""
       cmdsys = " -system"
       if "apk" in backapk:
          cmdapk = " -apk"
       else:
          cmdapk = " -noapk"
       if "obb" in backobb:
          cmdobb = " -obb"
       else:
          cmdobb = ""
       if "shared" in backshared:
          cmdshared = " -shared"
-      command = "bugreport"
+
          cmdshared = " -noshared"
       if "all" in backall:
          cmdall = " -all"
       else:
          cmdall = ""
       if "sys" not in backsys:
          cmdsys = " -nosystem"
       else:
          cmdsys = " -system"
       command = 'adb backup -f ' + backupfile + cmdapk + cmdobb + cmdshared + cmdall + cmdsys
       if "full" in backall:
          command = 'adb backup -apk -shared -all -system -f ' + backupfile
       print(command)
       output = subprocess.check_call(command, shell=True, stdout=PIPE)
       return output
 
    # 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 = "sideload %s" % file
       result = self.call_adb(command)
       return result
 
    # bugreport
    def bugreport(self):
       filename = "bugreport-" + str(datetime.date.today()) + ".txt"
       command = "adb bugreport > " + filename
       output = Popen(command, shell=True, stdout=PIPE, stderr=PIPE, stdin=PIPE)
       response = output.communicate()
       print("bug report saved as: " + filename)
       return response
 
    # logcat
    def logcat(self):
       command = "adb logcat"
       output = Popen(command, shell=True, stdout=PIPE, stderr=PIPE, stdin=PIPE)
       response = output.communicate()
       return response
 
    # 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
 
    # services list
    def listsvc(self):
       command = "shell su -c service list"
       result = self.call_adb(command)
       return result