squared 0.4.5 → 0.4.7

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

@@ -5,7 +5,7 @@ module Squared
     module Project
       class Node < Git
         OPT_NPM = {
-          common: %w[dry-run include-workspace-root workspaces=b? w|workspace=b].freeze,
+          common: %w[dry-run include-workspace-root workspaces=b? w|workspace=v].freeze,
           install: %w[prefer-dedupe package-lock-only cpu=b libc=b os=b].freeze,
           install_base: %w[ignore-scripts install-links strict-peer-deps include=b omit=b install-strategy=b].freeze,
           install_no: %w[audit bin-links fund package-lock].freeze,
@@ -238,8 +238,11 @@ module Squared
             return
           end
           items = []
-          items << @workspace.home if build? && path != @workspace.home && @workspace.home?
-          items += as_a(also) if also
+          if build? && path != @workspace.home && @workspace.home?
+            items << @workspace.home
+            @workspace.rev_clear(@workspace.find(@workspace.home).name)
+          end
+          items.concat(as_a(also)) if also
           return if items.empty?
 
           on :first, :copy
@@ -248,11 +251,18 @@ module Squared
             case dir
             when Pathname
               dest = dir
+              @workspace.rev_clear(dest)
             when String
               dest = @workspace.rootpath(dir)
+              @workspace.rev_clear(dest)
             when Symbol
-              dest = @workspace.find(name: dir)&.path
-              log.warn message("copy project :#{dir}", hint: 'not found') unless dest
+              if (proj = @workspace.find(name: dir))
+                @workspace.rev_clear(proj.name)
+                dest = proj.path
+              else
+                log.warn message("copy project :#{dir}", hint: 'not found')
+                dest = nil
+              end
             when Hash
               from = dir[:from] if dir.key?(:from)
               into = dir[:into] if dir.key?(:into)
@@ -265,10 +275,12 @@ module Squared
               glob = dir[:include]
               pass = dir[:exclude]
               dest = items.first unless dest && dest != true
+              @workspace.rev_clear(dest) unless dest == true
             when Project::Base
               dest = dir.path
+              @workspace.rev_clear(dir.name)
             else
-              raise_error "copy given: #{dir}"
+              raise_error "copy: given #{dir}"
             end
             next unless from && dest&.directory?
 
@@ -318,7 +330,7 @@ module Squared
           if @depend && !flag
             super
           elsif outdated?
-            workspace.rev_clear name
+            workspace.rev_clear(name)
             return update if !flag && env('NODE_UPDATE')
 
             if (yarn = dependtype(:yarn)) > 0
@@ -579,54 +591,55 @@ module Squared
         end
 
         def package(flag, opts = [])
+          workspace.rev_clear(name)
           if (yarn = dependtype(:yarn)) > 0
             cmd = session 'yarn', if flag == :update
                                     flag = yarn == 1 ? 'upgrade' : 'up'
                                   else
                                     flag
                                   end
-            out = option_sanitize(opts, if yarn == 1
-                                          OPT_PNPM[:install_base] + OPT_YARN.fetch(flag, []) + OPT_YARN[:common]
-                                        else
-                                          OPT_BERRY[flag]
-                                        end).first
+            op = OptionPartition.new(opts, if yarn == 1
+                                             OPT_PNPM[:install_base] + OPT_YARN.fetch(flag, []) + OPT_YARN[:common]
+                                           else
+                                             OPT_BERRY[flag]
+                                           end, cmd, project: self)
+            op.clear
             append_loglevel
-            option_clear out
             run(from: :"package:#{flag}")
             return
           elsif pnpm?
             cmd = session 'pnpm', flag
             list = OPT_PNPM[:install_base] + OPT_PNPM.fetch(flag, []) + OPT_PNPM[:common]
-            list += OPT_PNPM[:install_as] unless flag == :dedupe
-            opts = option_sanitize(opts, list, no: OPT_PNPM[:"#{flag}_no"]).first
+            list.concat(OPT_PNPM[:install_as]) unless flag == :dedupe
+            no = OPT_PNPM[:"#{flag}_no"]
           else
             cmd = session 'npm', flag
             list = OPT_NPM[:install_base] + OPT_NPM.fetch(flag, []) + OPT_NPM[:common]
-            list += OPT_NPM[:install_as] unless flag == :dedupe
-            opts, pat = option_sanitize(opts, list, no: OPT_NPM[:install_no])
+            list.concat(OPT_NPM[:install_as]) unless flag == :dedupe
+            no = OPT_NPM[:install_no]
           end
-          out = []
-          err = []
-          opts.each do |opt|
-            if pat && opt =~ pat
+          op = OptionPartition.new(opts, list, cmd, no: no, project: self)
+          op.each do |opt|
+            if opt =~ op.values
               case $1
               when 'w', 'workspace'
-                cmd << (%r{[\\/]}.match?($2) ? quote_option($1, basepath($2)) : shell_option($1, $2))
+                op << ($2.match?(%r{[\\/]}) ? quote_option($1, basepath($2)) : shell_option($1, $2))
               end
             elsif opt.include?('=')
-              err << opt
+              op.errors << opt
             else
-              out << opt
+              op.found << opt
             end
           end
+          op.swap
           append_nocolor
           append_loglevel
           if flag == :dedupe
-            option_clear out
+            op.clear
           else
-            append_value(out, escape: true)
+            op.append(escape: true)
           end
-          option_clear err
+          op.clear(errors: true)
           run(from: :"package:#{flag}")
         end
 
@@ -680,7 +693,8 @@ module Squared
             end
           rescue StandardError => e
             log.debug e
-            raise if exception
+            ret = on(:error, :bump, e)
+            raise if exception && ret != true
           end
         end
 
@@ -689,13 +703,25 @@ module Squared
 
           cmd = session dependbin, 'pack'
           if dependtype(:yarn) > 1
-            out = option_sanitize(opts, OPT_BERRY[:pack]).first
-            cmd << quote_option('out', Pathname.pwd.join("#{project}-#{version}.tgz")) unless session_arg?('out')
+            op = OptionPartition.new(opts, OPT_BERRY[:pack], cmd, project: self)
+            op << quote_option('out', Pathname.pwd.join("#{project}-#{version}.tgz")) unless op.arg?('out')
           else
-            out = option_sanitize(opts, pnpm? ? OPT_PNPM[:pack] : OPT_NPM[:pack] + OPT_NPM[:common]).first
-            cmd << quote_option('pack-destination', Dir.pwd) unless session_arg?('pack-destination')
+            op = OptionPartition.new(opts, pnpm? ? OPT_PNPM[:pack] : OPT_NPM[:pack] + OPT_NPM[:common], cmd,
+                                     project: self)
+            unless pnpm?
+              op.each do |opt|
+                next unless opt =~ op.values
+
+                case $1
+                when 'w', 'workspace'
+                  op << ($2.match?(%r{[\\/]}) ? quote_option($1, basepath($2)) : shell_option($1, $2))
+                  op.found << opt
+                end
+              end
+            end
+            op << quote_option('pack-destination', Dir.pwd) unless op.arg?('pack-destination')
           end
-          option_clear out
+          op.clear
           run(from: :pack)
         end
 
@@ -718,7 +744,7 @@ module Squared
             when Enumerable
               target.to_a.join(' ')
             else
-              raise_error("compose given: #{target}", hint: from)
+              raise_error("compose: given #{target}", hint: from)
             end
           end
         end

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

@@ -4,9 +4,8 @@ module Squared
   module Workspace
     module Project
       class Python < Git
-        REQUIREMENTS = %w[requirements.txt poetry.lock pyproject.toml setup.cfg].freeze
-        SETUPTOOLS = %w[setup.py pyproject.toml].freeze
-        DIR_PYTHON = (REQUIREMENTS + SETUPTOOLS).freeze
+        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 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
@@ -21,7 +20,7 @@ module Squared
           install: %w[break-system-packages check-build-dependencies compile dry-run force-reinstall I|ignore-installed
                       ignore-requires-python no-build-isolation no-clean no-compile no-deps no-index no-warn-conflicts
                       no-warn-script-location pre prefer-binary require-hashes U|upgrade use-pep517 user abi=b
-                      config-settings=q c|constraint=p e|editable=b? extra-index-url=q f|find-links=q global-option=q
+                      config-settings=q c|constraint=p e|editable=v extra-index-url=q f|find-links=q global-option=q
                       implementation=b i|index-url=q no-binary=q only-binary=q platform=q prefix=p progress-bar=b
                       python-version=q report=p r|requirement=p root=p root-user-action=b src=p t|target=p
                       upgrade-strategy=b].freeze,
@@ -46,8 +45,7 @@ module Squared
                       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 :REQUIREMENTS, :SETUPTOOLS, :DIR_PYTHON, :OPT_PYTHON, :OPT_PIP, :OPT_POETRY, :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
@@ -71,9 +69,9 @@ module Squared
           end
         end
 
-        attr_reader :venv
+        attr_reader :venv, :editable
 
-        def initialize(*, venv: nil, **kwargs)
+        def initialize(*, venv: nil, editable: '.', verbose: nil, **kwargs)
           super
           if @pass.include?(Python.ref)
             initialize_ref Python.ref
@@ -82,13 +80,20 @@ module Squared
             initialize_build(Python.ref, **kwargs)
             initialize_env(**kwargs)
           end
-          @dependindex = REQUIREMENTS.index { |file| basepath(file).exist? }
-          @dependfile = basepath(REQUIREMENTS[@dependindex || 0])
+          @dependindex = DEP_PYTHON.index { |file| basepath(file).exist? }
+          @dependfile = basepath(DEP_PYTHON[@dependindex || 0])
+          @verbose = $1.size if verbose.is_a?(String) && verbose =~ /^(v+)$/
+          @editable = case editable
+                      when '.', Pathname
+                        editable
+                      when String
+                        Pathname.new(editable)
+                      end
           venv_set venv if venv
         end
 
         subtasks({
-          'venv' => %i[create remove show].freeze,
+          'venv' => %i[run create remove show].freeze,
           'pip' => %i[uninstall freeze].freeze,
           'install' => %i[user force upgrade target editable].freeze,
           'build' => %i[python poetry hatch].freeze,
@@ -114,13 +119,14 @@ module Squared
                     if flag == :create
                       format_desc action, flag, 'dir,opts*'
                       task flag, [:dir] do |_, args|
-                        dir = param_guard(action, flag, args: args, key: :dir)
-                        opts = python_session('-m venv', opts: args.extras).last
-                        opts = option_sanitize(opts, OPT_PYTHON[:venv]).first
-                        append_value(dir = basepath(dir), delim: true)
-                        option_clear(opts, pass: false)
+                        dir = basepath(param_guard(action, flag, args: args, key: :dir))
+                        cmd, opts = python_session('-m venv', opts: args.extras)
+                        op = OptionPartition.new(opts, OPT_PYTHON[:venv], cmd, project: self)
+                        op.append(dir, delim: true)
+                          .clear(pass: false)
+                        v = op.arg?(/^-v+$/, 'verbose')
                         run(exception: true)
-                        puts(dir.directory? ? "Success: #{dir}" : 'Failed')
+                        puts(dir.directory? ? "Success: #{dir}" : 'Failed') unless v
                       end
                     elsif venv
                       case flag
@@ -129,10 +135,17 @@ module Squared
 
                         format_desc action, flag, 'c|reate?,d|epend?'
                         task flag do |_, args|
-                          venv.rmtree(verbose: true)
+                          rm_rf(venv, verbose: true)
                           venv_init if has_value?(%w[c create], args.to_a)
                           depend if has_value?(%w[d depend], args.to_a)
                         end
+                      when :run
+                        format_desc action, flag, 'args+'
+                        task flag do |_, args|
+                          args = param_guard(action, flag, args: args.to_a)
+                          venv_init
+                          run session(*args, path: false)
+                        end
                       when :show
                         format_desc action, flag
                         task flag do
@@ -143,7 +156,7 @@ module Squared
                   when 'pip'
                     case flag
                     when :freeze
-                      format_desc action, flag, 'file?=requirements.txt,opts*'
+                      format_desc action, flag, "file?=#{DEP_PYTHON[4]},opts*"
                       task flag do |_, args|
                         if (file = pip(flag, args.to_a)) && verbose
                           puts File.read(file)
@@ -162,7 +175,7 @@ module Squared
                                                                when :editable
                                                                  'path/url?'
                                                                when :upgrade
-                                                                 'eager?,package+'
+                                                                 'strategy?,package+'
                                                                end)
                     case flag
                     when :editable
@@ -222,10 +235,9 @@ module Squared
             super
           elsif outdated?
             venv_init
-            workspace.rev_clear name
-            if !flag && dependtype == 2
-              cmd = session 'poetry', 'install', '-n'
-              cmd << '--no-ansi' unless verbose
+            workspace.rev_clear(name)
+            if !flag && dependtype == 1
+              cmd = poetry_session 'install', '-n'
               cmd << '--no-root' if option('no-root')
             else
               cmd = pip_session 'install'
@@ -240,16 +252,10 @@ module Squared
                 end
                 append_pip(flag, opts, from: :install)
               else
-                if (val = option('editable', 'e'))
-                  cmd << quote_option('e', editable(val))
-                end
                 append_global
               end
-              if dependtype == 1 && !session_arg?('e', 'editable')
-                cmd << '-r requirements.txt' unless session_arg?('r', 'requirement')
-              elsif !session_arg?('e', 'editable', value: true)
-                cmd << '.'
-              end
+              cmd << "-r #{DEP_PYTHON[4]}" if basepath(DEP_PYTHON[4]).exist? && !session_arg?('r', 'requirement')
+              append_editable
             end
             run(from: :depend, sync: sync)
           end
@@ -333,9 +339,10 @@ module Squared
           out = append_pip(flag, opts, from: :install)
           case flag
           when :editable
-            cmd << quote_option('e', out.shift || '.')
+            cmd << quote_option('e', out.pop || editable || '.')
             option_clear out
           when :upgrade
+            raise_error('no packages listed', hint: flag) if out.empty?
             cmd << '--upgrade'
             cmd << basic_option('upgrade-strategy', strategy) if strategy
             append_value out
@@ -344,33 +351,34 @@ module Squared
         end
 
         def buildx(flag, opts = [])
-          out = []
-          srcdir = nil
           case flag
           when :python
             cmd, opts = python_session('-m build', opts: opts)
             list = OPT_PYTHON[:build]
           when :poetry
-            cmd = session 'poetry', 'build'
+            cmd = poetry_session 'build'
             list = OPT_POETRY[:build] + OPT_POETRY[:common]
           when :hatch
             cmd, opts = hatch_session('build', opts: opts)
             list = OPT_HATCH[:build]
           end
-          option_sanitize(opts, list, single: flag == :python ? /^(?:v+|q+|b+)$/ : /^(?:v+|q+)$/).first.each do |opt|
+          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
-              out << opt
+              op.found << opt
             end
           end
+          op.swap
           case flag
           when :poetry
             if srcdir
-              if session_arg?('o', 'output')
-                out << srcdir
+              if op.arg?('o', 'output')
+                op.extras << srcdir
               else
-                cmd << quote_option('output', basepath(srcdir))
+                op << quote_option('output', basepath(srcdir))
               end
               srcdir = nil
             end
@@ -380,33 +388,32 @@ module Squared
             else
               srcdir ||= path
             end
-            cmd << basic_option('p', project) unless ENV['HATCH_PROJECT'] || session_arg?('p', 'project')
+            op << basic_option('p', project) unless ENV['HATCH_PROJECT'] || op.arg?('p', 'project')
           end
-          cmd << shell_quote(basepath(srcdir)) if srcdir
-          option_clear out
+          op << shell_quote(basepath(srcdir)) if srcdir
+          op.clear
           run(from: :"#{flag}:build")
         end
 
         def publish(flag, opts = [])
-          cmd = session flag
           case flag
           when :poetry
-            cmd << 'publish'
+            poetry_session 'publish'
             list = OPT_POETRY[:publish] + OPT_POETRY[:common]
           when :twine
-            cmd << 'upload'
+            session 'twine', 'upload'
             list = OPT_TWINE[:publish]
           when :hatch
             opts = hatch_session('publish', opts: opts).last
             list = OPT_HATCH[:publish]
           end
-          out = option_sanitize(opts, list, single: flag == :twine ? nil : /^(?:v+|q+)$/).first
-          if out.empty?
+          op = OptionPartition.new(opts, list, @session, project: self, single: singleopt(flag))
+          if op.empty?
             dist = basepath.join('dist')
-            raise_error('no source files given', hint: dist) unless dist.directory? && !dist.empty?
-            out << "#{dist}/*" unless flag == :poetry
+            raise_error('no source files found', hint: dist) unless dist.directory? && !dist.empty?
+            op.extras << "#{dist}/*" unless flag == :poetry
           end
-          append_value out
+          op.append
           run(from: :"#{flag}:publish")
         end
 
@@ -415,11 +422,11 @@ module Squared
           out = append_pip(nil, opts, from: flag)
           case flag
           when :uninstall
-            raise_error('no packages given', subject: name, hint: 'uninstall') if out.empty?
+            raise_error('no packages listed', hint: 'uninstall') if out.empty?
             cmd.merge(out)
           when :freeze
             venv_init
-            ret = basepath(out.shift || 'requirements.txt')
+            ret = basepath(out.shift || DEP_PYTHON[4])
             cmd << '>' << shell_quote(ret)
             option_clear out
           end
@@ -431,14 +438,14 @@ module Squared
           case key
           when :dependfile
             req = basepath(*val)
-            if (index = REQUIREMENTS.index(req.basename.to_s))
+            if (index = DEP_PYTHON.index(req.basename.to_s))
               @dependindex = index
               @dependfile = req
             else
               log.warn "variable_set: @#{key}=#{req} (not supported)"
             end
-          when :venv
-            @venv = val.empty? ? nil : basepath(*val)
+          when :venv, :editable
+            instance_variable_set(:"@#{key}", val.empty? ? nil : basepath(*val))
           else
             super
           end
@@ -455,62 +462,69 @@ module Squared
         private
 
         def pip_session(*cmd)
-          session('pip', *cmd, path: venv.nil?)
+          session('pip', *cmd, *preopts, path: venv.nil?)
         end
 
         def python_session(*cmd, opts: nil)
-          return session('python', *cmd, path: venv.nil?) unless opts
+          return session('python', *preopts(quiet: false), *cmd, path: venv.nil?) unless opts
 
-          out = []
-          opts = option_sanitize(opts, OPT_PYTHON[:common], target: out, single: /^v+$/).first
-          ret = session('python', *out, *cmd, path: venv.nil?)
-          [ret, opts]
+          op = OptionPartition.new(opts, OPT_PYTHON[:common], project: self, single: /^v+$/)
+          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
+          ret
         end
 
         def hatch_session(*cmd, opts: nil)
-          return session('hatch', *cmd, path: venv.nil?) unless opts
+          return session('hatch', *preopts, *cmd, path: venv.nil?) unless opts
 
-          out = []
-          opts = option_sanitize(opts, OPT_HATCH[:common], target: out, single: /^(?:v+|q+)$/).first
-          ret = session('hatch', *out, *cmd, path: venv.nil?)
-          [ret, opts]
+          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, from: nil)
+        def append_pip(flag, opts, target: @session, from: nil)
           if !from || opts.empty?
-            append_global
+            append_global(target: target)
             return []
           end
-          opts, pat = option_sanitize(opts, OPT_PIP[from] + OPT_PIP[:common], single: /^(?:v+|q+)$/)
-          append_global
+          op = OptionPartition.new(opts, OPT_PIP[from] + OPT_PIP[:common], target, project: self, single: singleopt)
+          append_global(target: target)
           if from == :install
-            out = []
             edit = nil
-            opts.each do |opt|
-              if opt =~ pat
+            op.each do |opt|
+              if opt =~ op.values
                 case $1
                 when 'e', 'editable'
+                  op.found << edit if edit && flag == :editable
                   edit = $2
                 end
               elsif flag == :editable && !edit
                 edit = opt
               else
-                out << opt
+                op.found << opt
               end
             end
+            op.swap
             if edit
-              edit = editable(edit)
+              edit = basepath(edit) unless %r{^[a-z]+(?:\+[a-z]+)?://}i.match?(edit)
               if flag == :editable
-                out << edit
+                op.extras << edit
               else
                 target << quote_option('e', edit)
               end
             end
             case flag
             when :editable, :upgrade
-              out
+              op.extras
             else
-              option_clear out
+              op.clear
               []
             end
           else
@@ -518,8 +532,25 @@ module Squared
           end
         end
 
+        def append_editable(target: @session)
+          return if requirements?
+
+          if (val = option('editable', 'e', target: target, ignore: false))
+            session_delete('e', 'editable', target: target)
+            case val
+            when '0', 'false'
+              return
+            else
+              val = basepath(val)
+            end
+          elsif session_arg?('e', 'editable', target: target) || !(val = editable)
+            return
+          end
+          target << quote_option('e', val)
+        end
+
         def append_global(target: @session)
-          if (val = option('cache-dir'))
+          if (val = option('cache-dir', target: target))
             target << case val
                       when '0', 'false'
                         '--no-cache-dir'
@@ -527,17 +558,35 @@ module Squared
                         quote_option('cache-dir', basepath(val))
                       end
           end
-          target << shell_option('proxy', val) if (val = option('proxy'))
-          target << quote_option('python', basepath(val)) if (val = option('python'))
+          target << shell_option('proxy', val) if (val = option('proxy', target: target))
+          target << quote_option('python', basepath(val)) if (val = option('python', target: target))
           append_nocolor(target: target)
         end
 
-        def editable(val)
-          %r{^[a-z]+(?:\+[a-z]+)?://}i.match?(val) ? val : basepath(val)
+        def singleopt(flag = nil)
+          case flag
+          when :python
+            /^(?:v+|q+|b+)$/
+          when :twine
+            nil
+          else
+            /^(?:v+|q+)$/
+          end
+        end
+
+        def preopts(quiet: true)
+          ret = []
+          case verbose
+          when false
+            ret << '--quiet' if quiet
+          when Numeric
+            ret << "-#{'v' * verbose}" if verbose > 0
+          end
+          ret
         end
 
         def variables
-          (super + %i[venv]).freeze
+          (super + %i[venv editable]).freeze
         end
 
         def runenv
@@ -551,7 +600,7 @@ module Squared
         end
 
         def venvbin
-          @venv.join(workspace.windows? ? 'Scripts' : 'bin')
+          @venv&.join(workspace.windows? ? 'Scripts' : 'bin')
         end
 
         def venv_set(val)
@@ -574,10 +623,14 @@ module Squared
           return if !venv || (venvbin.directory? && !venvbin.empty?)
 
           puts log_message(Logger::INFO, venv, subject: 'venv', hint: 'init')
-          cmd = python_session '-m venv', shell_option('prompt', name), '--upgrade-deps', shell_quote(venv)
+          cmd = session 'python', '-m venv', shell_option('prompt', name), '--upgrade-deps', shell_quote(venv)
           run(cmd, false, exception: true, banner: false)
           puts log_message(Logger::INFO, venv, subject: 'venv', hint: 'created')
         end
+
+        def requirements?
+          dependtype == 5
+        end
       end
 
       Application.implement Python