def check_platform():
  """Check the platform that script is running on.
  """
  if platform.startswith("win32") or platform.startswith("cygwin"):
    if version_info[0] < 3 and version_info[1] > 1:
      click.echo("Python version not supported, "
                 "Install python 3.x.x and try again")

   def __init__(self, headless = False):
      if "UNO_PATH" in os.environ:
         office = os.environ["UNO_PATH"]
      else:
         if platform.startswith("win"):
            # XXX
            office = ""
         else:
            # Lets hope that works..
            office = '/usr/bin'
      office = os.path.join(office, "soffice")
      if platform.startswith("win"):
          office += ".exe"

      self._pidfile = "/tmp/markup_renderer_OOinstance" #XXX Windows compat needed
      xLocalContext = uno.getComponentContext()
      self._resolver = xLocalContext.ServiceManager.createInstanceWithContext("com.sun.star.bridge.UnoUrlResolver", xLocalContext)
      self._socket = "name=markupRendererPipe"

      args = ["--invisible", "--nologo", "--nodefault", "--norestore", "--nofirststartwizard"]
      if headless:
         args.append("--headless")

      if platform.startswith("win"):
         cmdArray = ['"' + office + '"']
      else:
         cmdArray = [office]
      cmdArray += args + ["--accept=pipe,%s;urp" % self._socket]
      if( not os.path.isfile(self._pidfile)):
         self.pid = os.spawnv(os.P_NOWAIT, office, cmdArray)
         f = open(self._pidfile,"w")
         f.write(str(self.pid))

  def Run(self):
    if platform.startswith("win"):
      startupinfo = subprocess.STARTUPINFO()
      startupinfo.dwFlags |= STARTF_USESHOWWINDOW

    for cmd in self.script:
      evt = scriptEvent(msg = cmd, state = SCRIPT_RUNNING)
      wx.PostEvent(self.win, evt)
      args = shlex.split(str(cmd))
      try:
        if platform.startswith("win"):
          p = subprocess.Popen(args, stderr = subprocess.STDOUT,
                               stdout = subprocess.PIPE,
                               startupinfo = startupinfo)
        else:
          p = subprocess.Popen(args, stderr = subprocess.STDOUT,
                               stdout = subprocess.PIPE)
      except:
        evt = scriptEvent(msg = "Exception occurred trying to run\n\n%s" % cmd,
                          state = SCRIPT_CANCELLED)
        wx.PostEvent(self.win, evt)
        self.running = False
        return
      obuf = ''
      while not self.cancelled:
        o = p.stdout.read(1)
        if o == '': break
        if o == '\r' or o == '\n':
          if obuf.strip() != "":
            evt = scriptEvent(msg = obuf, state = SCRIPT_RUNNING)
            wx.PostEvent(self.win, evt)
          obuf = ''
        elif ord(o) < 32:
          pass
        else:
          obuf += o

      if self.cancelled:
        evt = scriptEvent(msg = None, state = SCRIPT_CANCELLED)
        wx.PostEvent(self.win, evt)
        p.kill()
        self.running = False
        p.wait()
        return

      rc = p.wait()
      if rc != 0:
        msg = "RC = " + str(rc) + " - Build terminated"
        evt = scriptEvent(msg = msg, state = SCRIPT_CANCELLED)
        wx.PostEvent(self.win, evt)
        self.running = False
        return

      evt = scriptEvent(msg = "", state = SCRIPT_RUNNING)
      wx.PostEvent(self.win, evt)

    evt = scriptEvent(msg = None, state = SCRIPT_FINISHED)
    wx.PostEvent(self.win, evt)

    self.running = False

def clearScreen():
	import os
	if _platform.startswith("linux") or _platform.startswith("darwin"):
		# linux or mac
		os.system("clear")
	else:
		# windows
		os.system("cls")

def get_os():
    """
    Return system OS name.
    :return: string
    """
    if platform.startswith('linux'):
        return 'Linux'
    elif platform.startswith('win'):
        return 'Windows'

