wxPython-zombie 3.1.5.8__cp313-cp313-win_amd64.whl

wx/demo/PopupWindow.py

@@ -0,0 +1,227 @@
+#!/usr/bin/env python
+
+# 11/30/2003 - Jeff Grimmett (grimmtooth@softhome.net)
+#
+# o Some issues with the listbox example; I tried correcting
+#   it but it's still not working the way it should. Commented
+#   out for now, as I found it.
+
+
+import wx
+
+#---------------------------------------------------------------------------
+
+class TestPopup(wx.PopupWindow):
+    """Adds a bit of text and mouse movement to the wx.PopupWindow"""
+    def __init__(self, parent, style):
+        wx.PopupWindow.__init__(self, parent, style)
+        pnl = self.pnl = wx.Panel(self)
+        pnl.SetBackgroundColour("CADET BLUE")
+
+
+        st = wx.StaticText(pnl, -1,
+                          "This is a special kind of top level\n"
+                          "window that can be used for\n"
+                          "popup menus, combobox popups\n"
+                          "and such.\n\n"
+                          "Try positioning the demo near\n"
+                          "the bottom of the screen and \n"
+                          "hit the button again.\n\n"
+                          "In this demo this window can\n"
+                          "be dragged with the left button\n"
+                          "and closed with the right."
+                          ,
+                          pos=(10,10))
+
+        sz = st.GetBestSize()
+        self.SetSize( (sz.width+20, sz.height+20) )
+        pnl.SetSize( (sz.width+20, sz.height+20) )
+
+        pnl.Bind(wx.EVT_LEFT_DOWN, self.OnMouseLeftDown)
+        pnl.Bind(wx.EVT_MOTION, self.OnMouseMotion)
+        pnl.Bind(wx.EVT_LEFT_UP, self.OnMouseLeftUp)
+        pnl.Bind(wx.EVT_RIGHT_UP, self.OnRightUp)
+
+        st.Bind(wx.EVT_LEFT_DOWN, self.OnMouseLeftDown)
+        st.Bind(wx.EVT_MOTION, self.OnMouseMotion)
+        st.Bind(wx.EVT_LEFT_UP, self.OnMouseLeftUp)
+        st.Bind(wx.EVT_RIGHT_UP, self.OnRightUp)
+
+        wx.CallAfter(self.Refresh)
+
+
+    def OnMouseLeftDown(self, evt):
+        self.Refresh()
+        self.ldPos = evt.GetEventObject().ClientToScreen(evt.GetPosition())
+        self.wPos = self.ClientToScreen((0,0))
+        self.pnl.CaptureMouse()
+
+    def OnMouseMotion(self, evt):
+        if evt.Dragging() and evt.LeftIsDown():
+            dPos = evt.GetEventObject().ClientToScreen(evt.GetPosition())
+            nPos = (self.wPos.x + (dPos.x - self.ldPos.x),
+                    self.wPos.y + (dPos.y - self.ldPos.y))
+            self.Move(nPos)
+
+    def OnMouseLeftUp(self, evt):
+        if self.pnl.HasCapture():
+            self.pnl.ReleaseMouse()
+
+    def OnRightUp(self, evt):
+        self.Show(False)
+        wx.CallAfter(self.Destroy)
+
+
+
+class TestTransientPopup(wx.PopupTransientWindow):
+    """Adds a bit of text and mouse movement to the wx.PopupWindow"""
+    def __init__(self, parent, style, log):
+        wx.PopupTransientWindow.__init__(self, parent, style)
+        self.log = log
+        panel = wx.Panel(self)
+        panel.SetBackgroundColour("#FFB6C1")
+
+        st = wx.StaticText(panel, -1,
+                          "wx.PopupTransientWindow is a\n"
+                          "wx.PopupWindow which disappears\n"
+                          "automatically when the user\n"
+                          "clicks the mouse outside it or if it\n"
+                          "(or its first child) loses focus in \n"
+                          "any other way.")
+        btn = wx.Button(panel, -1, "Press Me")
+        spin = wx.SpinCtrl(panel, -1, "Hello", size=(100,-1))
+        btn.Bind(wx.EVT_BUTTON, self.OnButton)
+
+        sizer = wx.BoxSizer(wx.VERTICAL)
+        sizer.Add(st, 0, wx.ALL, 5)
+        sizer.Add(btn, 0, wx.ALL, 5)
+        sizer.Add(spin, 0, wx.ALL, 5)
+        panel.SetSizer(sizer)
+
+        sizer.Fit(panel)
+        sizer.Fit(self)
+        self.Layout()
+
+
+    def ProcessLeftDown(self, evt):
+        self.log.write("ProcessLeftDown: %s\n" % evt.GetPosition())
+        return wx.PopupTransientWindow.ProcessLeftDown(self, evt)
+
+    def OnDismiss(self):
+        self.log.write("OnDismiss\n")
+
+    def OnButton(self, evt):
+        btn = evt.GetEventObject()
+        if btn.GetLabel() == "Press Me":
+            btn.SetLabel("Pressed")
+        else:
+            btn.SetLabel("Press Me")
+
+
+
+class TestPanel(wx.Panel):
+    def __init__(self, parent, log):
+        wx.Panel.__init__(self, parent, -1)
+        self.log = log
+
+        b = wx.Button(self, -1, "Show wx.PopupWindow", (25, 50))
+        self.Bind(wx.EVT_BUTTON, self.OnShowPopup, b)
+
+        b = wx.Button(self, -1, "Show wx.PopupTransientWindow", (25, 95))
+        self.Bind(wx.EVT_BUTTON, self.OnShowPopupTransient, b)
+
+        # This isn't working so well, not sure why. Commented out for
+        # now.
+
+#        b = wx.Button(self, -1, "Show wx.PopupWindow with listbox", (25, 140))
+#        self.Bind(wx.EVT_BUTTON, self.OnShowPopupListbox, b)
+
+
+    def OnShowPopup(self, evt):
+        win = TestPopup(self.GetTopLevelParent(), wx.SIMPLE_BORDER)
+        #win = TestPopupWithListbox(self, wx.SIMPLE_BORDER, self.log)
+
+        # Show the popup right below or above the button
+        # depending on available screen space...
+        btn = evt.GetEventObject()
+        pos = btn.ClientToScreen( (0,0) )
+        sz =  btn.GetSize()
+        win.Position(pos, (0, sz[1]))
+
+        win.Show(True)
+
+
+    def OnShowPopupTransient(self, evt):
+        win = TestTransientPopup(self,
+                                 wx.SIMPLE_BORDER,
+                                 self.log)
+
+        # Show the popup right below or above the button
+        # depending on available screen space...
+        btn = evt.GetEventObject()
+        pos = btn.ClientToScreen( (0,0) )
+        sz =  btn.GetSize()
+        win.Position(pos, (0, sz[1]))
+
+        win.Popup()
+
+
+    def OnShowPopupListbox(self, evt):
+        win = TestPopupWithListbox(self, wx.NO_BORDER, self.log)
+
+        # Show the popup right below or above the button
+        # depending on available screen space...
+        btn = evt.GetEventObject()
+        pos = btn.ClientToScreen( (0,0) )
+        sz =  btn.GetSize()
+        win.Position(pos, (0, sz[1]))
+
+        win.Show(True)
+
+
+
+# This class is currently not implemented in the demo. It does not
+# behave the way it should, so for the time being it's only here
+# for show. If you figure out how to make it work, please send
+# a corrected file to Robin!
+class TestPopupWithListbox(wx.PopupWindow):
+    def __init__(self, parent, style, log):
+        wx.PopupWindow.__init__(self, parent, style)
+        self.log = log
+        import keyword
+        self.lb = wx.ListBox(self, -1, choices = keyword.kwlist)
+        #sz = self.lb.GetBestSize()
+        self.SetSize((150, 75)) #sz)
+        self.lb.SetSize(self.GetClientSize())
+        self.lb.SetFocus()
+        self.Bind(wx.EVT_LISTBOX, self.OnListBox)
+        self.Bind(wx.EVT_LISTBOX_DCLICK, self.OnListBoxDClick)
+
+    def OnListBox(self, evt):
+        obj = evt.GetEventObject()
+        self.log.write("OnListBox: %s\n" % obj)
+        self.log.write('Selected: %s\n' % obj.GetString(evt.GetInt()))
+        evt.Skip()
+
+    def OnListBoxDClick(self, evt):
+        self.Hide()
+        self.Destroy()
+
+#---------------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+    win = TestPanel(nb, log)
+    return win
+
+#---------------------------------------------------------------------------
+
+
+overview = """\
+"""
+
+
+if __name__ == '__main__':
+    import sys,os
+    import run
+    run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+

