fpm 1.6.1 → 1.14.1

data/lib/fpm/package/freebsd.rb

@@ -1,4 +1,4 @@
-require "backports" # gem backports
+require "backports/latest" # gem backports/latest
 require "fpm/package"
 require "fpm/util"
 require "digest"
@@ -12,27 +12,11 @@ class FPM::Package::FreeBSD < FPM::Package
     :after_remove       => "post-deinstall",
   } unless defined?(SCRIPT_MAP)
 
-  def self.default_abi
-    abi_name = %x{uname -s}.chomp
-    abi_version = %x{uname -r}.chomp.split(".")[0]
-    abi_arch = %x{uname -m}.chomp
-
-    [abi_name, abi_version, abi_arch].join(":")
-  end
-
-  option "--abi", "ABI",
-         "Sets the FreeBSD abi pkg field to specify binary compatibility.",
-         :default => default_abi
-
   option "--origin", "ABI",
          "Sets the FreeBSD 'origin' pkg field",
          :default => "fpm/<name>"
 
   def output(output_path)
-    # See https://github.com/jordansissel/fpm/issues/1090
-    # require xz later, because this triggers a load of liblzma.so.5 that is
-    # unavailable on older CentOS/RH distros.
-    require "xz"
     output_check(output_path)
 
     # Build the packaging metadata files.