def retrieve_serial_number():
    if platform.startswith("linux"):
        return ""
    elif platform.startswith("win"):
        output = check_output(["wmic", "bios", "get", "serialnumber"])
        output = output.strip().split("\n")[1]
        return output
    elif platform.startswith("darwin"):
        raise NotImplementedError

 def _init_socket(self):
     try:
         if ipaddress.IPv4Address(self.announce_addr).is_multicast:
             # TTL
             self._udp_sock.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_TTL, 2)
             # TODO: This should only be used if we do not have inproc method! 
             self._udp_sock.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_LOOP, 1)
             # Usually, the system administrator specifies the 
             # default interface multicast datagrams should be 
             # sent from. The programmer can override this and
             # choose a concrete outgoing interface for a given
             # socket with this option. 
             #
             # this results in the loopback address?
             # host = socket.gethostbyname(socket.gethostname())
             # self._udp_sock.setsockopt(socket.SOL_IP, socket.IP_MULTICAST_IF, socket.inet_aton(host))
             # You need to tell the kernel which multicast groups 
             # you are interested in. If no process is interested 
             # in a group, packets destined to it that arrive to 
             # the host are discarded.            
             # You can always fill this last member with the 
             # wildcard address (INADDR_ANY) and then the kernel 
             # will deal with the task of choosing the interface.
             #
             # Maximum memberships: /proc/sys/net/ipv4/igmp_max_memberships 
             # self._udp_sock.setsockopt(socket.SOL_IP, socket.IP_ADD_MEMBERSHIP, 
             #       socket.inet_aton("225.25.25.25") + socket.inet_aton(host))
             group = socket.inet_aton(self.announce_addr)
             mreq = struct.pack('4sL', group, socket.INADDR_ANY)
             self._udp_sock.setsockopt(socket.SOL_IP, 
                                       socket.IP_ADD_MEMBERSHIP, mreq)
             self._udp_sock.setsockopt(socket.SOL_SOCKET, 
                                       socket.SO_REUSEADDR, 1)
             #  On some platforms we have to ask to reuse the port
             try: 
                 socket.self._udp_sock.setsockopt(socket.SOL_SOCKET, 
                                       socket.SO_REUSEPORT, 1)
             except AttributeError:
                 pass
             self._udp_sock.bind((self.announce_addr, self._port))
         else:
             # Only for broadcast
             print("Setting up a broadcast beacon on %s:%s" %(self.announce_addr, self._port))
             self._udp_sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)       
             self._udp_sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
             #  On some platforms we have to ask to reuse the port
             try: 
                 self._udp_sock.setsockopt(socket.SOL_SOCKET, 
                                       socket.SO_REUSEPORT, 1)
             except AttributeError:
                 pass
             if platform.startswith("win") or  platform.startswith("darwin"):
                 self._udp_sock.bind(("0.0.0.0", self._port))
             else:
                 self._udp_sock.bind((self.announce_addr, self._port))
     except socket.error as msg:
         print(msg)

def openfile(path):
    if platform.startswith('win') or platform == 'cygwin':
        subprocess.Popen(['explorer', '-p', '/select,', path])
    elif platform.startswith('linux'):
        subprocess.Popen(['xdg-open', path])
    elif platform.startswith('darwin'):
        subprocess.Popen(['open', path])
    else:
        raise NotImplementedError