wx/demo/PrintDialog.py

@@ -0,0 +1,60 @@
+#!/usr/bin/env python
+
+import wx
+
+#---------------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+    def __init__(self, parent, log):
+        self.log = log
+        wx.Panel.__init__(self, parent, -1)
+
+        b = wx.Button(self, -1, "Create and Show a PrintDialog", (50,50))
+        self.Bind(wx.EVT_BUTTON, self.OnButton, b)
+
+
+    def OnButton(self, evt):
+        data = wx.PrintDialogData()
+
+        data.EnableSelection(True)
+        data.EnablePrintToFile(True)
+        data.EnablePageNumbers(True)
+        data.SetMinPage(1)
+        data.SetMaxPage(5)
+        # data.SetAllPages(True)
+
+        dlg = wx.PrintDialog(self, data)
+
+        if dlg.ShowModal() == wx.ID_OK:
+            data = dlg.GetPrintDialogData()
+            self.log.WriteText('GetAllPages: %d\n' % data.GetAllPages())
+
+        dlg.Destroy()
+
+
+#---------------------------------------------------------------------------
+
+
+def runTest(frame, nb, log):
+    win = TestPanel(nb, log)
+    return win
+
+#---------------------------------------------------------------------------
+
+
+overview = """\
+This class represents the print and print setup common dialogs. You may obtain
+a wx.PrinterDC device context from a successfully dismissed print dialog.
+
+User information is stored in a wx.PrintDialogData object that is passed to the
+dialog at creation time, and it is filled in by the user. As with other dialogs,
+do not use this data once the dialog is dismissed, and do not destroy the dialog
+until you have everything you need from it.
+
+"""
+
+
+if __name__ == '__main__':
+    import sys,os
+    import run
+    run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])

