docs: def pip_install_requirements():
      """
      Install on current installed virtualenv version from a pip bundle [dist/project name-version].zip or pip ``req.txt``|``requirements.txt``
      or a env.pip_requirements list.
      
      By default it will look for a zip bundle in the dist directory first then a requirements file.
  
      
      The limitations of installing requirements are that you cannot point directly to packages
      in your local filesystem. In this case you would bundle instead.
      """
      if not version_state('mkvirtualenv'):
          print env.host,'Error: Cannot run pip_install_requirements. A virtualenv is not created for this version. Run mkvirtualenv first'
          return
      if env.verbosity:
          print env.host, 'PIP INSTALLING REQUIREMENTS:'
      
      #Remove any pre-existing pip-log from any previous failed installation
      pip_log_dir = '/'.join(['/home',env.user,'.pip'])
      if exists(pip_log_dir): run('rm -f %s/*.txt'% pip_log_dir)
      
      #determine what req files or bundle files we need to deploy
      if not env.PIP_REQUIREMENTS:
          req_files = {}.fromkeys(glob('req*'))
      else:
          req_files = {}.fromkeys(env.PIP_REQUIREMENTS)
      
      for key in req_files:
          bundle = ''.join([key.split('.')[0],'.zip'])
          if os.path.exists(os.path.join('dist',bundle)):
              req_files[key] = bundle
          
      #determine the django version
      file_patterns =''
      django_version = get_version()
      svn_version = django_version.find('SVN')
      if svn_version > -1:
          django_version = django_version[svn_version+4:]
          django_req = ''.join(['-e svn+http://code.djangoproject.com/svn/django/trunk@',django_version,'#egg=Django'])
      else:
          other_builds = ['alpha','beta','rc']
          for b in other_builds:
              if b in django_version:
                  print "ERROR: Unsupported Django version", django_version
                  print "Define a DJANGO_REQUIREMENT pointing to the tar.gz for",django_version
                  print "and re-deploy, or use the official or SVN release of Django."
                  sys.exit(1)
          django_req = ''.join(['Django==',django_version])
  
      #if no requirements file exists create one
      if not req_files:
          f = open("requirements.txt","w+")
          text = render_to_string('woven/requirements.txt', {'django':django_req})
          f.write(text)
          f.close()
          if env.verbosity:
              print "Created local requirements.txt"
          req_files["requirements.txt"]=''
          
      req_files_list = req_files.keys()
      req_files_list.sort()
      
      #patterns for bundles
      if req_files: file_patterns = '|'.join([file_patterns,'req*.zip'])
  
      #create a pip cache & src directory
      cache =  '/'.join([deployment_root(),'.pip','cache'])
      src = '/'.join([deployment_root(),'.pip','src'])
      deployed = mkdirs(cache)
      deployed += mkdirs(src)
      #deploy bundles and any local copy of django
      local_dir = os.path.join(os.getcwd(),'dist')
      remote_dir = '/'.join([deployment_root(),'env',env.project_fullname,'dist'])
      if os.path.exists(local_dir):  
          if file_patterns: deployed += deploy_files(local_dir, remote_dir, pattern=file_patterns)
      
      #deploy any requirement files
      deployed +=  deploy_files(os.getcwd(), remote_dir, pattern = 'req*') 
      
      #install in the env
      out = State(' '.join([env.host,'pip install requirements']))
      python_path = '/'.join([deployment_root(),'env',env.project_fullname,'bin','python'])
      with settings(warn_only=True):
          with cd(remote_dir):
              for req in req_files_list:
                  bundle = req_files[req]
                  if bundle: req=bundle
                  if env.verbosity:
                      print ' * installing',req
                  if '.zip' in req.lower():
                      install = run('pip install %s -q --environment=%s --log=/home/%s/.pip/%s_pip_log.txt'%
                                    (req, python_path, env.user, req.replace('.','_')))
                    
                  else:
                      install = run('pip install -q --environment=%s --src=%s --download-cache=%s --requirement=%s --log=/home/%s/.pip/%s_pip_log.txt'%
                                    (python_path,src,cache,req, env.user,req.replace('.','_')))
                  if install.failed:
                      out.failed =True
                      out.stderr += ' '.join([env.host, "ERROR INSTALLING",req,'\n'])
      
      out.object = deployed
                
      if out.failed:
          print out.stderr
          print "Review the pip install logs at %s/.pip and re-deploy"% deployment_root()
          sys.exit(1)
      return out