def get_args():
    import argparse
    from sys import platform

    # Parent parser
    mainparser = argparse.ArgumentParser(description='''Restores backups
            created by s3backup.py''')
    mainparser.add_argument('--version', action='version',
            version='s3restore %s; Suite version %s' %
            (version, config.version))
    subparsers = mainparser.add_subparsers(title='Commands',
            description='Type "command -h" for more info.')

    # Parser for the full-restore command
    fullparser = subparsers.add_parser('full-restore', help='''Restores all
            files from the backup.''')
    fullparser.add_argument('schedule', choices=['daily', 'weekly',
            'monthly'], help='Specifies the backup type to restore.')
    fullparser.add_argument('date', help='''The date the backup was made. A
            quoted string of the format "MM DD YYYY". A value of "last"
            restores the most recent backup.''')
    fullparser.add_argument('--force', action='store_true',
            help='''Restores all files, overwriting any with duplicate
            filenames.''')
    fullparser.add_argument('--force-no-overwrite', action='store_true',
            help='''Restores all file that no longer exist on the
            filesystem.''')
    fullparser.add_argument('-d', '--download-only', metavar='DIR',
            help='''Download and decrypt (if necessary) the archive to the
            given directory, but do not extract.''')
    if platform.startswith('win'):
        fullparser.add_argument('-f', '--filesystem', default='C',
                help='''The filesystem to use. Defaults to "C"''')
    fullparser.set_defaults(func=run_full_restore)

    # Parser for the browse-files command
    browseparser = subparsers.add_parser('browse-files', help='''Browse the
            archives and the archive's files and choose which to restore.
            ''')
    browseparser.add_argument('-s', '--schedule', choices=['daily',
            'weekly', 'monthly'], help='The type of backup to restore.')
    browseparser.add_argument('-d', '--date', help='''The date the backup
            was made. A string of the format "MM DD YYYY". A value of
            "last" browses the most recent backup.''')
    browseparser.add_argument('--archives', action='store_true',
            help='''Prints the list of archives. If given, all other
            arguments are ignored.''')
    if platform.startswith('win'):
        browseparser.add_argument('r', '--root', default='C',
                help='The root filesystem to restore to. Defaults to "C"')
    else:
        browseparser.add_argument('-r', '--root', default='/',
                help='''The root directory to restore to.''')
    browseparser.set_defaults(func=run_browse_files)

    return mainparser

def openfolder(path):
    if platform.startswith('win') or platform == 'cygwin':
        subprocess.Popen(['explorer', '/select,', path])
    elif platform.startswith('linux'):
        path = path.rsplit('/', 1)[0] + '/'
        subprocess.Popen(['xdg-open', path])
    elif platform.startswith('darwin'):
        path = path.rsplit('/', 1)[0] + '/'
        subprocess.Popen(['open', path])
    else:
        raise NotImplementedError