wx/demo/PrintFramework.py

@@ -0,0 +1,227 @@
+#!/usr/bin/env python
+
+import wx
+import ScrolledWindow
+
+#----------------------------------------------------------------------
+
+
+class MyPrintout(wx.Printout):
+    def __init__(self, canvas, log):
+        wx.Printout.__init__(self)
+        self.canvas = canvas
+        self.log = log
+
+    def OnBeginDocument(self, start, end):
+        self.log.WriteText("MyPrintout.OnBeginDocument\n")
+        return super(MyPrintout, self).OnBeginDocument(start, end)
+
+    def OnEndDocument(self):
+        self.log.WriteText("MyPrintout.OnEndDocument\n")
+        super(MyPrintout, self).OnEndDocument()
+
+    def OnBeginPrinting(self):
+        self.log.WriteText("MyPrintout.OnBeginPrinting\n")
+        super(MyPrintout, self).OnBeginPrinting()
+
+    def OnEndPrinting(self):
+        self.log.WriteText("MyPrintout.OnEndPrinting\n")
+        super(MyPrintout, self).OnEndPrinting()
+
+    def OnPreparePrinting(self):
+        self.log.WriteText("MyPrintout.OnPreparePrinting\n")
+        super(MyPrintout, self).OnPreparePrinting()
+
+    def HasPage(self, page):
+        self.log.WriteText("MyPrintout.HasPage: %d\n" % page)
+        if page <= 2: # we only have 2 pages in this document
+            return True
+        else:
+            return False
+
+    def GetPageInfo(self):
+        self.log.WriteText("MyPrintout.GetPageInfo\n")
+        return (1, 2, 1, 2)
+
+    def OnPrintPage(self, page):
+        self.log.WriteText("MyPrintout.OnPrintPage: %d\n" % page)
+        dc = self.GetDC()
+
+        #-------------------------------------------
+        # One possible method of setting scaling factors...
+
+        maxX = self.canvas.getWidth()
+        maxY = self.canvas.getHeight()
+
+        # Let's have at least 50 device units margin
+        marginX = 50
+        marginY = 50
+
+        # Add the margin to the graphic size
+        maxX = maxX + (2 * marginX)
+        maxY = maxY + (2 * marginY)
+
+        # Get the size of the DC in pixels
+        (w, h) = dc.GetSize()
+
+        # Calculate a suitable scaling factor
+        scaleX = float(w) / maxX
+        scaleY = float(h) / maxY
+
+        # Use x or y scaling factor, whichever fits on the DC
+        actualScale = min(scaleX, scaleY)
+
+        # Calculate the position on the DC for centering the graphic
+        posX = (w - (self.canvas.getWidth() * actualScale)) / 2.0
+        posY = (h - (self.canvas.getHeight() * actualScale)) / 2.0
+
+        # Set the scale and origin
+        dc.SetUserScale(actualScale, actualScale)
+        dc.SetDeviceOrigin(int(posX), int(posY))
+
+        #-------------------------------------------
+        self.canvas.DoDrawing(dc, True)
+        dc.DrawText("Page: %d" % page, marginX/2, maxY-marginY)
+
+        return True
+
+
+#----------------------------------------------------------------------
+
+
+class TestPrintPanel(wx.Panel):
+    def __init__(self, parent, frame, log):
+        wx.Panel.__init__(self, parent, -1)
+        self.log = log
+        self.frame = frame
+
+        self.printData = wx.PrintData()
+        self.printData.SetPaperId(wx.PAPER_LETTER)
+        self.printData.SetPrintMode(wx.PRINT_MODE_PRINTER)
+
+        self.box = wx.BoxSizer(wx.VERTICAL)
+        self.canvas = ScrolledWindow.MyCanvas(self)
+        self.box.Add(self.canvas, 1, wx.GROW)
+
+        subbox = wx.BoxSizer(wx.HORIZONTAL)
+        btn = wx.Button(self, -1, "Page Setup")
+        self.Bind(wx.EVT_BUTTON, self.OnPageSetup, btn)
+        subbox.Add(btn, 1, wx.GROW | wx.ALL, 2)
+
+        btn = wx.Button(self, -1, "Print Preview")
+        self.Bind(wx.EVT_BUTTON, self.OnPrintPreview, btn)
+        subbox.Add(btn, 1, wx.GROW | wx.ALL, 2)
+
+        btn = wx.Button(self, -1, "Print")
+        self.Bind(wx.EVT_BUTTON, self.OnDoPrint, btn)
+        subbox.Add(btn, 1, wx.GROW | wx.ALL, 2)
+
+        self.box.Add(subbox, 0, wx.GROW)
+
+        self.SetAutoLayout(True)
+        self.SetSizer(self.box)
+
+
+    def OnPageSetup(self, evt):
+        psdd = wx.PageSetupDialogData(self.printData)
+        psdd.EnablePrinter(True)
+        # psdd.CalculatePaperSizeFromId()
+        dlg = wx.PageSetupDialog(self, psdd)
+        dlg.ShowModal()
+
+        # this makes a copy of the wx.PrintData instead of just saving
+        # a reference to the one inside the PrintDialogData that will
+        # be destroyed when the dialog is destroyed
+        self.printData = wx.PrintData( dlg.GetPageSetupData().GetPrintData() )
+
+        dlg.Destroy()
+
+    def OnPrintPreview(self, event):
+        data = wx.PrintDialogData(self.printData)
+        printout = MyPrintout(self.canvas, self.log)
+        printout2 = MyPrintout(self.canvas, self.log)
+        self.preview = wx.PrintPreview(printout, printout2, data)
+
+        if not self.preview.IsOk():
+            self.log.WriteText("Houston, we have a problem...\n")
+            return
+
+        pfrm = wx.PreviewFrame(self.preview, self.frame, "This is a print preview")
+
+        pfrm.Initialize()
+        pfrm.SetPosition(self.frame.GetPosition())
+        pfrm.SetSize(self.frame.GetSize())
+        pfrm.Show(True)
+
+    def OnDoPrint(self, event):
+        pdd = wx.PrintDialogData(self.printData)
+        pdd.SetToPage(2)
+        printer = wx.Printer(pdd)
+        printout = MyPrintout(self.canvas, self.log)
+
+        if not printer.Print(self.frame, printout, True):
+            wx.MessageBox("There was a problem printing.\nPerhaps your current printer is not set correctly?", "Printing", wx.OK)
+        else:
+            self.printData = wx.PrintData( printer.GetPrintDialogData().GetPrintData() )
+        printout.Destroy()
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+    win = TestPrintPanel(nb, frame, log)
+    return win
+
+
+#----------------------------------------------------------------------
+
+
+
+overview = """\
+<html>
+<body>
+<h1>PrintFramework</h1>
+
+This is an overview of the classes and methods used to print documents.
+It also demonstrates how to do print previews and invoke the printer
+setup dialog.
+
+<p>Classes demonstrated here:<P>
+<ul>
+    <li><b>wx.Printout()</b> - This class encapsulates the functionality of printing out
+        an application document. A new class must be derived and members overridden
+        to respond to calls such as OnPrintPage and HasPage. Instances of this class
+        are passed to wx.Printer.Print() or a wx.PrintPreview object to initiate
+        printing or previewing.<P><p>
+
+    <li><b>wx.PrintData()</b> - This class holds a variety of information related to
+        printers and printer device contexts. This class is used to create a
+        wx.PrinterDC and a wx.PostScriptDC. It is also used as a data member of
+        wx.PrintDialogData and wx.PageSetupDialogData, as part of the mechanism for
+        transferring data between the print dialogs and the application.<p><p>
+
+    <li><b>wx.PrintDialog()</b> - This class represents the print and print setup
+        common dialogs. You may obtain a wx.PrinterDC device context from a
+        successfully dismissed print dialog.<p><p>
+
+    <li><b>wx.PrintPreview()</b> - Objects of this class manage the print preview
+        process. The object is passed a wx.Printout object, and the wx.PrintPreview
+        object itself is passed to a wx.PreviewFrame object. Previewing is started by
+        initializing and showing the preview frame. Unlike wxPrinter.Print, flow of
+        control returns to the application immediately after the frame is shown.<p><p>
+</ul>
+
+<p>Other classes are also demonstrated, but this is the gist of the printer interface
+framework in wxPython.
+
+</body>
+</html>
+
+"""
+
+
+if __name__ == '__main__':
+    import sys,os
+    import run
+    run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+

