'module' object has no attribute 'element_make_factory'

The error is actually very simple: the gst module has no element_make_factory method. Have a look at my following interactive session for some more info:

>>> import gst
>>> gst.element_make_factory
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'module' object has no attribute 'element_make_factory'
>>> gst.some_none_existent_method
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'module' object has no attribute 'some_none_existent_method'
>>> dir(gst)
['ACTIVATE_NONE', 'ACTIVATE_PULL', 'ACTIVATE_PUSH', 'ALLOC_TRACE_LIVE', 

#### Snipping out lots of results...

'warnings', 'xml_make_element', 'xml_write', 'xml_write_file']
>>> 'element_make_factory' in dir(gst)
False
>>> 'element_factory_make' in dir(gst)
True
>>> gst.element_factory_make
<built-in function element_factory_make>
>>>

Here's some working code...it's still in progress(but it works). It should have a glade file and some button callbacks implemented. The pygi Gst part works though.

'''
Example multimedia player

dependencies:
gir and GdkX11

adapted from here:
http://bazaar.launchpad.net/~jderose/+junk/gst-examples/view/head:/video-player-1.0
'''

#use gir if you're using quickly...or just use it anyway
from gi.repository import GObject, Gst, Gtk, GdkX11, GstVideo

import os, base64

class DemoFiles:
    '''
    Smashing our .glade file and our mp3 into our py
    '''
    def __init__(self, root):
        self.root = root
        self.glade = '' +\
            ''
        self.testaudio = '' +\
            ''

    def drop_files(self):
        pass

class Settings:
    '''
    Using our home directory
    '''
    def __init__(self, root):
        self.root = root
        home = os.environ['HOME']
        working = os.path.join(home, 'com.example.pygi.gst')
        uri = os.path.join(working, 'makeitbetter.mp3')
        glade = os.path.join(working, 'player.glade')

        self.params = {
                       'HOME': home,
                       'WORKING': working,
                       'DEMOFILE': uri,
                       'GLADE': glade
                       }

    def __call__(self, param):
        return self.params[param]

    def set_param(self, param, data):
        self.params[param] = data
        return True

class Handler:
    '''
    Callbacks for Glade
    '''
    def __init__(self, root):
        self.root = root
        pass

    def on_file_button_clicked(self, *args):
        pass

    def on_file_ok_button_clicked(self, *args):
        print args[0]
        self.root.ui.gst.playbin.set_property('uri', 'file://' + args[0])
        self.root.ui.gst.pipeline.set_state(Gst.State.PLAYING)        

    def on_file_cancel_button_clicked(self, *args):
        pass

    def on_main_win_delete_event(self, *args):
        #clean up our pipeline
        self.root.ui.gst.pipeline.set_state(Gst.State.NULL)
        Gtk.main_quit()   

class GstreamerStuff:
    '''
    All the gstreamer stuff
    '''
    def __init__(self, root):             
        self.root = root

        #Threading init
        GObject.threads_init()
        Gst.init(None)

        # GStreamer init
        self.pipeline = Gst.Pipeline()
        self.bus = self.pipeline.get_bus()
        self.bus.add_signal_watch()
        self.bus.connect('message::eos', self.on_eos)
        self.bus.connect('message::error', self.on_error)

        # This is needed to make the video output in our DrawingArea:
        self.bus.enable_sync_message_emission()
        self.bus.connect('sync-message::element', self.on_sync_message)

        # Create GStreamer elements
        self.playbin = Gst.ElementFactory.make('playbin', None)

        # Add playbin to the pipeline
        self.pipeline.add(self.playbin)

        self.xid = ''

    def on_sync_message(self, bus, msg):
        if msg.get_structure().get_name() == 'prepare-window-handle':
            msg.src.set_window_handle(self.xid)

    def on_eos(self, bus, msg):
        self.root.ui.update_status('Seeking to start of video')
        self.pipeline.seek_simple(
            Gst.Format.TIME,        
            Gst.SeekFlags.FLUSH | Gst.SeekFlags.KEY_UNIT,
            0
        )

    def on_error(self, bus, msg):
        self.root.ui.update_status(msg.parse_error())

    def set_xid(self, xid):
        self.xid = xid

class UI:
    '''
    User interface code
    '''
    def __init__(self, root):
        self.root = root

        #Handle Gtk setup
        self.builder = Gtk.Builder()
        self.handler = Handler(root)
        #Load the glade file
        self.builder.add_from_file(self.root.settings('GLADE'))
        #Connect callbacks
        self.builder.connect_signals(self.handler)

        #Handle Gst setup
        self.gst = GstreamerStuff(root)

    def init(self):
        self.show_main()
        self.gst.set_xid(self.builder.get_object('main_drawing_area').get_property('window').get_xid())

    def show_main(self):
        self.builder.get_object('main_win').show_all()

    def update_status(self, status):
        print('Status bar update')
        self.builder.get_object('status_bar')

class SamplePlayer:
    '''
    Meat
    '''
    def __init__(self):
        #Settings instance
        self.settings = Settings(self)

        #Dump demo files
        demo = DemoFiles(self)
        demo.drop_files()

        #UI Init - I put gstreamer in here
        self.ui = UI(self)

    def run(self):
        self.ui.init()
        print('Trying with: ' + self.settings('DEMOFILE'))
        self.ui.handler.on_file_ok_button_clicked(self.settings('DEMOFILE'))
        Gtk.main()

if __name__ == '__main__':
    player = SamplePlayer()
    player.run()