Simple Python + Gtk.Window
I don't think your considerations are a big problem.

However what I think is a bigger problem is the amount of verbosity and repetition in your code. While the code is readable as is, adding more elements in the future will make your __init__() method inflate and become unreadable.

This is because you are adding each Element individually. In large applications this is largely unfeasible when you have more than a dozen widgets, for reasons I am sure you can understand.

There are a couple of solutions to this:

Generate Layout using code

instead of doing this:

self.window.new_button = Gtk.Button(label="New")
self.window.new_button.connect("clicked", self.on_new_clicked)
self.window.hbox.pack_start(self.window.new_button, False, False, 0)

# ... repeat for all buttons


you can do this

buttons = [("New", self.on_new_clicked),
           ("Save", self.on_save_clicked),
           ("eMail", self.on_email_clicked),
           ("Pen", self.on_pen_clicked),
          ]

for name, callback in buttons:
    b = Gtk.Button(label=button)
    b.connect("clicked", callback)
    self.window.hbox.pack_start(b, False, False, 0)


Subclass standard widgets

Often you can also clean up your application by subclassing other widgets:

class myButtonBox(Gtk.ButtonBox):
    def __init__(self, *args, **kwargs):

        # add all buttons to self here

        super().__init__(*args, **kwargs)
        # note: super() without args works only in new versions of Python


Seperate Interface and logic by using GtkBuilder xml

I am mentioning this last since this is the best option, but not very frequently worth the effort.

The Gtk 3 Tutorial has a very nice page on GtkBuilder


  The Gtk.Builder class offers you the opportunity to design user
  interfaces without writing a single line of code. This is possible
  through describing the interface by a XML file and then loading the
  XML description at runtime and create the objects automatically, which
  the Builder class does for you. For the purpose of not needing to
  write the XML manually the Glade application lets you create the user
  interface in a WYSIWYG (what you see is what you get) manner
  
  This method has several advantages:
  
  
  Less code needs to be written.
  UI changes can be seen more quickly, so UIs are able to improve.
  Designers without programming skills can create and edit UIs.
  The description of the user interface is independent from the programming language being used.
  
  
  There is still code required for handling interface changes triggered by the user,
  but Gtk.Builder allows you to focus on implementing that
  functionality.