wx/demo/Process.py

@@ -0,0 +1,168 @@
+#!/usr/bin/env python
+
+import wx
+
+#----------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+    def __init__(self, parent, ID, log):
+        wx.Panel.__init__(self, parent, ID)
+        self.log = log
+
+        self.process = None
+        self.Bind(wx.EVT_IDLE, self.OnIdle)
+
+        # We can either derive from wx.Process and override OnTerminate
+        # or we can let wx.Process send this window an event that is
+        # caught in the normal way...
+        self.Bind(wx.EVT_END_PROCESS, self.OnProcessEnded)
+
+
+        # Make the controls
+        prompt = wx.StaticText(self, -1, 'Command line:')
+        self.cmd = wx.TextCtrl(self, -1, 'python -u data/echo.py')
+        self.exBtn = wx.Button(self, -1, 'Execute')
+
+        self.out = wx.TextCtrl(self, -1, '',
+                               style=wx.TE_MULTILINE|wx.TE_READONLY|wx.TE_RICH2)
+
+        self.inp = wx.TextCtrl(self, -1, '', style=wx.TE_PROCESS_ENTER)
+        self.sndBtn = wx.Button(self, -1, 'Send')
+        self.termBtn = wx.Button(self, -1, 'Close Stream')
+        self.inp.Enable(False)
+        self.sndBtn.Enable(False)
+        self.termBtn.Enable(False)
+
+        # Hook up the events
+        self.Bind(wx.EVT_BUTTON, self.OnExecuteBtn, self.exBtn)
+        self.Bind(wx.EVT_BUTTON, self.OnSendText, self.sndBtn)
+        self.Bind(wx.EVT_BUTTON, self.OnCloseStream, self.termBtn)
+        self.Bind(wx.EVT_TEXT_ENTER, self.OnSendText, self.inp)
+
+
+        # Do the layout
+        box1 = wx.BoxSizer(wx.HORIZONTAL)
+        box1.Add(prompt, 0, wx.ALIGN_CENTER)
+        box1.Add(self.cmd, 1, wx.ALIGN_CENTER|wx.LEFT|wx.RIGHT, 5)
+        box1.Add(self.exBtn, 0)
+
+        box2 = wx.BoxSizer(wx.HORIZONTAL)
+        box2.Add(self.inp, 1, wx.ALIGN_CENTER)
+        box2.Add(self.sndBtn, 0, wx.LEFT, 5)
+        box2.Add(self.termBtn, 0, wx.LEFT, 5)
+
+        sizer = wx.BoxSizer(wx.VERTICAL)
+        sizer.Add(box1, 0, wx.EXPAND|wx.ALL, 10)
+        sizer.Add(self.out, 1, wx.EXPAND|wx.ALL, 10)
+        sizer.Add(box2, 0, wx.EXPAND|wx.ALL, 10)
+
+        self.SetSizer(sizer)
+        self.SetAutoLayout(True)
+
+
+    def OnExecuteBtn(self, evt):
+        cmd = self.cmd.GetValue()
+
+        self.process = wx.Process(self)
+        self.process.Redirect()
+        pid = wx.Execute(cmd, wx.EXEC_ASYNC, self.process)
+        self.log.write('OnExecuteBtn: "%s" pid: %s\n' % (cmd, pid))
+
+        self.inp.Enable(True)
+        self.sndBtn.Enable(True)
+        self.termBtn.Enable(True)
+        self.cmd.Enable(False)
+        self.exBtn.Enable(False)
+        self.inp.SetFocus()
+
+
+    def OnSendText(self, evt):
+        text = self.inp.GetValue()
+        self.inp.SetValue('')
+        self.log.write('OnSendText: "%s"\n' % text)
+        text += '\n'
+        self.process.GetOutputStream().write(text.encode('utf-8'))
+        self.inp.SetFocus()
+
+
+    def OnCloseStream(self, evt):
+        self.log.write('OnCloseStream\n')
+        #print("b4 CloseOutput")
+        self.process.CloseOutput()
+        #print("after CloseOutput")
+
+    def OnIdle(self, evt):
+        if self.process is not None:
+            stream = self.process.GetInputStream()
+
+            if stream.CanRead():
+                text = stream.read()
+                self.out.AppendText(text)
+
+
+    def OnProcessEnded(self, evt):
+        self.log.write('OnProcessEnded, pid:%s,  exitCode: %s\n' %
+                       (evt.GetPid(), evt.GetExitCode()))
+
+        stream = self.process.GetInputStream()
+
+        if stream.CanRead():
+            text = stream.read()
+            self.out.AppendText(text)
+
+        self.process.Destroy()
+        self.process = None
+        self.inp.Enable(False)
+        self.sndBtn.Enable(False)
+        self.termBtn.Enable(False)
+        self.cmd.Enable(True)
+        self.exBtn.Enable(True)
+
+
+    def ShutdownDemo(self):
+        # Called when the demo application is switching to a new sample. Tell
+        # the process to close (by closign its output stream) and then wait
+        # for the termination signals to be received and processed.
+        if self.process is not None:
+            self.process.CloseOutput()
+            wx.MilliSleep(250)
+            wx.Yield()
+            self.process = None
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+    win = TestPanel(nb, -1, log)
+    return win
+
+
+#----------------------------------------------------------------------
+
+
+overview = """\
+<html><body>
+<h2>wx.Process</h2>
+
+wx.Process lets you get notified when an asynchronous child process
+started by wxExecute terminates, and also to get input/output streams
+for the child process's stdout, stderr and stdin.
+
+<p>
+This demo launches a simple python script that echos back on stdout
+lines that it reads from stdin.  You can send text to the echo
+process's stdin by typing in the lower textctrl and clicking Send.
+
+<p>
+Clicking the Close Stream button will close the demo's end of the
+stdin pipe to the child process.  In our case that will cause the
+child process to exit its main loop.
+
+</body><html>
+"""
+
+
+if __name__ == '__main__':
+    import sys,os
+    import run
+    run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])