def display(image_file_name):
  '''
  opens up the image in the default image viewer.
  '''
  from sys import platform
  from subprocess import call
  if platform.startswith('linux'):
    call(['xdg-open',image_file_name])
  elif platform.startswith('darwin'):
    call(['open',image_file_name])
  elif platform.startswith('win'):
    call(['start', image_file_name], shell=True)

    def reconnect_xbee(self):
    #search for available ports
        port_to_connect = ''
        while port_to_connect == '':

            #detect platform and format port names
            if _platform.startswith('win'):
                ports = ['COM%s' % (i + 1) for i in range(256)]
            elif _platform.startswith('linux'):
                # this excludes your current terminal "/dev/tty"
                ports = glob.glob('/dev/ttyUSB*')
            else:
                raise EnvironmentError('Unsupported platform: ' + _platform)

            ports_avail = []

            #loop through all possible ports and try to connect
            for port in ports:
                try:
                    s = serial.Serial(port)
                    s.close()
                    ports_avail.append(port)
                except (OSError, serial.SerialException):
                    pass

            if len(ports_avail) ==1:
                port_to_connect = ports_avail[0]

            elif len(ports_avail)==0:
                #No Serial port found, continue looping.
                print( "No serial port detected. Trying again...")
                time.sleep(1)

            elif len(ports_avail)>1:
                #Multiple serial ports detected. Get user input to decide which one to connect to
                #com_input = raw_input("Multiple serial ports available. Which serial port do you want? \n"+str(self.ports_avail)+":").upper();
                if self.default_serial == None:
                    raise EnvironmentError('Incorrect command line parameters. If there are multiple serial devices, indicate what port you want to be used using --serialport')
                elif self.default_serial.upper() in ports_avail:
                    port_to_connect = self.default_serial.upper()
                else:
                    raise EnvironmentError('Incorrect command line parameters. Serial port is not known as a valid port. Valid ports are:'+ str(ports_avail))

        #connect to xbee or uart
        ser = serial.Serial(port_to_connect, 115200)
        if self.uart_connection:
            self.xbee = UARTConnection(ser)
        else:
            self.xbee = ZigBee(ser)

        print('xbee connected to port ' + port_to_connect)
        return self

    def OnPaint(self, event):

        if _plat.startswith('linux'):
            dc = wx.PaintDC(self)
            dc.Clear()
        elif _plat.startswith('darwin'):
            pass
        elif _plat.startswith('win'):
            if USE_BUFFERED_DC:
                dc = wx.BufferedPaintDC(self, self._Buffer)
            else:
                dc = wx.PaintDC(self)
                dc.DrawBitmap(self._Buffer, 0, 0)
                dc.Clear()

 def _getOS(self):
     '''
     Determins the operating system used to run code,
     and returns the terminal exit code to reset terminal features.
     :return: escape code for operating system that resets terminal print config.
     '''
     if platform.startswith("linux"): return self.reset_linux
     elif platform.startswith('darwin'): return self.reset_mac
     elif platform.startswith("win") or platform.startswith("cygwin"):
         return NotImplemented("Windows operating system does not support \
             color print nativly")
     elif platform.startswith("freebsd"): raise NotImplemented("Freebsd os \
             support is not implemented yet")
     else: raise NotImplemented("Could not find os type")

def speak(what):
	if _platform.startswith("linux"):
		# linux
		import subprocess
		subprocess.call(['speech-dispatcher'])
		subprocess.call(['spd-say', what])
	elif _platform.startswith("darwin"):
		# MAC OS X
		os.system("say -v Fred " + what)
	elif _platform == "win32":
		# Windows
		import winsound
		freq = 2500 # Set Frequency To 2500 Hertz
		dur = 1000 # Set Duration To 1000 ms == 1 second
		winsound.Beep(freq, dur)

def test_issue_65(sftpserver):
    '''using the .cd() context manager prior to setting a dir via chdir
    causes an error'''
    with sftpserver.serve_content(VFS):
        cnn = conn(sftpserver)
        cnn['default_path'] = None  # don't call .chdir by setting default_path
        with pysftp.Connection(**cnn) as sftp:
            assert sftp.getcwd() is None
            with sftp.cd('/home/test/pub'):
                pass

            if platform.startswith('linux'):
                assert sftp.getcwd() == '/'
            elif platform.startswith('win32'):
                assert sftp.getcwd() is None

    def _install_android_sdk(self):
        sdk_dir = self.android_sdk_dir
        if self.buildozer.file_exists(sdk_dir):
            self.buildozer.info('Android SDK found at {0}'.format(sdk_dir))
            return sdk_dir

        self.buildozer.info('Android SDK is missing, downloading')
        if platform in ('win32', 'cygwin'):
            archive = 'android-sdk_r{0}-windows.zip'
            unpacked = 'android-sdk-windows'
        elif platform in ('darwin', ):
            archive = 'android-sdk_r{0}-macosx.zip'
            unpacked = 'android-sdk-macosx'
        elif platform.startswith('linux'):
            archive = 'android-sdk_r{0}-linux.tgz'
            unpacked = 'android-sdk-linux'
        else:
            raise SystemError('Unsupported platform: {0}'.format(platform))

        archive = archive.format(self.android_sdk_version)
        url = 'http://dl.google.com/android/'
        self.buildozer.download(url, archive,
                cwd=self.buildozer.global_platform_dir)

        self.buildozer.info('Unpacking Android SDK')
        self.buildozer.file_extract(archive,
                cwd=self.buildozer.global_platform_dir)
        self.buildozer.file_rename(unpacked, sdk_dir,
                cwd=self.buildozer.global_platform_dir)
        self.buildozer.info('Android SDK installation done.')
        return sdk_dir