@@ -58,7 +42,7 @@ class FPM::Package::FreeBSD < FPM::Package
     pkg_version = (iteration and (iteration.to_i > 0)) ?  "#{version}-#{iteration}" : "#{version}"
 
     pkgdata = {
-      "abi" => attributes[:freebsd_abi],
+      "arch" => architecture,
       "name" => name,
       "version" => pkg_version,
       "comment" => description,
@@ -92,24 +76,44 @@ class FPM::Package::FreeBSD < FPM::Package
       file.write(pkgdata.to_json + "\n")
     end
 
-    # Create the .txz package archive from the files in staging_path.
-    File.open(output_path, "wb") do |file|
-      XZ::StreamWriter.new(file) do |xz|
-        FPM::Util::TarWriter.new(xz) do |tar|
-          # The manifests must come first for pkg.
-          add_path(tar, "+COMPACT_MANIFEST",
-                   File.join(staging_path, "+COMPACT_MANIFEST"))
-          add_path(tar, "+MANIFEST",
-                   File.join(staging_path, "+MANIFEST"))
-
-          checksums.keys.each do |path|
-            add_path(tar, "/" + path, File.join(staging_path, path))
-          end
-        end
-      end
+    file_list = File.new(build_path("file_list"), "w")
+    files.each do |i|
+      file_list.puts(i)
     end
+    file_list.close
+
+    # Create the .txz package archive from the files in staging_path.
+    # We use --files-from here to keep the tar entries from having `./` as the prefix.
+    # This is done as a best effor to mimic what FreeBSD packages do, having everything at the top-level as
+    # file names, like "+MANIFEST" instead of "./+MANIFEST"
+    safesystem("tar", "-Jcf", output_path, "-C", staging_path, "--files-from", build_path("file_list"), "--transform", 's|^\([^+]\)|/\1|')
   end # def output
 
+  # Handle architecture naming conversion:
+  # <osname>:<osversion>:<arch>:<wordsize>[.other]
+  def architecture
+    osname    = %x{uname -s}.chomp
+    osversion = %x{uname -r}.chomp.split('.').first
+
+    # Essentially because no testing on other platforms
+    arch = 'x86'
+
+    wordsize = case @architecture
+    when nil, 'native'
+      %x{getconf LONG_BIT}.chomp # 'native' is current arch
+    when 'arm64'
+      '64'
+    when 'amd64'
+      '64'
+    when 'i386'
+      '32'
+    else
+      %x{getconf LONG_BIT}.chomp # default to native, the current arch
+    end
+
+    return [osname, osversion, arch, wordsize].join(':')
+  end
+
   def add_path(tar, tar_path, path)
     stat = File.lstat(path)
     if stat.directory?

data/lib/fpm/package/gem.rb

@@ -30,6 +30,9 @@ class FPM::Package::Gem < FPM::Package
   option "--gem", "PATH_TO_GEM",
           "The path to the 'gem' tool (defaults to 'gem' and searches " \
           "your $PATH)", :default => "gem"
+  option "--shebang", "SHEBANG",
+          "Replace the shebang in the executables in the bin path with a " \
+          "custom string", :default => nil
   option "--fix-name", :flag, "Should the target package name be prefixed?",
     :default => true
   option "--fix-dependencies", :flag, "Should the package dependencies be " \
@@ -41,9 +44,36 @@ class FPM::Package::Gem < FPM::Package
   option "--disable-dependency", "gem_name",
     "The gem name to remove from dependency list",
     :multivalued => true, :attribute_name => :gem_disable_dependencies
+  option "--embed-dependencies", :flag, "Should the gem dependencies " \
+    "be installed?", :default => false
 
   option "--version-bins", :flag, "Append the version to the bins", :default => false
 
+  option "--stagingdir", "STAGINGDIR",
+    "The directory where fpm installs the gem temporarily before conversion. " \
+    "Normally a random subdirectory of workdir."
+
+  option "--git-repo", "GIT_REPO",
+    "Use this git repo address as the source of the gem instead of " \
+    "rubygems.org.", :default => nil
+
+  option "--git-branch", "GIT_BRANCH",
+    "When using a git repo as the source of the gem instead of " \
+    "rubygems.org, use this git branch.",
+    :default => nil
+
+  # Override parent method
+  def staging_path(path=nil)
+    @gem_staging_path ||= attributes[:gem_stagingdir] || Stud::Temporary.directory("package-#{type}-staging")
+    @staging_path = @gem_staging_path
+
+    if path.nil?
+      return @staging_path
+    else
+      return File.join(@staging_path, path)
+    end
+  end # def staging_path
+
   def input(gem)
     # 'arg'  is the name of the rubygem we should unpack.
     path_to_gem = download_if_necessary(gem, version)
@@ -70,21 +100,34 @@ class FPM::Package::Gem < FPM::Package
 
     logger.info("Trying to download", :gem => gem_name, :version => gem_version)
 
-    gem_fetch = [ "#{attributes[:gem_gem]}", "fetch", gem_name]
-
-    gem_fetch += ["--prerelease"] if attributes[:gem_prerelease?]
-    gem_fetch += ["--version", gem_version] if gem_version
-
     download_dir = build_path(gem_name)
     FileUtils.mkdir(download_dir) unless File.directory?(download_dir)
 
-    ::Dir.chdir(download_dir) do |dir|
-      logger.debug("Downloading in directory #{dir}")
-      safesystem(*gem_fetch)
+    if attributes[:gem_git_repo]
+      require "git"
+      logger.debug("Git cloning in directory #{download_dir}")
+      g = Git.clone(attributes[:gem_git_repo],gem_name,:path => download_dir)
+      if attributes[:gem_git_branch]
+        g.branch(attributes[:gem_git_branch]).checkout
+        g.pull('origin',attributes[:gem_git_branch])
+      end
+      gem_build = [ "#{attributes[:gem_gem]}", "build", "#{g.dir.to_s}/#{gem_name}.gemspec"]
+      ::Dir.chdir(g.dir.to_s) do |dir|
+        logger.debug("Building in directory #{dir}")
+        safesystem(*gem_build)
+      end
+      gem_files = ::Dir.glob(File.join(g.dir.to_s, "*.gem"))
+    else
+      gem_fetch = [ "#{attributes[:gem_gem]}", "fetch", gem_name]
+      gem_fetch += ["--prerelease"] if attributes[:gem_prerelease?]
+      gem_fetch += ["--version", gem_version] if gem_version
+      ::Dir.chdir(download_dir) do |dir|
+        logger.debug("Downloading in directory #{dir}")
+        safesystem(*gem_fetch)
+      end
+      gem_files = ::Dir.glob(File.join(download_dir, "*.gem"))
     end
 
-    gem_files = ::Dir.glob(File.join(download_dir, "*.gem"))
-
     if gem_files.length != 1
       raise "Unexpected number of gem files in #{download_dir},  #{gem_files.length} should be 1"
     end
@@ -141,7 +184,7 @@ class FPM::Package::Gem < FPM::Package
     # composing multiple packages, it's best to explicitly include it in the provides list.
     self.provides << "#{self.name} = #{self.version}"
 
-    if !attributes[:no_auto_depends?]
+    if !attributes[:no_auto_depends?] && !attributes[:gem_embed_dependencies?]
       spec.runtime_dependencies.map do |dep|
         # rubygems 1.3.5 doesn't have 'Gem::Dependency#requirement'
         if dep.respond_to?(:requirement)
@@ -177,8 +220,18 @@ class FPM::Package::Gem < FPM::Package
 
     ::FileUtils.mkdir_p(installdir)
     # TODO(sissel): Allow setting gem tool path
-    args = [attributes[:gem_gem], "install", "--quiet", "--no-ri", "--no-rdoc",
-       "--no-user-install", "--install-dir", installdir, "--ignore-dependencies"]
+    args = [attributes[:gem_gem], "install", "--quiet", "--no-user-install", "--install-dir", installdir]
+    if ::Gem::VERSION =~ /^[012]\./ 
+      args += [ "--no-ri", "--no-rdoc" ]
+    else
+      # Rubygems 3.0.0 changed --no-ri to --no-document
+      args += [ "--no-document" ]
+    end
+
+    if !attributes[:gem_embed_dependencies?]
+      args += ["--ignore-dependencies"]
+    end
+
     if attributes[:gem_env_shebang?]
       args += ["-E"]
     end
@@ -196,6 +249,22 @@ class FPM::Package::Gem < FPM::Package
     args << gem_path
     safesystem(*args)
 
+    # Replace the shebangs in the executables
+    if attributes[:gem_shebang]
+      ::Dir.entries(bin_path).each do |file_name|
+        # exclude . and ..
+        next if ['.', '..'].include?(file_name)
+        # exclude everything which is not a file
+        file_path = File.join(bin_path, file_name)
+        next unless File.ftype(file_path) == 'file'
+        # replace shebang in files if there is one
+        file = File.read(file_path)
+        if file.gsub!(/\A#!.*$/, "#!#{attributes[:gem_shebang]}")
+          File.open(file_path, 'w'){|f| f << file}
+        end
+      end
+    end
+
     # Delete bin_path if it's empty, and any empty parents (#612)
     # Above, we mkdir_p bin_path because rubygems aborts if the parent
     # directory doesn't exist, for example:
@@ -212,6 +281,21 @@ class FPM::Package::Gem < FPM::Package
         FileUtils.mv("#{bin_path}/#{bin}", "#{bin_path}/#{bin}-#{self.version}")
       end
     end
+
+    if attributes[:source_date_epoch_from_changelog?]
+      detect_source_date_from_changelog(installdir)
+    end
+
+    # Remove generated Makefile and gem_make.out files, if any; they
+    # are not needed, and may contain generated paths that cause
+    # different output on successive runs.
+    Find.find(installdir) do |path|
+      if path =~ /.*(gem_make.out|Makefile|mkmf.log)$/
+        logger.info("Removing no longer needed file %s to reduce nondeterminism" % path)
+        File.unlink(path)
+      end
+    end
+
   end # def install_to_staging
 
   # Sanitize package name.
@@ -220,5 +304,75 @@ class FPM::Package::Gem < FPM::Package
   def fix_name(name)
     return [attributes[:gem_package_name_prefix], name].join("-")
   end # def fix_name
+
+  # Regular expression to accept a gem changelog line, and store date & version, if any, in named capture groups.
+  # Supports formats suggested by http://keepachangelog.com and https://github.com/tech-angels/vandamme
+  # as well as other similar formats that actually occur in the wild.
+  # Build it in pieces for readability, and allow version and date in either order.
+  # Whenever you change this, add a row to the test case in spec/fpm/package/gem_spec.rb.
+  # Don't even try to handle dates that lack four-digit years.
+  # Building blocks:
+  P_RE_LEADIN    = '^[#=]{0,3}\s?'
+  P_RE_VERSION_  = '[\w\.-]+\.[\w\.-]+[a-zA-Z0-9]'
+  P_RE_SEPARATOR = '\s[-=/(]?\s?'
+  P_RE_DATE1     = '\d{4}-\d{2}-\d{2}'
+  P_RE_DATE2     = '\w+ \d{1,2}(?:st|nd|rd|th)?,\s\d{4}'
+  P_RE_DATE3     = '\w+\s+\w+\s+\d{1,2},\s\d{4}'
+  P_RE_DATE      = "(?<date>#{P_RE_DATE1}|#{P_RE_DATE2}|#{P_RE_DATE3})"
+  P_RE_URL       = '\(https?:[-\w/.%]*\)'    # In parens, per markdown
+  P_RE_GTMAGIC   = '\[\]'                    # github magic version diff, per chandler
+  P_RE_VERSION   = "\\[?(?:Version |v)?(?<version>#{P_RE_VERSION_})\\]?(?:#{P_RE_URL}|#{P_RE_GTMAGIC})?"
+  # The final RE's:
+  P_RE_VERSION_DATE = "#{P_RE_LEADIN}#{P_RE_VERSION}#{P_RE_SEPARATOR}#{P_RE_DATE}"
+  P_RE_DATE_VERSION = "#{P_RE_LEADIN}#{P_RE_DATE}#{P_RE_SEPARATOR}#{P_RE_VERSION}"
+
+  # Detect release date, if found, store in attributes[:source_date_epoch]
+  def detect_source_date_from_changelog(installdir)
+    name = self.name.sub("rubygem-", "") + "-" + self.version
+    changelog = nil
+    datestr = nil
+    r1 = Regexp.new(P_RE_VERSION_DATE)
+    r2 = Regexp.new(P_RE_DATE_VERSION)
+
+    # Changelog doesn't have a standard name, so check all common variations
+    # Sort this list using LANG=C, i.e. caps first
+    [
+      "CHANGELIST",
+      "CHANGELOG", "CHANGELOG.asciidoc", "CHANGELOG.md", "CHANGELOG.rdoc", "CHANGELOG.rst", "CHANGELOG.txt",
+      "CHANGES",   "CHANGES.md",   "CHANGES.txt",
+      "ChangeLog", "ChangeLog.md", "ChangeLog.txt",
+      "Changelog", "Changelog.md", "Changelog.txt",
+      "changelog", "changelog.md", "changelog.txt",
+    ].each do |changelogname|
+      path = File.join(installdir, "gems", name, changelogname)
+      if File.exist?(path)
+        changelog = path
+        File.open path do |file|
+          file.each_line do |line|
+            if line =~ /#{self.version}/
+              [r1, r2].each do |r|
+                if r.match(line)
+                  datestr = $~[:date]
+                  break
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+    if datestr
+      date = Date.parse(datestr)
+      sec = date.strftime("%s")
+      attributes[:source_date_epoch] = sec
+      logger.debug("Gem %s has changelog date %s, setting source_date_epoch to %s" % [name, datestr, sec])
+    elsif changelog
+      logger.debug("Gem %s changelog %s did not have recognizable date for release %s" % [name, changelog, self.version])
+    else
+      logger.debug("Gem %s did not have changelog with recognized name" % [name])
+      # FIXME: check rubygems.org?
+    end
+  end # detect_source_date_from_changelog
+
   public(:input, :output)
 end # class FPM::Package::Gem

data/lib/fpm/package/pacman.rb

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 require "fpm/package"
 require "fpm/util"
-require "backports"
+require "backports/latest"
 require "fileutils"
 require "find"
 
@@ -18,10 +18,10 @@ class FPM::Package::Pacman < FPM::Package
   option "--group", "GROUP", "The group owner of files in this package", :default => 'root'
 
   # The list of supported compression types. Default is xz (LZMA2)
-  COMPRESSION_TYPES = [ "gz", "bzip2", "xz", "none" ]
+  COMPRESSION_TYPES = [ "gz", "bzip2", "xz", "zstd", "none" ]
 
   option "--compression", "COMPRESSION", "The compression type to use, must " \
-    "be one of #{COMPRESSION_TYPES.join(", ")}.", :default => "xz" do |value|
+    "be one of #{COMPRESSION_TYPES.join(", ")}.", :default => "zstd" do |value|
     if !COMPRESSION_TYPES.include?(value)
       raise ArgumentError, "Pacman compression value of '#{value}' is invalid. " \
         "Must be one of #{COMPRESSION_TYPES.join(", ")}"
@@ -58,7 +58,7 @@ class FPM::Package::Pacman < FPM::Package
   end # def config_files
 
   def dependencies
-    bogus_regex = /[^\sA-Za-z0-9><=-]/
+    bogus_regex = /[^\sA-Za-z0-9><=+._@-]/
     # Actually modifies depencies if they are not right
     bogus_dependencies = @dependencies.grep bogus_regex
     if bogus_dependencies.any?
@@ -137,7 +137,7 @@ class FPM::Package::Pacman < FPM::Package
     # Speaking of just taking the first entry of the field:
     # A crude thing to do, but I suppose it's better than nothing.
     # -- Daniel Haskin, 3/24/2015
-    self.category = control["group"][0] || self.category
+    self.category = control["group"] && control["group"][0] || self.category
 
     # Licenses could include more than one.
     # Speaking of just taking the first entry of the field:
@@ -164,6 +164,10 @@ class FPM::Package::Pacman < FPM::Package
     end
 
     self.dependencies = control["depend"] || self.dependencies
+    
+    if attributes[:no_auto_depends?]
+      self.dependencies = []
+    end
 
     self.attributes[:pacman_optional_depends] = control["optdepend"] || []
     # There are other available attributes, but I didn't include them because:
@@ -205,31 +209,39 @@ class FPM::Package::Pacman < FPM::Package
 
   def compression_option
     case self.attributes[:pacman_compression]
-      when nil, "xz"
-        return "--xz"
+      when nil, "zstd"
+        return "--zstd"
       when "none"
         return ""
       when "gz"
         return "-z"
+      when "xz"
+        return "--xz"
       when "bzip2"
         return "-j"
+      when "zstd"
+        return "--zstd"
       else
-        return "--xz"
+        return "--zstd"
       end
   end
 
   def compression_ending
     case self.attributes[:pacman_compression]
-      when nil, "xz"
-        return ".xz"
+      when nil, "zstd"
+        return ".zst"
       when "none"
         return ""
       when "gz"
         return ".gz"
+      when "zx"
+        return ".xz"
       when "bzip2"
         return ".bz2"
+      when "zstd"
+        return ".zst"
       else
-        return ".xz"
+        return ".zst"
       end
   end
 
@@ -241,7 +253,11 @@ class FPM::Package::Pacman < FPM::Package
     Find.find(staging_path) do |path|
       src = path.gsub(/^#{staging_path}/, '')
       dst = build_path(src)
-      copy_entry(path, dst, preserve=true, remove_destination=true)
+      begin
+        copy_entry(path, dst, preserve=true, remove_destination=true)
+      rescue
+        copy_entry(path, dst, preserve=false, remove_destination=true)
+      end
       copy_metadata(path, dst)
     end
 

data/lib/fpm/package/pleaserun.rb

@@ -10,13 +10,14 @@ require "pleaserun/cli"
 # This does not currently support 'output'
 class FPM::Package::PleaseRun < FPM::Package
   # TODO(sissel): Implement flags.
-  
+
   require "pleaserun/platform/systemd"
   require "pleaserun/platform/upstart"
   require "pleaserun/platform/launchd"
   require "pleaserun/platform/sysv"
 
   option "--name", "SERVICE_NAME", "The name of the service you are creating"
+  option "--chdir", "CHDIR", "The working directory used by the service"
 
   private
   def input(command)
@@ -27,6 +28,10 @@ class FPM::Package::PleaseRun < FPM::Package
       ::PleaseRun::Platform::Launchd.new("10.9"), # OS X
       ::PleaseRun::Platform::SYSV.new("lsb-3.1") # Ancient stuff
     ]
+    pleaserun_attributes = [ "chdir", "user", "group", "umask", "chroot", "nice", "limit_coredump",
+                             "limit_cputime", "limit_data", "limit_file_size", "limit_locked_memory",
+                             "limit_open_files", "limit_user_processes", "limit_physical_memory", "limit_stack_size",
+                             "log_directory", "log_file_stderr", "log_file_stdout"]
 
     attributes[:pleaserun_name] ||= File.basename(command.first)
     attributes[:prefix] ||= "/usr/share/pleaserun/#{attributes[:pleaserun_name]}"
@@ -41,6 +46,13 @@ class FPM::Package::PleaseRun < FPM::Package
       else
         platform.name
       end
+      pleaserun_attributes.each do |attribute_name|
+        attribute = "pleaserun_#{attribute_name}".to_sym
+        if attributes.has_key?(attribute) and not attributes[attribute].nil?
+          platform.send("#{attribute_name}=", attributes[attribute])
+        end
+      end
+
       base = staging_path(File.join(attributes[:prefix], "#{platform.platform}/#{platform.target_version || "default"}"))
       target = File.join(base, "files")
       actions_script = File.join(base, "install_actions.sh")

data/lib/fpm/package/pyfpm/get_metadata.py

@@ -47,6 +47,11 @@ class get_metadata(Command):
 
     def process_dep(self, dep):
         deps = []
+        if hasattr(dep, 'marker') and dep.marker:
+            # PEP0508 marker present
+            if not dep.marker.evaluate():
+                return deps
+
         if dep.specs:
             for operator, version in dep.specs:
                 deps.append("%s %s %s" % (dep.project_name,
@@ -85,6 +90,11 @@ class get_metadata(Command):
                 for dep in pkg_resources.parse_requirements(
                         self.distribution.install_requires):
                     final_deps.extend(self.process_dep(dep))
+            if getattr(self.distribution, 'extras_require', None):
+                for dep in pkg_resources.parse_requirements(
+                        v for k, v in self.distribution.extras_require.items()
+                        if k.startswith(':') and pkg_resources.evaluate_marker(k[1:])):
+                    final_deps.extend(self.process_dep(dep))
 
         data["dependencies"] = final_deps
 

data/lib/fpm/package/python.rb

@@ -29,6 +29,9 @@ class FPM::Package::Python < FPM::Package
   option "--pypi", "PYPI_URL",
     "PyPi Server uri for retrieving packages.",
     :default => "https://pypi.python.org/simple"
+  option "--trusted-host", "PYPI_TRUSTED",
+    "Mark this host or host:port pair as trusted for pip",
+    :default => nil
   option "--package-prefix", "NAMEPREFIX",
     "(DEPRECATED, use --package-name-prefix) Name to prefix the package " \
     "name with." do |value|
@@ -73,6 +76,14 @@ class FPM::Package::Python < FPM::Package
     "The python package name to remove from dependency list",
     :multivalued => true, :attribute_name => :python_disable_dependency,
     :default => []
+  option "--setup-py-arguments", "setup_py_argument",
+    "Arbitrary argument(s) to be passed to setup.py",
+    :multivalued => true, :attribute_name => :python_setup_py_arguments,
+    :default => [] 
+  option "--internal-pip", :flag,
+    "Use the pip module within python to install modules - aka 'python -m pip'. This is the recommended usage since Python 3.4 (2014) instead of invoking the 'pip' script",
+    :attribute_name => :python_internal_pip,
+    :default => true
 
   private
 
@@ -123,16 +134,47 @@ class FPM::Package::Python < FPM::Package
     target = build_path(package)
     FileUtils.mkdir(target) unless File.directory?(target)
 
-    if attributes[:python_pip].nil?
+    if attributes[:python_internal_pip?]
+      # XXX: Should we detect if internal pip is available?
+      attributes[:python_pip] = [ attributes[:python_bin], "-m", "pip"]
+    end
+
+    # attributes[:python_pip] -- expected to be a path
+    if attributes[:python_pip]
+      logger.debug("using pip", :pip => attributes[:python_pip])
+      # TODO: Support older versions of pip
+
+      pip = [attributes[:python_pip]] if pip.is_a?(String)
+      setup_cmd = [
+        *attributes[:python_pip],
+        "download",
+        "--no-clean",
+        "--no-deps",
+        "--no-binary", ":all:",
+        "-d", build_path,
+        "-i", attributes[:python_pypi],
+      ]
+
+      if attributes[:python_trusted_host]
+        setup_cmd += [
+          "--trusted-host",
+          attributes[:python_trusted_host],
+        ]
+      end
+
+      setup_cmd += [
+        "--build",
+        target,
+        want_pkg,
+      ]
+      
+      safesystem(*setup_cmd)
+    else
       # no pip, use easy_install
       logger.debug("no pip, defaulting to easy_install", :easy_install => attributes[:python_easyinstall])
       safesystem(attributes[:python_easyinstall], "-i",
                  attributes[:python_pypi], "--editable", "-U",
                  "--build-directory", target, want_pkg)
-    else
-      logger.debug("using pip", :pip => attributes[:python_pip])
-      # TODO: Support older versions of pip
-      safesystem(attributes[:python_pip], "download", "--no-clean", "--no-deps", "--no-binary", ":all:", "-i", attributes[:python_pypi], "--build", target,  want_pkg)
     end
 
     # easy_install will put stuff in @tmpdir/packagename/, so find that:
@@ -179,7 +221,7 @@ class FPM::Package::Python < FPM::Package
 
     output = ::Dir.chdir(setup_dir) do
       tmp = build_path("metadata.json")
-      setup_cmd = "env PYTHONPATH=#{pylib} #{attributes[:python_bin]} " \
+      setup_cmd = "env PYTHONPATH=#{pylib}:$PYTHONPATH #{attributes[:python_bin]} " \
         "setup.py --command-packages=pyfpm get_metadata --output=#{tmp}"
 
       if attributes[:python_obey_requirements_txt?]
@@ -225,7 +267,7 @@ class FPM::Package::Python < FPM::Package
 
     if !attributes[:no_auto_depends?] and attributes[:python_dependencies?]
       metadata["dependencies"].each do |dep|
-        dep_re = /^([^<>!= ]+)\s*(?:([<>!=]{1,2})\s*(.*))?$/
+        dep_re = /^([^<>!= ]+)\s*(?:([~<>!=]{1,2})\s*(.*))?$/
         match = dep_re.match(dep)
         if match.nil?
           logger.error("Unable to parse dependency", :dependency => dep)
@@ -236,7 +278,7 @@ class FPM::Package::Python < FPM::Package
         next if attributes[:python_disable_dependency].include?(name)
 
         # convert == to =
-        if cmp == "=="
+        if cmp == "==" or cmp == "~="
           logger.info("Converting == dependency requirement to =", :dependency => dep )
           cmp = "="
         end
@@ -310,6 +352,13 @@ class FPM::Package::Python < FPM::Package
         flags += [ "build_scripts", "--executable", attributes[:python_scripts_executable] ]
       end
 
+      if !attributes[:python_setup_py_arguments].nil? and !attributes[:python_setup_py_arguments].empty?
+        # Add optional setup.py arguments
+        attributes[:python_setup_py_arguments].each do |a|
+          flags += [ a ]
+        end
+      end
+
       safesystem(attributes[:python_bin], "setup.py", "install", *flags)
     end
   end # def install_to_staging