squared 0.4.38 → 0.5.0

data/lib/squared/workspace/project/python.rb

@@ -7,8 +7,8 @@ module Squared
         DEP_PYTHON = %w[poetry.lock setup.cfg pyproject.toml setup.py requirements.txt].freeze
         DIR_PYTHON = (DEP_PYTHON + %w[README.rst]).freeze
         OPT_PYTHON = {
-          common: %w[b B d E h i I O P q s S u v x c=q m=b W=b X=q check-hash-based-pycs=b].freeze,
-          build: %w[C=bm n|no-isolation s|sdist x|skip-dependency-check v|verbose w|wheel config-setting=q installer=b
+          common: %w[b B d E h i I O OO P q s S u v x c=q m=b W=b X=q check-hash-based-pycs=b].freeze,
+          build: %w[n|no-isolation s|sdist v|verbose w|wheel x|skip-dependency-check C|config-setting=q installer=b
                     o|outdir=p].freeze,
           venv: %w[clear copies symlinks system-site-packages upgrade upgrade-deps without-scm-ignore-files without-pip
                    prompt=q].freeze
@@ -28,17 +28,10 @@ module Squared
           freeze: %w[all exclude-editable l|local user exclude=b path=p r|requirement=p].freeze
         }.freeze
         OPT_POETRY = {
-          common: %w[ansi no-ansi no-cache n|no-interaction no-plugins q|quiet v|verbose P|project=p].freeze,
+          common: %w[ansi no-ansi no-cache n|no-interaction no-plugins P|project=p q|quiet v|verbose].freeze,
           build: %w[clean config-settings=qq f|format=b o|output=p].freeze,
-          publish: %w[build dry-run skip-existing cert=p client-cert=p dist-dir=p p|password=q r|repository=b
-                      u|username=qq].freeze
-        }.freeze
-        OPT_PDM = {
-          common: %w[I|ignore-python no-cache n|non-interactive].freeze,
-          build: %w[C=bm no-clean no-isolation no-sdist no-wheel quiet verbose config-setting=q d|dest=p p|project=p
-                    k|skip=b].freeze,
-          publish: %w[no-build no-very-ssl quiet S|sign skip-existing verbose ca-certs=p c|comment=q d|dest=p
-                      i|identity=b P|password=q p|project=p r|repository=q k|skip=b u|username=qq].freeze
+          publish: %w[build dry-run client-cert=p cert=p dist-dir=p p|password=b r|repository=b skip-existing
+                      u|username=b].freeze
         }.freeze
         OPT_HATCH = {
           common: %w[color interactive no-color no-interactive cache-dir=p config=p data-dir=p e|env=b p|project=b
@@ -48,11 +41,11 @@ module Squared
                       p|publisher=b r|repo=b u|user=q].freeze
         }.freeze
         OPT_TWINE = {
-          publish: %w[attestations disable-progress-bar non-interactive s|sign skip-existing verbose cert=p
-                      client-cert=p c|comment=q config-file=p i|identity=b p|password=q r|repository=b repository-url=q
-                      sign-with=b u|username=qq].freeze
+          publish: %w[attestations disable-progress-bar non-interactive skip-existing verbose s|sign c|comment=q
+                      config-file=p cert=p client-cert=p i|identity=b p|password=q r|repository=b repository-url=q
+                      sign-with=b u|username=q].freeze
         }.freeze
-        private_constant :DEP_PYTHON, :DIR_PYTHON, :OPT_PYTHON, :OPT_PIP, :OPT_POETRY, :OPT_PDM, :OPT_HATCH, :OPT_TWINE
+        private_constant :DEP_PYTHON, :DIR_PYTHON, :OPT_PYTHON, :OPT_PIP, :OPT_POETRY, :OPT_HATCH, :OPT_TWINE
 
         class << self
           def populate(*); end
@@ -78,7 +71,7 @@ module Squared
 
         attr_reader :venv, :editable
 
-        def initialize(*, editable: '.', **kwargs)
+        def initialize(*, venv: nil, editable: '.', verbose: nil, **kwargs)
           super
           if @pass.include?(Python.ref)
             initialize_ref Python.ref
@@ -87,101 +80,35 @@ module Squared
             initialize_build(Python.ref, **kwargs)
             initialize_env(**kwargs)
           end
-          dependfile_set(DEP_PYTHON, default: 2)
+          dependfile_set DEP_PYTHON
+          @verbose = verbose.size if verbose.is_a?(String) && verbose.match?(/\Av+\z/)
           editable_set editable
-          venv_set kwargs[:venv]
+          venv_set venv if venv
         end
 
         subtasks({
           'venv' => %i[exec create remove show].freeze,
-          'pip' => %i[upgrade uninstall freeze].freeze,
+          'pip' => %i[uninstall freeze].freeze,
           'install' => %i[user force upgrade target editable].freeze,
-          'outdated' => %i[major minor patch].freeze,
-          'build' => %i[python poetry pdm hatch].freeze,
-          'publish' => %i[poetry pdm hatch twine].freeze,
-          'run' => nil,
+          'build' => %i[python poetry hatch].freeze,
+          'publish' => %i[poetry twine hatch].freeze,
           'exec' => nil
         })
 
-        def verbose=(val)
-          case val
-          when /\Av+\z/
-            @verbose = val.size
-          else
-            super
-          end
-        end
-
         def ref
           Python.ref
         end
 
         def populate(*, **)
           super
-          return unless (outdated? && ref?(Python.ref)) || @only
+          return unless outdated? && ref?(Python.ref)
 
           namespace name do
             Python.subtasks do |action, flags|
-              next if task_pass?(action)
+              next if @pass.include?(action)
 
               if flags.nil?
                 case action
-                when 'run'
-                  next unless pyprojectfile
-
-                  format_desc action, nil, "script+|#{indexchar}index+|#,pattern*"
-                  task action, [:command] do |_, args|
-                    found = 0
-                    %w[tool.poetry.scripts tool.pdm.scripts project.scripts].each_with_index do |table, index|
-                      next if (list = read_pyproject(table)).empty?
-
-                      if args.command == '#'
-                        format_list(list, "run[#{indexchar}N]", 'scripts', grep: args.extras, from: pyprojectfile)
-                        found |= 1
-                      else
-                        args.to_a.each do |val|
-                          if (n, = indexitem(val))
-                            if (script, = list[n - 1])
-                              case index
-                              when 0
-                                script = session_output 'poetry', 'run', script
-                              when 1
-                                script = pdm_session 'run', script
-                              else
-                                venv_init
-                              end
-                              found |= 1
-                              run(script, from: :run)
-                            elsif exception
-                              indexerror n, list
-                            else
-                              found |= 2
-                              log.warn "run script #{n} of #{list.size} (out of range)"
-                            end
-                          else
-                            case index
-                            when 0
-                              found |= 1
-                              run(session_output('poetry', 'run', val), from: :run)
-                            when 1
-                              found |= 1
-                              run(pdm_session('run', val), from: :run)
-                            else
-                              raise_error "script: #{val}" if exception
-                              found |= 2
-                              log.warn "run script \"#{val}\" (not indexed)"
-                            end
-                          end
-                        end
-                      end
-                      break
-                    end
-                    next if found.anybits?(1)
-
-                    puts log_message(found == 0 ? Logger::INFO : Logger::WARN,
-                                     "no scripts #{found == 0 ? 'found' : 'executed'}",
-                                     subject: name, hint: pyprojectfile)
-                  end
                 when 'exec'
                   format_desc action, nil, 'command|:,args*'
                   task action do |_, args|
@@ -191,12 +118,12 @@ module Squared
                           elsif i || args.empty?
                             readline('Enter command', force: true)
                           else
-                            if (val = command_args(args, min: 1, prefix: 'python'))
+                            if (val = command_args(args, prefix: 'python'))
                               args << val
                             end
                             args.join(' ')
                           end
-                    run(cmd, send: :exec, banner: false)
+                    Kernel.exec(cmd, chdir: path)
                   end
                 end
               else
@@ -207,7 +134,7 @@ module Squared
                       if flag == :create
                         format_desc action, flag, 'dir,opts*'
                         task flag, [:dir] do |_, args|
-                          dir = basepath param_guard(action, flag, args: args, key: :dir)
+                          dir = path + param_guard(action, flag, args: args, key: :dir)
                           venv_create dir, args.extras
                         end
                       elsif venv
@@ -228,7 +155,7 @@ module Squared
                             if args.empty?
                               args = readline('Enter command', force: true).split(' ', 2)
                             elsif args.size == 1 && !option('interactive', prefix: 'venv', equals: '0')
-                              args << readline('Enter arguments', force: false) unless args.first.include?(' ')
+                              args << readline('Enter arguments', force: false)
                             end
                             venv_init
                             run args.join(' ')
@@ -242,11 +169,6 @@ module Squared
                       end
                     when 'pip'
                       case flag
-                      when :upgrade
-                        format_desc action, flag, 'opts*'
-                        task flag do |_, args|
-                          install flag, ['upgrade', *args.to_a, 'pip']
-                        end
                       when :freeze
                         format_desc action, flag, "file?=#{DEP_PYTHON[4]},opts*"
                         task flag do |_, args|
@@ -292,30 +214,14 @@ module Squared
                           depend flag, args.to_a
                         end
                       end
-                    when 'outdated'
-                      format_desc action, flag, 'eager?,user?'
-                      task flag do |_, args|
-                        outdated flag, args.to_a
-                      end
                     when 'build'
-                      case flag
-                      when :poetry
-                        next unless build_backend == 'poetry.core.masonry.api'
-                      when :pdm
-                        next unless build_backend == 'pdm.backend'
-                      when :hatch
-                        next unless build_backend == 'hatchling.build'
-                      end
                       format_desc(action, flag, 'opts*', after: case flag
-                                                                when :poetry then 'output?'
-                                                                when :pdm then 'dest?'
+                                                                when :python then 'srcdir?'
                                                                 when :hatch then 'location?'
-                                                                else 'outdir?'
                                                                 end)
                       task flag do |_, args|
                         build! flag, args.to_a
                       end
-                      break unless flag == :python
                     when 'publish'
                       format_desc(action, flag, 'opts*', after: case flag
                                                                 when :hatch then 'artifacts?'
@@ -338,18 +244,17 @@ module Squared
           elsif outdated?
             venv_init
             workspace.rev_clear(name, sync: sync)
-            if !flag && poetry?
-              cmd = poetry_session 'install -n'
+            if !flag && dependtype == 1
+              cmd = poetry_session 'install', '-n'
               cmd << '--no-root' if option('no-root')
             else
               cmd = pip_session 'install'
-              cmd << '--upgrade-strategy=eager' if env('PYTHON_UPDATE')
               if flag
                 case flag
                 when :user
                   cmd << '--user'
                 when :target
-                  cmd << quote_option('target', basepath(target))
+                  cmd << quote_option('target', path + target)
                 when :force
                   cmd << '--force-reinstall'
                 end
@@ -364,8 +269,8 @@ module Squared
           end
         end
 
-        def outdated(flag = nil, opts = [], sync: invoked_sync?('outdated', flag))
-          cmd = pip_session 'list --outdated'
+        def outdated(*, sync: invoked_sync?('outdated'))
+          cmd = pip_session 'list', '--outdated'
           append_global
           cmd = session_done cmd
           log.info cmd
@@ -374,39 +279,28 @@ module Squared
           print_item banner if sync
           start = 0
           found = 0
-          major = []
-          minor = []
-          patch = []
+          major = 0
           pwd_set(from: :outdated) do
             buffer = []
             out = ->(val) { sync ? puts(val) : buffer << val }
-            if workspace.windows?
-              (venv ? command(runenv, cmd) : `#{cmd}`).lines
-            else
-              IO.popen(runenv || {}, cmd)
-            end.each do |line|
-              next if line.match?(/^[ -]+$/)
+            IO.popen(runenv || {}, cmd).each do |line|
+              next if line.match?(/^[\s-]+$/)
 
               if start > 0
                 unless stdin?
-                  cur, lat = line.scan(SEM_VER)
-                  next unless cur && lat
+                  data = line.scan(SEM_VER)
+                  next unless (cur = data.shift) && (lat = data.shift)
 
                   latest = lat.join
                   current = cur.join
                   semver cur
                   semver lat
-                  name = line.split(' ', 2).first
-                  type = if semmajor?(cur, lat)
-                           major << name
-                           2
-                         elsif cur[2] == lat[2]
-                           patch << name
-                           0
-                         else
-                           minor << name
-                           1
-                         end
+                  if semmajor?(cur, lat)
+                    type = 2
+                    major += 1
+                  else
+                    type = cur[2] == lat[2] ? 0 : 1
+                  end
                   if type == 0
                     styles = color(:yellow)
                   else
@@ -440,18 +334,7 @@ module Squared
               puts buffer
             end
             if found > 0
-              print_status(major.size, minor.size, patch.size, from: :outdated)
-              pkg = case flag
-                    when :major
-                      major + minor + patch
-                    when :minor
-                      minor + patch
-                    when :patch
-                      patch
-                    end
-              unless !pkg || pkg.empty?
-                install(:upgrade, pkg, strategy: opts.include?('eager') ? 'eager' : nil, user: opts.include?('user'))
-              end
+              puts print_footer empty_status('Updates are available', 'major', major)
             elsif start == 0
               puts 'No updates were found'
             end
@@ -459,7 +342,7 @@ module Squared
           on :last, :outdated
         end
 
-        def install(flag, opts = [], strategy: nil, user: nil)
+        def install(flag, opts = [], strategy: nil)
           cmd = pip_session 'install'
           out = append_pip(flag, opts, from: :install)
           case flag
@@ -469,89 +352,77 @@ module Squared
           when :upgrade
             raise_error('no packages listed', hint: flag) if out.empty?
             cmd << '--upgrade'
-            cmd << '--user' if user
             cmd << basic_option('upgrade-strategy', strategy) if strategy
             append_value out
-            python_session('-m pip', *cmd.to_a.drop(1)) if workspace.windows?
           end
           run(from: :install)
         end
 
         def build!(flag, opts = [])
           case flag
+          when :python
+            cmd, opts = python_session('-m build', opts: opts)
+            list = OPT_PYTHON[:build]
           when :poetry
             cmd = poetry_session 'build'
             list = OPT_POETRY[:build] + OPT_POETRY[:common]
-          when :pdm
-            cmd, opts = pdm_session('build', opts: opts)
-            list = OPT_PDM[:build]
           when :hatch
             cmd, opts = hatch_session('build', opts: opts)
             list = OPT_HATCH[:build]
-          else
-            cmd, opts = python_session('-m build', opts: opts)
-            list = OPT_PYTHON[:build]
           end
+          srcdir = nil
           op = OptionPartition.new(opts, list, cmd, project: self, single: singleopt(flag))
+          op.each do |opt|
+            if !srcdir && basepath(opt).exist? && projectpath?(opt)
+              srcdir = opt
+            else
+              op.found << opt
+            end
+          end
+          op.swap
           case flag
-          when :hatch
-            if !ENV['HATCH_BUILD_LOCATION'] && (outdir ||= op.shift)
-              op.add_path(outdir)
+          when :poetry
+            if srcdir
+              if op.arg?('o', 'output')
+                op.extras << srcdir
+              else
+                op << quote_option('output', path + srcdir)
+              end
+              srcdir = nil
             end
-          else
-            unless op.empty?
-              args = case flag
-                     when :poetry
-                       %w[o output]
-                     when :pdm
-                       %w[d dest]
-                     else
-                       srcdir = true
-                       %w[o outdir]
-                     end
-              op << quote_option(args.last, basepath(op.shift)) unless op.arg?(*args)
+          when :hatch
+            if ENV['HATCH_BUILD_LOCATION']
+              srcdir = nil
+            else
+              srcdir ||= path
             end
+            op << basic_option('p', project) unless ENV['HATCH_PROJECT'] || op.arg?('p', 'project')
           end
-          op.exist?(add: true, first: true) if srcdir
+          op << shell_quote(path + srcdir) if srcdir
           op.clear
           run(from: :"#{flag}:build")
         end
-        alias build_ build!
 
         def publish(flag, opts = [])
           case flag
           when :poetry
             poetry_session 'publish'
             list = OPT_POETRY[:publish] + OPT_POETRY[:common]
-          when :pdm
-            opts = pdm_session('publish', opts: opts).last
-            list = OPT_PDM[:publish]
-          when :hatch
-            opts = hatch_session('publish', opts: opts).last
-            list = OPT_HATCH[:publish]
           when :twine
             session 'twine', 'upload'
             list = OPT_TWINE[:publish]
+          when :hatch
+            opts = hatch_session('publish', opts: opts).last
+            list = OPT_HATCH[:publish]
           end
           op = OptionPartition.new(opts, list, @session, project: self, single: singleopt(flag))
-          dist = lambda do
-            basepath('dist').tap do |dir|
-              raise_error('no source files found', hint: dir) unless dir.directory? && !dir.empty?
-            end
+          if op.empty?
+            dist = path + 'dist'
+            raise_error('no source files found', hint: dist) unless dist.directory? && !dist.empty?
+            op.extras << "#{dist}/*" unless flag == :poetry
           end
-          case flag
-          when :hatch, :twine
-            if op.empty?
-              op.push("#{dist.call}/*")
-            else
-              op.map! { |val| basepath(val) }
-            end
-            op.append
-          else
-            dist.call unless op.arg?(*(flag == :poetry ? ['dist-dir'] : ['d', 'dest']))
-            op.clear(pass: false)
-          end
-          run(from: :"#{flag}:publish", interactive: "Publish #{sub_style(project, styles: theme[:active])}")
+          op.append
+          run(from: :"#{flag}:publish")
         end
 
         def pip(flag, opts = [])
@@ -559,7 +430,7 @@ module Squared
           out = append_pip(nil, opts, from: flag)
           case flag
           when :uninstall
-            raise_error('no packages listed', hint: flag) if out.empty?
+            raise_error('no packages listed', hint: 'uninstall') if out.empty?
             cmd.merge(out)
           when :freeze
             venv_init
@@ -571,24 +442,26 @@ module Squared
           ret
         end
 
-        def variable_set(key, *val, **)
+        def variable_set(key, *val, **, &blk)
+          if block_given?
+            case key
+            when :dependfile, :venv, :editable
+              val = block_args val, &blk
+            end
+          end
           case key
           when :dependfile
-            if val.first.nil?
-              super
+            req = basepath(*val)
+            if (index = DEP_PYTHON.index(req.basename.to_s))
+              @dependindex = index
+              @dependfile = req
             else
-              req = basepath(*val)
-              if (index = DEP_PYTHON.index(req.basename.to_s))
-                @dependindex = index
-                @dependfile = req
-              else
-                log.warn "variable_set: @#{key}=#{req} (not supported)"
-              end
+              log.warn "variable_set: @#{key}=#{req} (not supported)"
             end
           when :editable
             editable_set val.first
           when :venv
-            @venv = val.empty? || val.first.nil? ? nil : basepath(*val)
+            instance_variable_set(:"@#{key}", val.empty? ? nil : basepath(*val))
           else
             super
           end
@@ -599,7 +472,7 @@ module Squared
         end
 
         def outdated?
-          dependtype > 0 && !task_pass?('outdated')
+          dependtype > 0
         end
 
         private
@@ -609,40 +482,29 @@ module Squared
         end
 
         def python_session(*cmd, opts: nil)
-          pre = preopts(quiet: false)
-          return session('python', *pre, *cmd, path: venv.nil?) unless opts
+          return session('python', *preopts(quiet: false), *cmd, path: venv.nil?) unless opts
 
-          op = OptionPartition.new(opts, OPT_PYTHON[:common], project: self, single: singleopt(:python))
-          ret = session('python', *pre, *op.to_a, *cmd, path: venv.nil?)
+          op = OptionPartition.new(opts, OPT_PYTHON[:common], project: self, single: /\Av+\z/)
+          ret = session('python', *op.to_a, *cmd, path: venv.nil?)
           [ret, op.extras]
         end
 
         def poetry_session(*cmd)
           ret = session('poetry', *cmd, *preopts)
-          if (val = option('project', ignore: false))
-            ret << quote_option('project', basepath(val))
-          end
+          option('project', ignore: false) { |val| ret << quote_option('project', path + val) }
           ret
         end
 
-        def pdm_session(*cmd, opts: nil)
-          create_session(*cmd, name: 'pdm', common: OPT_PDM[:common], opts: opts)
-        end
-
         def hatch_session(*cmd, opts: nil)
-          create_session(*cmd, name: 'hatch', common: OPT_HATCH[:common], opts: opts)
-        end
-
-        def create_session(*cmd, name:, common:, opts: nil)
-          return session(name, *preopts, *cmd, path: venv.nil?) unless opts
+          return session('hatch', *preopts, *cmd, path: venv.nil?) unless opts
 
-          op = OptionPartition.new(opts, common, project: self, single: singleopt(name.to_sym))
-          ret = session(name, *preopts, *op.to_a, *cmd, path: venv.nil?)
+          op = OptionPartition.new(opts, OPT_HATCH[:common], project: self, single: singleopt)
+          ret = session('hatch', *op.to_a, *cmd, path: venv.nil?)
           [ret, op.extras]
         end
 
         def append_pip(flag, opts, target: @session, from: nil)
-          unless from && !opts.empty?
+          if !from || opts.empty?
             append_global(target: target)
             return []
           end
@@ -665,11 +527,11 @@ module Squared
             end
             op.swap
             if edit
-              edit = basepath(edit) unless %r{\A[a-z]+(?:\+[a-z]+)?://}i.match?(edit)
+              edit = path + edit unless %r{^[a-z]+(?:\+[a-z]+)?://}i.match?(edit)
               if flag == :editable
-                op.push(edit)
+                op.extras << edit
               else
-                op << quote_option('e', edit)
+                target << quote_option('e', edit)
               end
             end
             case flag
@@ -680,120 +542,54 @@ module Squared
               []
             end
           else
-            op.extras
+            opts
           end
         end
 
         def append_editable(target: @session)
-          return if requirements? && editable == '.'
+          return if requirements?
 
           if (val = option('editable', 'e', target: target, ignore: false))
-            OptionPartition.delete_key(target, 'e', 'editable')
+            session_delete('e', 'editable', target: target)
             case val
             when '0', 'false'
-              return unless installable?
+              return
             else
-              val = basepath val
+              val = path + val
             end
-          elsif session_arg?('e', 'editable', target: target) || !installable?
+          elsif session_arg?('e', 'editable', target: target) || !(val = editable)
             return
-          else
-            val = editable
           end
-          target << (val ? quote_option('e', basepath(val)) : '.')
+          target << quote_option('e', val)
         end
 
         def append_global(target: @session)
-          if (val = option('cache-dir', target: target))
+          option('cache-dir', target: target) do |val|
             target << case val
                       when '0', 'false'
                         '--no-cache-dir'
                       else
-                        quote_option('cache-dir', basepath(val))
+                        quote_option('cache-dir', path + val)
                       end
           end
-          target << quote_option('proxy', val) if (val = option('proxy', target: target))
-          target << quote_option('python', basepath(val)) if (val = option('python', target: target))
+          option('proxy', target: target) { |val| target << shell_option('proxy', val) }
+          option('python', target: target) { |val| target << quote_option('python', path + val) }
           append_nocolor(target: target)
         end
 
-        def build_backend
-          @build_backend ||= read_pyproject('build-system', 'build-backend') || ''
-        end
-
-        def read_pyproject(table, key = nil)
-          return [] unless (file = pyprojectfile)
-
-          unless (ret = (@pyproject ||= {})[table])
-            ret = []
-            start = /^\s*\[#{Regexp.escape(table)}\]\s*$/
-            ch = nil
-            found = false
-            File.foreach(file) do |line|
-              if found
-                break if line.match?(/^\s*\[[\w.-]+\]\s*$/)
-
-                if ch
-                  val = line.rstrip
-                  case ch
-                  when '}', ']'
-                    ch = nil if val.end_with?(ch)
-                    val = "\n#{val}"
-                  else
-                    if val.chomp!(ch)
-                      ch = nil
-                    else
-                      val = line
-                    end
-                  end
-                  ret.last[1] += val
-                elsif (data = line.match(/^\s*(\S+)\s*=\s*([+-]?[\d.]+|true|false|("""|'''|["'\[{])(.*?))\s*$/))
-                  if (val = data[4])
-                    case (ch = data[3])
-                    when '{', '['
-                      val = "#{ch}#{val}"
-                      ch = ch == '{' ? '}' : ']'
-                      ch = nil if val.end_with?(ch)
-                    else
-                      if val.chomp!(ch)
-                        ch = nil
-                      elsif ch.size == 1
-                        next
+        def editable_set(val)
+          @editable = case val
+                      when '.', Pathname
+                        val
+                      when String
+                        Pathname.new(editable)
                       end
-                    end
-                  else
-                    val = case (val = data[2])
-                          when 'true'
-                            true
-                          when 'false'
-                            false
-                          else
-                            val.include?('.') ? val.to_f : val.to_i
-                          end
-                  end
-                  ret << [data[1], val]
-                end
-              else
-                found = line.match?(start)
-              end
-            end
-            @pyproject[table] = ret
-          end
-          return ret.find { |val| val.first == key }&.last if key
-
-          ret
-        end
-
-        def pyprojectfile
-          return unless (ret = basepath(DEP_PYTHON[2])).exist?
-
-          ret
         end
 
         def singleopt(flag = nil)
           case flag
           when :python
-            /\A(?:v+|q+|b+|V+|O+)\z/
+            /\A(?:v+|q+|b+)\z/
           when :twine
             nil
           else
@@ -830,23 +626,13 @@ module Squared
           @venv&.join(workspace.windows? ? 'Scripts' : 'bin')
         end
 
-        def editable_set(val)
-          @editable = case val
-                      when '.', Pathname
-                        val
-                      when String
-                        Pathname.new(val) unless val.empty?
-                      end
-        end
-
         def venv_set(val)
-          return unless val
-
           if val.is_a?(Array)
             val, *opts = val
             @venvopts = opts
           end
-          @venv = basepath(val)
+          @venv = Pathname.new(val)
+          @venv = @path + @venv unless @venv.absolute?
           if projectpath?(@venv)
             if @venv.exist?
               log.debug "venv found: #{@venv}"
@@ -864,8 +650,8 @@ module Squared
           return if !venv || (venvbin.directory? && !venvbin.empty?)
 
           puts log_message(Logger::INFO, venv, subject: 'venv', hint: 'init')
-          opts = @venvopts&.map { |val| OptionPartition.strip(val) }&.flatten
-          venv_create(venv, opts || ["prompt=#{name}", 'upgrade-deps'], env: false, banner: false)
+          @venvopts &&= @venvopts.map { |val| OptionPartition.strip(val) }.flatten
+          venv_create(venv, @venvopts || ["prompt=#{name}", 'upgrade-deps'], env: false, banner: false)
           puts log_message(Logger::INFO, venv, subject: 'venv', hint: 'created')
         end
 
@@ -874,28 +660,11 @@ module Squared
           op = OptionPartition.new(opts, OPT_PYTHON[:venv], cmd, project: self)
           op.append(dir, delim: true)
             .clear(pass: false)
-          status = op.arg?(/\A-v+\z/)
+          status = op.arg?(/\A-v+\z/, 'verbose')
           run(op, env, exception: true, banner: banner)
-          if poetry?
-            install(:upgrade, ['poetry'])
-          elsif setuptools?
-            install(:upgrade, ['setuptools', 'wheel'])
-          end
           puts(dir.directory? ? "Success: #{dir}" : 'Failed') if banner && !status
         end
 
-        def installable?
-          setuptools? || !!pyprojectfile
-        end
-
-        def setuptools?
-          dependtype == 2 || dependtype == 4
-        end
-
-        def poetry?
-          dependtype == 1
-        end
-
         def requirements?
           dependtype == 5
         end