def SetViewerUserThread(env,viewername,userfn):
    """Adds a viewer to the environment if one doesn't exist yet and starts it on this thread. Then creates a new thread to call the user-defined function to continue computation.
    This function will return when the viewer and uesrfn exits. If userfn exits first, then will quit the viewer
    """
    if env.GetViewer() is not None or viewername is None:
        userfn()
    viewer = None
    if sysplatformname.startswith('darwin'):
        viewer = openravepy_int.RaveCreateViewer(env,viewername)
    else:
        # create in a separate thread for windows and linux since the signals do not get messed up
        env.SetViewer(viewername)
    if viewer is None:
        userfn()
    # add the viewer before starting the user function
    env.Add(viewer)
    threading = __import__('threading')
    Thread = threading.Thread
    def localuserfn(userfn,viewer):
        try:
            userfn()
        finally:
            # user function quit, so have to destroy the viewer
            viewer.quitmainloop()
    userthread = Thread(target=localuserfn,args=(userfn,viewer))
    userthread.start()
    sig_thread_id = 0
    for tid, tobj in threading._active.items():
        if tobj is userthread:
            sig_thread_id = tid
            break
    try:
        viewer.main(True,sig_thread_id)
    finally:
        userthread.join()

    def open_dir_file(self, target):
        """Open a file or a directory in the explorer of the operating system."""
        # check if the file or the directory exists
        if not path.exists(target):
            raise IOError('No such file: {0}'.format(target))

        # check the read permission
        if not access(target, R_OK):
            raise IOError('Cannot access file: {0}'.format(target))

        # open the directory or the file according to the os
        if opersys == 'win32':  # Windows
            proc = startfile(path.realpath(target))

        elif opersys.startswith('linux'):  # Linux:
            proc = subprocess.Popen(['xdg-open', target],
                                    stdout=subprocess.PIPE,
                                    stderr=subprocess.PIPE)

        elif opersys == 'darwin':  # Mac:
            proc = subprocess.Popen(['open', '--', target],
                                    stdout=subprocess.PIPE,
                                    stderr=subprocess.PIPE)

        else:
            raise NotImplementedError(
                "Your `%s` isn't a supported operating system`." % opersys)

        # end of function
        return proc

    def _install_android_sdk(self):
        sdk_dir = self.android_sdk_dir
        if self.buildozer.file_exists(sdk_dir):
            self.buildozer.info('Android SDK found at {0}'.format(sdk_dir))
            return sdk_dir

        self.buildozer.info('Android SDK is missing, downloading')
        if platform in ('win32', 'cygwin'):
            archive = 'sdk-tools-windows-{}.zip'.format(DEFAULT_SDK_TAG)
            unpacked = 'android-sdk-windows'
        elif platform in ('darwin', ):
            archive = 'sdk-tools-darwin-{}.zip'.format(DEFAULT_SDK_TAG)
            unpacked = 'android-sdk-macosx'
        elif platform.startswith('linux'):
            archive = 'sdk-tools-linux-{}.zip'.format(DEFAULT_SDK_TAG)
            unpacked = 'android-sdk-linux'
        else:
            raise SystemError('Unsupported platform: {0}'.format(platform))

        if not os.path.exists(sdk_dir):
            os.makedirs(sdk_dir)

        url = 'http://dl.google.com/android/repository/'
        self.buildozer.download(url,
                                archive,
                                cwd=sdk_dir)

        self.buildozer.info('Unpacking Android SDK')
        self.buildozer.file_extract(archive,
                                    cwd=sdk_dir)

        self.buildozer.info('Android SDK tools base installation done.')

        return sdk_dir