gphoto2_doc.txt

Help on package gphoto2:

NAME
    gphoto2

PACKAGE CONTENTS
    _abilities_list
    _camera
    _context
    _file
    _filesys
    _list
    _port_info_list
    _port_log
    _result
    _version
    _widget
    abilities_list
    camera
    context
    file
    filesys
    list
    port_info_list
    port_log
    result
    version
    widget

CLASSES
    builtins.Exception(builtins.BaseException)
        GPhoto2Error
    
    class GPhoto2Error(builtins.Exception)
     |  Exception raised by gphoto2 library errors
     |  
     |  Attributes:
     |      code   (int): the gphoto2 error code
     |      string (str): corresponding error message
     |  
     |  Method resolution order:
     |      GPhoto2Error
     |      builtins.Exception
     |      builtins.BaseException
     |      builtins.object
     |  
     |  Methods defined here:
     |  
     |  __init__(self, code)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |  
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |  
     |  __weakref__
     |      list of weak references to the object (if defined)
     |  
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.Exception:
     |  
     |  __new__(*args, **kwargs) from builtins.type
     |      Create and return a new object.  See help(type) for accurate signature.
     |  
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.BaseException:
     |  
     |  __delattr__(self, name, /)
     |      Implement delattr(self, name).
     |  
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |  
     |  __reduce__(...)
     |      helper for pickle
     |  
     |  __repr__(self, /)
     |      Return repr(self).
     |  
     |  __setattr__(self, name, value, /)
     |      Implement setattr(self, name, value).
     |  
     |  __setstate__(...)
     |  
     |  __str__(self, /)
     |      Return str(self).
     |  
     |  with_traceback(...)
     |      Exception.with_traceback(tb) --
     |      set self.__traceback__ to tb and return self.
     |  
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from builtins.BaseException:
     |  
     |  __cause__
     |      exception cause
     |  
     |  __context__
     |      exception context
     |  
     |  __dict__
     |  
     |  __suppress_context__
     |  
     |  __traceback__
     |  
     |  args

FUNCTIONS
    SWIG_PyInstanceMethod_New(...)
    
    gp_abilities_list_append(...)
        gp_abilities_list_append(CameraAbilitiesList list, CameraAbilities abilities) -> int
        
        Append the abilities to the list.  
        
        Parameters
        ----------
        * `list` :  
            CameraAbilitiesList  
        * `abilities` :  
            CameraAbilities  
        
        Returns
        -------
        a gphoto2 error code  
        
        This function is called by a camera library on camera_abilities() in
        order to inform libgphoto2 about a supported camera model.
        
        See also gphoto2.CameraAbilitiesList.append
    
    gp_abilities_list_count(...)
        gp_abilities_list_count(CameraAbilitiesList list) -> int
        
        Count the entries in the supplied list.  
        
        Parameters
        ----------
        * `list` :  
            a CameraAbilitiesList  
        
        Returns
        -------
        The number of entries or a gphoto2 error code
        
        See also gphoto2.CameraAbilitiesList.count
    
    gp_abilities_list_detect(...)
        gp_abilities_list_detect(CameraAbilitiesList list, PortInfoList info_list, Context context) -> int
        
        Parameters
        ----------
        * `list` :  
            a CameraAbilitiesList  
        * `info_list` :  
            the GPPortInfoList of ports to use for detection  
        * `l` :  
            a CameraList that contains the autodetected cameras after the call  
        * `context` :  
            a GPContext  
        
        Tries to detect any camera connected to the computer using the supplied
        list of supported cameras and the supplied info_list of ports.  
        
        Returns
        -------
        a gphoto2 error code
        
        See also gphoto2.CameraAbilitiesList.detect
    
    gp_abilities_list_get_abilities(...)
        gp_abilities_list_get_abilities(CameraAbilitiesList list, int index) -> int
        
        Retrieve the camera abilities of entry with supplied index number.  
        
        Parameters
        ----------
        * `list` :  
            a CameraAbilitiesList  
        * `index` :  
            index  
        * `abilities` :  
            pointer to CameraAbilities for returned data.  
        
        Returns
        -------
        a gphoto2 error code  
        
        Retrieves the camera abilities of entry with supplied index number.
        Typically, you would call gp_camera_set_abilities() afterwards in order
        to prepare the initialization of a camera.
        
        See also gphoto2.CameraAbilitiesList.get_abilities
    
    gp_abilities_list_load(...)
        gp_abilities_list_load(CameraAbilitiesList list, Context context) -> int
        
        Scans the system for camera drivers.  
        
        Parameters
        ----------
        * `list` :  
            a CameraAbilitiesList  
        * `context` :  
            a GPContext  
        
        Returns
        -------
        a gphoto2 error code  
        
        All supported camera models will then be added to the list.
        
        See also gphoto2.CameraAbilitiesList.load
    
    gp_abilities_list_load_dir(...)
        gp_abilities_list_load_dir(CameraAbilitiesList list, char const * dir, Context context) -> int
        
        
        
        See also gphoto2.CameraAbilitiesList.load_dir
    
    gp_abilities_list_lookup_model(...)
        gp_abilities_list_lookup_model(CameraAbilitiesList list, char const * model) -> int
        
        Search the list for an entry of given model name.  
        
        Parameters
        ----------
        * `list` :  
            a CameraAbilitiesList  
        * `model` :  
            a camera model name  
        
        Returns
        -------
        Index of entry or gphoto2 error code
        
        See also gphoto2.CameraAbilitiesList.lookup_model
    
    gp_abilities_list_new(...)
        gp_abilities_list_new() -> int
        
        Allocate the memory for a new abilities list.  
        
        Function to allocate the memory for a new abilities list.  
        
        Parameters
        ----------
        * `list` :  
            CameraAbilitiesList object to initialize  
        
        Returns
        -------
        gphoto2 error code  
        
        You would then call gp_abilities_list_load() in order to populate it.
        
        See also gphoto2.CameraAbilitiesList.new
    
    gp_abilities_list_reset(...)
        gp_abilities_list_reset(CameraAbilitiesList list) -> int
        
        Reset the list.  
        
        Parameters
        ----------
        * `list` :  
            a CameraAbilitiesList  
        
        Returns
        -------
        a gphoto2 error code
        
        See also gphoto2.CameraAbilitiesList.reset
    
    gp_camera_autodetect(...)
        gp_camera_autodetect(Context context) -> int
        
        Autodetect all detectable camera  
        
        Parameters
        ----------
        * `list` :  
            a CameraList that receives the autodetected cameras  
        * `context` :  
            a GPContext  
        
        Returns
        -------
        a gphoto2 error code  
        
        This camera will autodetected all cameras that can be autodetected. This
        will for instance detect all USB cameras.  
        
        CameraList *list; gp_list_new (&list); gp_camera_autodetect (list,
        context); ... done! ...
        
        See also gphoto2.Camera.autodetect
    
    gp_camera_capture(...)
        gp_camera_capture(Camera camera, CameraCaptureType type, Context context) -> int
        
        Captures an image, movie, or sound clip depending on the given `type`.  
        
        Parameters
        ----------
        * `camera` :  
            a Camera  
        * `type` :  
            a CameraCaptureType  
        * `path` :  
            a CameraFilePath  
        * `context` :  
            a GPContext  
        
        Returns
        -------
        a gphoto2 error code  
        
        The resulting file will be stored on the camera. The location gets
        stored in `path`. The file can then be downloaded using
        gp_camera_file_get.
        
        See also gphoto2.Camera.capture
    
    gp_camera_capture_preview(...)
        gp_camera_capture_preview(Camera camera, Context context) -> int
        
        Captures a preview that won't be stored on the camera but returned in
        supplied file.  
        
        Parameters
        ----------
        * `camera` :  
            a Camera  
        * `file` :  
            a CameraFile  
        * `context` :  
            a GPContext  
        
        Returns
        -------
        a gphoto2 error code  
        
        For example, you could use gp_capture_preview() for taking some sample
        pictures before calling gp_capture().
        
        See also gphoto2.Camera.capture_preview
    
    gp_camera_exit(...)
        gp_camera_exit(Camera camera, Context context) -> int
        
        Close connection to camera.  
        
        Parameters
        ----------
        * `camera` :  
            a Camera object  
        * `context` :  
            a GPContext object  
        
        Returns
        -------
        a gphoto2 error code.  
        
        Closes a connection to the camera and therefore gives other application
        the possibility to access the camera, too.  
        
        It is recommended that you call this function when you currently don't
        need the camera. The camera will get reinitialized by gp_camera_init()
        automatically if you try to access the camera again.
        
        See also gphoto2.Camera.exit
    
    gp_camera_file_delete(...)
        gp_camera_file_delete(Camera camera, char const * folder, char const * file, Context context) -> int
        
        Deletes the file from `folder`.  
        
        Parameters
        ----------
        * `camera` :  
            a Camera  
        * `folder` :  
            a folder  
        * `file` :  
            the name of a file  
        * `context` :  
            a GPContext  
        
        Returns
        -------
        a gphoto2 error code
        
        See also gphoto2.Camera.file_delete
    
    gp_camera_file_get(...)
        gp_camera_file_get(Camera camera, char const * folder, char const * file, CameraFileType type, Context context) -> int
        
        Retrieves a file from the Camera.  
        
        Parameters
        ----------
        * `camera` :  
            a Camera  
        * `folder` :  
            a folder  
        * `file` :  
            the name of a file  
        * `type` :  
            the CameraFileType  
        * `camera_file` :  
            a CameraFile  
        * `context` :  
            a GPContext  
        
        Returns
        -------
        a gphoto2 error code
        
        See also gphoto2.Camera.file_get
    
    gp_camera_file_get_info(...)
        gp_camera_file_get_info(Camera camera, char const * folder, char const * file, Context context) -> int
        
        Retrieves information about a file.  
        
        Parameters
        ----------
        * `camera` :  
            a Camera  
        * `folder` :  
            a folder  
        * `file` :  
            the name of the file  
        * `info` :  
        * `context` :  
            a GPContext  
        
        Returns
        -------
        a gphoto2 error code
        
        See also gphoto2.Camera.file_get_info
    
    gp_camera_file_read(...)
        gp_camera_file_read(Camera camera, char const * folder, char const * file, CameraFileType type, uint64_t offset, char * buf, Context context) -> int
        
        Reads a file partially from the Camera.  
        
        Parameters
        ----------
        * `camera` :  
            a Camera  
        * `folder` :  
            a folder  
        * `file` :  
            the name of a file  
        * `type` :  
            the CameraFileType  
        * `offset` :  
            the offset into the camera file  
        * `data` :  
            the buffer receiving the data  
        * `size` :  
            the size to be read and that was read. (Note: size should not exceed
            32 bits)  
        * `context` :  
            a GPContext  
        
        Returns
        -------
        a gphoto2 error code
        
        See also gphoto2.Camera.file_read
    
    gp_camera_file_set_info(...)
        gp_camera_file_set_info(Camera camera, char const * folder, char const * file, CameraFileInfo info, Context context) -> int
        
        Sets some file properties like name or permissions.  
        
        Parameters
        ----------
        * `camera` :  
            a Camera  
        * `folder` :  
            a folder  
        * `file` :  
            the name of a file  
        * `info` :  
            the CameraFileInfo  
        * `context` :  
            a GPContext  
        
        Returns
        -------
        a gphoto2 error code
        
        See also gphoto2.Camera.file_set_info
    
    gp_camera_folder_delete_all(...)
        gp_camera_folder_delete_all(Camera camera, char const * folder, Context context) -> int
        
        Deletes all files in a given `folder`.  
        
        Parameters
        ----------
        * `camera` :  
            a Camera  
        * `folder` :  
            a folder  
        * `context` :  
            a GPContext  
        
        Returns
        -------
        a gphoto2 error code
        
        See also gphoto2.Camera.folder_delete_all
    
    gp_camera_folder_list_files(...)
        gp_camera_folder_list_files(Camera camera, char const * folder, Context context) -> int
        
        Lists the files in supplied `folder`.  
        
        Parameters
        ----------
        * `camera` :  
            a Camera  
        * `folder` :  
            a folder  
        * `list` :  
            a CameraList  
        * `context` :  
            a GPContext  
        
        Returns
        -------
        a gphoto2 error code
        
        See also gphoto2.Camera.folder_list_files
    
    gp_camera_folder_list_folders(...)
        gp_camera_folder_list_folders(Camera camera, char const * folder, Context context) -> int
        
        Lists the folders in supplied `folder`.  
        
        Parameters
        ----------
        * `camera` :  
            a Camera  
        * `folder` :  
            a folder  
        * `list` :  
            a CameraList  
        * `context` :  
            a GPContext  
        
        Returns
        -------
        a gphoto2 error code
        
        See also gphoto2.Camera.folder_list_folders
    
    gp_camera_folder_make_dir(...)
        gp_camera_folder_make_dir(Camera camera, char const * folder, char const * name, Context context) -> int
        
        Creates a new directory called `name` in the given `folder`.  
        
        Parameters
        ----------
        * `camera` :  
            a Camera  
        * `folder` :  
            the location where to create the new directory  
        * `name` :  
            the name of the directory to be created  
        * `context` :  
            a GPContext  
        
        Returns
        -------
        a gphoto2 error code
        
        See also gphoto2.Camera.folder_make_dir
    
    gp_camera_folder_put_file(...)
        gp_camera_folder_put_file(Camera camera, char const * folder, char const * filename, CameraFileType type, CameraFile file, Context context) -> int
        
        Uploads a file into given `folder`.  
        
        Parameters
        ----------
        * `camera` :  
            a Camera  
        * `folder` :  
            a folder  
        * `file` :  
            a CameraFile  
        * `context` :  
            a GPContext  
        
        Returns
        -------
        a gphoto2 error code
        
        See also gphoto2.Camera.folder_put_file
    
    gp_camera_folder_remove_dir(...)
        gp_camera_folder_remove_dir(Camera camera, char const * folder, char const * name, Context context) -> int
        
        Removes an (empty) directory called `name` from the given `folder`.  
        
        Parameters
        ----------
        * `camera` :  
            a Camera  
        * `folder` :  
            the folder from which to remove the directory  
        * `name` :  
            the name of the directory to be removed  
        * `context` :  
            a GPContext  
        
        Returns
        -------
        a gphoto2 error code
        
        See also gphoto2.Camera.folder_remove_dir
    
    gp_camera_get_abilities(...)
        gp_camera_get_abilities(Camera camera) -> int
        
        Retrieve the `abilities` of the `camera`.  
        
        Parameters
        ----------
        * `camera` :  
            a Camera  
        * `abilities` :  
        
        Returns
        -------
        a gphoto2 error code
        
        See also gphoto2.Camera.get_abilities
    
    gp_camera_get_about(...)
        gp_camera_get_about(Camera camera, Context context) -> int
        
        Retrieves information about the camera driver.  
        
        Parameters
        ----------
        * `camera` :  
            a Camera  
        * `about` :  
            a CameraText  
        * `context` :  
            a GPContext  
        
        Returns
        -------
        a gphoto2 error code  
        
        Typically, this information contains name and address of the author,
        acknowledgements, etc.
        
        See also gphoto2.Camera.get_about
    
    gp_camera_get_config(...)
        gp_camera_get_config(Camera camera, Context context) -> int
        
        Retrieve a configuration `window` for the `camera`.  
        
        Parameters
        ----------
        * `camera` :  
            a Camera  
        * `window` :  
            a CameraWidget  
        * `context` :  
            a GPContext  
        
        Returns
        -------
        gphoto2 error code  
        
        This `window` can be used for construction of a configuration dialog.
        
        See also gphoto2.Camera.get_config
    
    gp_camera_get_manual(...)
        gp_camera_get_manual(Camera camera, Context context) -> int
        
        Retrieves the `manual` for given `camera`.  
        
        Parameters
        ----------
        * `camera` :  
            a Camera  
        * `manual` :  
            a CameraText  
        * `context` :  
            a GPContext  
        
        Returns
        -------
        a gphoto2 error code  
        
        This manual typically contains information about using the camera.
        
        See also gphoto2.Camera.get_manual
    
    gp_camera_get_port_info(...)
        gp_camera_get_port_info(Camera camera) -> int
        
        
        
        See also gphoto2.Camera.get_port_info
    
    gp_camera_get_port_speed(...)
        gp_camera_get_port_speed(Camera camera) -> int
        
        Retrieve the current speed.  
        
        Parameters
        ----------
        * `camera` :  
            a Camera  
        
        Returns
        -------
        The current speed or a gphoto2 error code
        
        See also gphoto2.Camera.get_port_speed
    
    gp_camera_get_single_config(...)
        gp_camera_get_single_config(Camera camera, char const * name, Context context) -> int
        
        Retrieve a single configuration `widget` for the `camera`.  
        
        Parameters
        ----------
        * `camera` :  
            a Camera  
        * `name` :  
            the name of a configuration widget  
        * `widget` :  
            a CameraWidget  
        * `context` :  
            a GPContext  
        
        Returns
        -------
        gphoto2 error code  
        
        This `widget` will then contain the current and the possible values and
        the type.
        
        See also gphoto2.Camera.get_single_config
    
    gp_camera_get_storageinfo(...)
        gp_camera_get_storageinfo(Camera camera, Context context) -> int
        
        Gets information on the camera attached storage.  
        
        Parameters
        ----------
        * `camera` :  
            a Camera  
        * `sifs` :  
            Pointer to receive a pointer to/array of storage info items  
        * `nrofsifs` :  
            Pointer to receive number of array entries  
        * `context` :  
            a GPContext  
        
        Returns
        -------
        a gphoto2 error code  
        
        Retrieves the storage information, like maximum and free space, for the
        specified filesystem, if supported by the device. The storage
        information is returned in an newly allocated array of
        CameraStorageInformation objects, to which the pointer pointed to by
        #sifs will be set.  
        
        The variable pointed to by #nrofsifs will be set to the number of
        elements in that array.  
        
        It is the caller's responsibility to free the memory of the array.
        
        See also gphoto2.Camera.get_storageinfo
    
    gp_camera_get_summary(...)
        gp_camera_get_summary(Camera camera, Context context) -> int
        
        Retrieves a camera summary.  
        
        Parameters
        ----------
        * `camera` :  
            a Camera  
        * `summary` :  
            a CameraText  
        * `context` :  
            a GPContext  
        
        Returns
        -------
        a gphoto2 error code  
        
        This summary typically contains information like manufacturer, pictures
        taken, or generally information that is not configurable.
        
        See also gphoto2.Camera.get_summary
    
    gp_camera_init(...)
        gp_camera_init(Camera camera, Context context) -> int
        
        Initiate a connection to the `camera`.  
        
        Parameters
        ----------
        * `camera` :  
            a Camera  
        * `context` :  
            a GPContext  
        
        Returns
        -------
        a gphoto2 error code  
        
        Before calling this function, the `camera` should be set up using
        gp_camera_set_port_path() or gp_camera_set_port_name() and
        gp_camera_set_abilities(). If that has been omitted, gphoto2 tries to
        autodetect any cameras and chooses the first one if any cameras are
        found. It is generally a good idea to call gp_camera_exit() after
        transactions have been completed in order to give other applications the
        chance to access the camera, too.
        
        See also gphoto2.Camera.init
    
    gp_camera_list_config(...)
        gp_camera_list_config(Camera camera, Context context) -> int
        
        
        
        See also gphoto2.Camera.list_config
    
    gp_camera_new(...)
        gp_camera_new() -> int
        
        Allocates the memory for a Camera.  
        
        Parameters
        ----------
        * `camera` :  
            the Camera object to initialize.  
        
        Returns
        -------
        a gphoto2 error code
        
        See also gphoto2.Camera.new
    
    gp_camera_set_abilities(...)
        gp_camera_set_abilities(Camera camera, CameraAbilities abilities) -> int
        
        Sets the camera abilities.  
        
        Parameters
        ----------
        * `camera` :  
            a Camera  
        * `abilities` :  
            the CameraAbilities to be set  
        
        Returns
        -------
        a gphoto2 error code  
        
        You need to call this function before calling gp_camera_init the first
        time unless you want gphoto2 to autodetect cameras and choose the first
        detected one. By setting the `abilities`, you tell gphoto2 what model
        the `camera` is and what camera driver should be used for accessing the
        `camera`. You can get `abilities` by calling
        gp_abilities_list_get_abilities.
        
        See also gphoto2.Camera.set_abilities
    
    gp_camera_set_config(...)
        gp_camera_set_config(Camera camera, CameraWidget window, Context context) -> int
        
        Sets the configuration.  
        
        Parameters
        ----------
        * `camera` :  
            a Camera  
        * `window` :  
            a CameraWidget  
        * `context` :  
            a GPContext  
        
        Returns
        -------
        a gphoto2 error code  
        
        Typically, a `window` is retrieved using gp_camera_get_config and passed
        to this function in order to adjust the settings on the camera.
        
        See also gphoto2.Camera.set_config
    
    gp_camera_set_port_info(...)
        gp_camera_set_port_info(Camera camera, GPPortInfo info) -> int
        
        
        
        See also gphoto2.Camera.set_port_info
    
    gp_camera_set_port_speed(...)
        gp_camera_set_port_speed(Camera camera, int speed) -> int
        
        Set the camera speed.  
        
        Parameters
        ----------
        * `camera` :  
            a Camera  
        * `speed` :  
            the speed  
        
        Returns
        -------
        a gphoto2 error code  
        
        This function is typically used prior first initialization using
        gp_camera_init for debugging purposes. Normally, a camera driver will
        try to figure out the current speed of the camera and set the speed to
        the optimal one automatically. Note that this function only works with
        serial ports. In other words, you have to set the camera's port to a
        serial one (using #gp_camera_set_port_path or #gp_camera_set_port_name)
        prior calling this function.
        
        See also gphoto2.Camera.set_port_speed
    
    gp_camera_set_single_config(...)
        gp_camera_set_single_config(Camera camera, char const * name, CameraWidget widget, Context context) -> int
        
        Set a single configuration `widget` for the `camera`.  
        
        Parameters
        ----------
        * `camera` :  
            a Camera  
        * `name` :  
            the name of a configuration widget  
        * `widget` :  
            a CameraWidget  
        * `context` :  
            a GPContext  
        
        Returns
        -------
        gphoto2 error code  
        
        This `widget` contains the new value of the widget to set.
        
        See also gphoto2.Camera.set_single_config
    
    gp_camera_set_timeout_funcs(...)
        gp_camera_set_timeout_funcs(Camera camera, CameraTimeoutStartFunc start_func, CameraTimeoutStopFunc stop_func, void * data)
        
        Parameters
        ----------
        * `camera` :  
            a Camera  
        * `start_func` :  
        * `stop_func` :  
        * `data` :  
        
        Returns
        -------
        a gphoto2 error code  
        
        If your frontend has something like idle loops, it is recommended you
        use gp_camera_set_timeout_funcs in order to give the camera driver the
        possibility to keep up the connection to the camera.
        
        See also gphoto2.Camera.set_timeout_funcs
    
    gp_camera_start_timeout(...)
        gp_camera_start_timeout(Camera camera, unsigned int timeout, CameraTimeoutFunc func) -> int
        
        Parameters
        ----------
        * `camera` :  
            a Camera  
        * `timeout` :  
            number of seconds that should pass between each call to `func`  
        * `func` :  
            the function that should be called each `timeout` seconds  
        
        Returns
        -------
        The id of the background process or a gphoto2 error code  
        
        This function should be called by the camera driver during camera_init()
        if the camera needs to be sent messages periodically in order to prevent
        it from shutting down.
        
        See also gphoto2.Camera.start_timeout
    
    gp_camera_stop_timeout(...)
        gp_camera_stop_timeout(Camera camera, unsigned int id)
        
        Stop periodic calls to keepalive function.  
        
        Parameters
        ----------
        * `camera` :  
            a Camera  
        * `id` :  
            the id of the background process previously returned by
            gp_camera_start_timeout  
        
        Call this function in the camera driver if you want to stop a periodic
        call to a function that has been started using gp_camera_start_timeout.
        
        See also gphoto2.Camera.stop_timeout
    
    gp_camera_trigger_capture(...)
        gp_camera_trigger_capture(Camera camera, Context context) -> int
        
        Triggers capture of one or more images.  
        
        Parameters
        ----------
        * `camera` :  
            a Camera  
        * `context` :  
            a GPContext  
        
        Returns
        -------
        a gphoto2 error code  
        
        This functions just remotely causes the shutter release and returns
        immediately. You will want to run #gp_camera_wait_event until a image is
        added which can be downloaded using gp_camera_file_get.
        
        See also gphoto2.Camera.trigger_capture
    
    gp_camera_wait_for_event(...)
        gp_camera_wait_for_event(Camera camera, int timeout, Context context) -> int
        
        Wait and retrieve an event from the camera.  
        
        Parameters
        ----------
        * `camera` :  
            a Camera  
        * `timeout` :  
            amount of time to wait in 1/1000 seconds  
        * `eventtype` :  
            received CameraEventType [out]  
        * `eventdata` :  
            received event specific data [out]  
        * `context` :  
            a GPContext  
        
        Returns
        -------
        gphoto2 error code  
        
        This function blocks and waits for an event to come from the camera. If
        a timeout occurs before an event is received then eventtype will be
        GP_EVENT_TIMEOUT and eventdata is left unchanged.  
        
        If an event is received then eventtype is set to the type of event, and
        eventdata is set to event specific data. See the CameraEventType enum to
        see which eventtypes match to which types of eventdata.  
        
        Note that this function will return one event after each other, you need
        to be able to call it multiple times, e.g. in a loop, when waiting for
        specific events.
        
        See also gphoto2.Camera.wait_for_event
    
    gp_context_cancel(...)
        gp_context_cancel(Context context) -> GPContextFeedback
        
        gp_context_cancel: : a GPContext  
        
        Gives the frontend the possibility to cancel the current operation that
        is executed in this .  
        
        Return value: a GPContextFeedback.
    
    gp_context_error(...)
        gp_context_error(Context context, char const * format)
    
    gp_context_idle(...)
        gp_context_idle(Context context)
        
        Notify frontend of a brief idle time.  
        
        Tells the frontend that it can do other processing at this moment, like
        refresh the UI. Backends should call this function every time when an
        interruption of the transfer is possible.  
        
        Parameters
        ----------
        * `context` :  
            a GPContext
    
    gp_context_message(...)
        gp_context_message(Context context, char const * format)
        
        Print a message to the context.  
        
        This sends a message to the passed context, to be printed by it in some
        kind of way, but do no other action.  
        
        To be used by camera drivers.  
        
        Parameters
        ----------
        * `context` :  
            A GPContext  
        * `format` :  
            A sprintf style format string  
        * `...` :  
            variable argument list depending on format string
    
    gp_context_new(...)
        gp_context_new() -> Context
        
        Creates a new context.  
        
        To be used by the frontend.  
        
        Returns
        -------
        a GPContext.
    
    gp_context_progress_start(...)
        gp_context_progress_start(Context context, float target, char const * format) -> unsigned int
        
        Start progress tracking.  
        
        This function starts up a new progress tracking for a specified context.
        Several nested progress reports can happen at once, depending on the
        backend.  
        
        Parameters
        ----------
        * `context` :  
            The context in which to start the progress.  
        * `target` :  
            The 100% value.  
        * `format` :  
            A sprintf style string to print out, including the following
            variable arguments.
    
    gp_context_progress_stop(...)
        gp_context_progress_stop(Context context, unsigned int id)
    
    gp_context_progress_update(...)
        gp_context_progress_update(Context context, unsigned int id, float current)
    
    gp_context_question(...)
        gp_context_question(Context context, char const * format) -> GPContextFeedback
        
        Ask frontend user a question.  
        
        Asks the user a question that he must answer either with "Ok" or
        "Cancel".  
        
        To be used by a camera driver. (So far no camera driver is using it, but
        this might change later.)  
        
        Parameters
        ----------
        * `context` :  
            a GPContext  
        * `format` :  
            a sprintf format string  
        * `...` :  
            variable arguments for format string  
        
        Returns
        -------
        The user's answer in form of a GPContextFeedback.
    
    gp_context_set_cancel_func(...)
        gp_context_set_cancel_func(Context context, GPContextCancelFunc func, void * data)
    
    gp_context_set_error_func(...)
        gp_context_set_error_func(Context context, GPContextErrorFunc func, void * data)
    
    gp_context_set_idle_func(...)
        gp_context_set_idle_func(Context context, GPContextIdleFunc func, void * data)
    
    gp_context_set_message_func(...)
        gp_context_set_message_func(Context context, GPContextMessageFunc func, void * data)
    
    gp_context_set_progress_funcs(...)
        gp_context_set_progress_funcs(Context context, GPContextProgressStartFunc start_func, GPContextProgressUpdateFunc update_func, GPContextProgressStopFunc stop_func, void * data)
    
    gp_context_set_question_func(...)
        gp_context_set_question_func(Context context, GPContextQuestionFunc func, void * data)
    
    gp_context_set_status_func(...)
        gp_context_set_status_func(Context context, GPContextStatusFunc func, void * data)
    
    gp_context_status(...)
        gp_context_status(Context context, char const * format)
    
    gp_file_adjust_name_for_mime_type(...)
        gp_file_adjust_name_for_mime_type(CameraFile file) -> int
        
        Parameters
        ----------
        * `file` :  
            a CameraFile  
        
        Returns
        -------
        a gphoto2 error code.
        
        See also gphoto2.CameraFile.adjust_name_for_mime_type
    
    gp_file_append(...)
        gp_file_append(CameraFile arg1, char const * data, unsigned long size) -> int
        
        Parameters
        ----------
        * `file` :  
            a CameraFile  
        * `data` :  
        * `size` :  
        
        Returns
        -------
        a gphoto2 error code.
        
        See also gphoto2.CameraFile.append
    
    gp_file_clean(...)
        gp_file_clean(CameraFile file) -> int
        
        Parameters
        ----------
        * `file` :  
            a CameraFile  
        
        Returns
        -------
        a gphoto2 error code.
        
        See also gphoto2.CameraFile.clean
    
    gp_file_copy(...)
        gp_file_copy(CameraFile destination, CameraFile source) -> int
        
        Parameters
        ----------
        * `destination` :  
            a CameraFile  
        * `source` :  
            a CameraFile  
        
        Returns
        -------
        a gphoto2 error code.
        
        See also gphoto2.CameraFile.copy
    
    gp_file_detect_mime_type(...)
        gp_file_detect_mime_type(CameraFile file) -> int
        
        Parameters
        ----------
        * `file` :  
            a CameraFile  
        
        Returns
        -------
        a gphoto2 error code.
        
        See also gphoto2.CameraFile.detect_mime_type
    
    gp_file_get_data_and_size(...)
        gp_file_get_data_and_size(CameraFile arg1) -> int
        
        Get a pointer to the data and the file's size.  
        
        Parameters
        ----------
        * `file` :  
            a CameraFile  
        * `data` :  
        * `size` :  
        
        Returns
        -------
        a gphoto2 error code.  
        
        Both data and size can be NULL and will then be ignored.  
        
        The pointer to data that is returned is still owned by libgphoto2 and
        its lifetime is the same as the #file.
        
        See also gphoto2.CameraFile.get_data_and_size
    
    gp_file_get_mime_type(...)
        gp_file_get_mime_type(CameraFile file) -> int
        
        Parameters
        ----------
        * `file` :  
            a CameraFile  
        * `mime_type` :  
            a pointer to a MIME type string  
        
        Returns
        -------
        a gphoto2 error code.
        
        See also gphoto2.CameraFile.get_mime_type
    
    gp_file_get_mtime(...)
        gp_file_get_mtime(CameraFile file) -> int
        
        Parameters
        ----------
        * `file` :  
            a CameraFile  
        * `mtime` :  
        
        Returns
        -------
        a gphoto2 error code.
        
        See also gphoto2.CameraFile.get_mtime
    
    gp_file_get_name(...)
        gp_file_get_name(CameraFile file) -> int
        
        Parameters
        ----------
        * `file` :  
            a CameraFile  
        * `name` :  
            a pointer to a name string  
        
        Returns
        -------
        a gphoto2 error code.
        
        See also gphoto2.CameraFile.get_name
    
    gp_file_get_name_by_type(...)
        gp_file_get_name_by_type(CameraFile file, char const * basename, CameraFileType type) -> int
        
        Parameters
        ----------
        * `file` :  
            a CameraFile  
        * `basename` :  
            the basename of the file  
        * `type` :  
            the gphoto type of the file  
        * `newname` :  
            the new name generated  
        
        Returns
        -------
        a gphoto2 error code.  
        
        This function takes the basename and generates a filename out of it
        depending on the gphoto filetype and the mime type in the file. The
        gphoto filetype will be converted to a prefix, like thumb_ or raw_, the
        mimetype will replace the current suffix by a different one (if
        necessary).  
        
        This can be used so that saving thumbnails or metadata will not
        overwrite the normal files.
        
        See also gphoto2.CameraFile.get_name_by_type
    
    gp_file_new(...)
        gp_file_new() -> int
        
        Create new CameraFile object.  
        
        Parameters
        ----------
        * `file` :  
            a pointer to a CameraFile  
        
        Returns
        -------
        a gphoto2 error code.
        
        See also gphoto2.CameraFile.new
    
    gp_file_new_from_fd(...)
        gp_file_new_from_fd(int fd) -> int
        
        Create new CameraFile object from a UNIX filedescriptor.  
        
        This function takes ownership of the filedescriptor and will close it
        when closing the CameraFile.  
        
        Parameters
        ----------
        * `file` :  
            a pointer to a CameraFile  
        * `fd` :  
            a UNIX filedescriptor  
        
        Returns
        -------
        a gphoto2 error code.
        
        See also gphoto2.CameraFile.new_from_fd
    
    gp_file_new_from_handler(...)
        gp_file_new_from_handler(CameraFileHandler * handler, void * priv) -> int
        
        Create new CameraFile object using a programmatic handler.  
        
        Parameters
        ----------
        * `file` :  
            a pointer to a CameraFile  
        * `handler` :  
            a #CameraFileHandler  
        * `private` :  
            a private pointer for frontend use  
        
        Returns
        -------
        a gphoto2 error code.
        
        See also gphoto2.CameraFile.new_from_handler
    
    gp_file_open(...)
        gp_file_open(char const * filename) -> int
        
        Parameters
        ----------
        * `file` :  
            a CameraFile  
        * `filename` :  
        
        Returns
        -------
        a gphoto2 error code.
        
        See also gphoto2.CameraFile.open
    
    gp_file_save(...)
        gp_file_save(CameraFile file, char const * filename) -> int
        
        Parameters
        ----------
        * `file` :  
            a CameraFile  
        * `filename` :  
        
        Returns
        -------
        a gphoto2 error code.
        
        See also gphoto2.CameraFile.save
    
    gp_file_set_data_and_size(...)
        gp_file_set_data_and_size(CameraFile arg1, char * data, unsigned long size) -> int
        
        Parameters
        ----------
        * `file` :  
            a CameraFile  
        * `data` :  
        * `size` :  
        
        Returns
        -------
        a gphoto2 error code.
        
        See also gphoto2.CameraFile.set_data_and_size
    
    gp_file_set_mime_type(...)
        gp_file_set_mime_type(CameraFile file, char const * mime_type) -> int
        
        Parameters
        ----------
        * `file` :  
            a CameraFile  
        * `mime_type` :  
            a MIME type string  
        
        Returns
        -------
        a gphoto2 error code.
        
        See also gphoto2.CameraFile.set_mime_type
    
    gp_file_set_mtime(...)
        gp_file_set_mtime(CameraFile file, time_t mtime) -> int
        
        Parameters
        ----------
        * `file` :  
            a CameraFile  
        * `mtime` :  
        
        Returns
        -------
        a gphoto2 error code.
        
        See also gphoto2.CameraFile.set_mtime
    
    gp_file_set_name(...)
        gp_file_set_name(CameraFile file, char const * name) -> int
        
        Parameters
        ----------
        * `file` :  
            a CameraFile  
        * `name` :  
            a pointer to a MIME type string  
        
        Returns
        -------
        a gphoto2 error code.
        
        See also gphoto2.CameraFile.set_name
    
    gp_filesystem_append(...)
        gp_filesystem_append(_CameraFilesystem fs, char const * folder, char const * filename, Context context) -> int
    
    gp_filesystem_count(...)
        gp_filesystem_count(_CameraFilesystem fs, char const * folder, Context context) -> int
        
        Count files a folder of a filesystem.  
        
        Parameters
        ----------
        * `fs` :  
            a CameraFilesystem  
        * `folder` :  
            a folder in which to count the files  
        * `context` :  
            a GPContext  
        
        Counts the files in the folder.  
        
        Returns
        -------
        The number of files in the folder or a gphoto2 error code.
    
    gp_filesystem_delete_all(...)
        gp_filesystem_delete_all(_CameraFilesystem fs, char const * folder, Context context) -> int
        
        Delete all files in specified folder.  
        
        Parameters
        ----------
        * `fs` :  
            a CameraFilesystem  
        * `folder` :  
            the folder in which to delete all files  
        * `context` :  
            a GPContext  
        
        Deletes all files in the given folder from the fs. If the fs has not
        been supplied with a delete_all_func, it tries to delete the files one
        by one using the delete_file_func. If that function has not been
        supplied neither, an error is returned.  
        
        Returns
        -------
        a gphoto2 error code.
    
    gp_filesystem_delete_file(...)
        gp_filesystem_delete_file(_CameraFilesystem fs, char const * folder, char const * filename, Context context) -> int
        
        Delete a file from a folder.  
        
        Parameters
        ----------
        * `fs` :  
            a CameraFilesystem  
        * `folder` :  
            a folder in which to delete the file  
        * `filename` :  
            the name of the file to delete  
        * `context` :  
            a GPContext  
        
        If a delete_file_func has been supplied to the fs, this function will be
        called and, if this function returns without error, the file will be
        removed from the fs.  
        
        Returns
        -------
        a gphoto2 error code.
    
    gp_filesystem_delete_file_noop(...)
        gp_filesystem_delete_file_noop(_CameraFilesystem fs, char const * folder, char const * filename, Context context) -> int
        
        Delete a virtal file from a folder in the filesystem.  
        
        Parameters
        ----------
        * `fs` :  
            a CameraFilesystem  
        * `folder` :  
            a folder in which to delete the file  
        * `filename` :  
            the name of the file to delete  
        * `context` :  
            a GPContext  
        
        Remove a file from the filesystem. Compared to
        gp_filesystem_delete_file() this just removes the file from the
        libgphoto2 view of the filesystem, but does not call the camera driver
        to delete it from the physical device.  
        
        Returns
        -------
        a gphoto2 error code.
    
    gp_filesystem_dump(...)
        gp_filesystem_dump(_CameraFilesystem fs) -> int
        
        Dump the current filesystem.  
        
        Parameters
        ----------
        * `fs` :  
            the CameraFilesystem  
        
        Returns
        -------
        a gphoto error code  
        
        Internal function to dump the current filesystem.
    
    gp_filesystem_get_file(...)
        gp_filesystem_get_file(_CameraFilesystem fs, char const * folder, char const * filename, CameraFileType type, CameraFile file, Context context) -> int
        
        Get file data from the filesystem.  
        
        Parameters
        ----------
        * `fs` :  
            a CameraFilesystem  
        * `folder` :  
            the folder in which the file can be found  
        * `filename` :  
            the name of the file to download  
        * `type` :  
            the type of the file  
        * `file` :  
            the file that receives the data  
        * `context` :  
            a GPContext  
        
        Downloads the file called filename from the folder using the
        get_file_func if such a function has been previously supplied. If the
        file has been previously downloaded, the file is retrieved from cache.
        The result is stored in the passed file structure.  
        
        Returns
        -------
        a gphoto2 error code.
    
    gp_filesystem_get_folder(...)
        gp_filesystem_get_folder(_CameraFilesystem fs, char const * filename, Context context) -> int
        
        Search a folder that contains a given filename.  
        
        Parameters
        ----------
        * `fs` :  
            a CameraFilesystem  
        * `filename` :  
            the name of the file to search in the fs  
        * `folder` :  
            pointer to value where the string is stored in  
        * `context` :  
            a GPContext  
        
        Searches a file called filename in the fs and returns the first
        occurrency. This functionality is needed for camera drivers that cannot
        figure out where a file gets created after capturing an image although
        the name of the image is known. Usually, those drivers will call
        gp_filesystem_reset in order to tell the fs that something has changed
        and then gp_filesystem_get_folder in order to find the file.  
        
        Note that you get a reference to the string stored in the filesystem
        structure, so do not free it yourself.  
        
        Returns
        -------
        a gphoto2 error code.
    
    gp_filesystem_get_info(...)
        gp_filesystem_get_info(_CameraFilesystem fs, char const * folder, char const * filename, Context context) -> int
        
        Get information about the specified file.  
        
        Parameters
        ----------
        * `fs` :  
            a CameraFilesystem  
        * `folder` :  
            the folder that contains the file  
        * `filename` :  
            the filename  
        * `info` :  
            pointer to CameraFileInfo that receives the information  
        * `context` :  
            a GPContext  
        
        Returns
        -------
        a gphoto2 error code.
    
    gp_filesystem_list_files(...)
        gp_filesystem_list_files(_CameraFilesystem fs, char const * folder, Context context) -> int
        
        Get the list of files in a folder.  
        
        Parameters
        ----------
        * `fs` :  
            a CameraFilesystem  
        * `folder` :  
            a folder of which a file list should be generated  
        * `list` :  
            a CameraList where to put the list of files into  
        * `context` :  
            a GPContext  
        
        Lists the files in folder using either cached values or (if there aren't
        any) the file_list_func which (hopefully) has been previously supplied.  
        
        Returns
        -------
        a gphoto2 error code.
    
    gp_filesystem_list_folders(...)
        gp_filesystem_list_folders(_CameraFilesystem fs, char const * folder, Context context) -> int
        
        List all subfolders within a filesystem folder.  
        
        Parameters
        ----------
        * `fs` :  
            a CameraFilesystem  
        * `folder` :  
            a folder  
        * `list` :  
            a CameraList where subfolders should be listed  
        * `context` :  
            a GPContext  
        
        Generates a list of subfolders of the supplied folder either using
        cached values (if there are any) or the folder_list_func if it has been
        supplied previously. If not, it is assumed that only a root folder
        exists (which is the case for many cameras).  
        
        Returns
        -------
        a gphoto2 error code.
    
    gp_filesystem_make_dir(...)
        gp_filesystem_make_dir(_CameraFilesystem fs, char const * folder, char const * name, Context context) -> int
        
        Create a subfolder within a folder.  
        
        Parameters
        ----------
        * `fs` :  
            a CameraFilesystem  
        * `folder` :  
            the folder in which the directory should be created  
        * `name` :  
            the name of the directory to be created  
        * `context` :  
            a GPContext  
        
        Creates a new directory called name in given folder.  
        
        Returns
        -------
        a gphoto2 error code
    
    gp_filesystem_name(...)
        gp_filesystem_name(_CameraFilesystem fs, char const * folder, int filenumber, Context context) -> int
        
        Lookup the filename of an indexed file within a folder.  
        
        Parameters
        ----------
        * `fs` :  
            a CameraFilesystem  
        * `folder` :  
            the folder where to look up the file with the filenumber  
        * `filenumber` :  
            the number of the file  
        * `filename` :  
            pointer to a filename where the result is stored  
        * `context` :  
            a GPContext  
        
        Looks up the filename of file with given filenumber in given folder. See
        gp_filesystem_number for exactly the opposite functionality.  
        
        Returns
        -------
        a gphoto2 error code.
    
    gp_filesystem_new(...)
        gp_filesystem_new() -> int
        
        Create a new filesystem struct.  
        
        Parameters
        ----------
        * `fs` :  
            a pointer to a CameraFilesystem  
        
        Creates a new empty CameraFilesystem  
        
        Returns
        -------
        a gphoto2 error code.
    
    gp_filesystem_number(...)
        gp_filesystem_number(_CameraFilesystem fs, char const * folder, char const * filename, Context context) -> int
        
        Get the index of a file in specified folder.  
        
        Parameters
        ----------
        * `fs` :  
            a CameraFilesystem  
        * `folder` :  
            the folder where to look for file called filename  
        * `filename` :  
            the file to look for  
        * `context` :  
            a GPContext  
        
        Looks for a file called filename in the given folder. See
        gp_filesystem_name for exactly the opposite functionality.  
        
        Returns
        -------
        a gphoto2 error code.
    
    gp_filesystem_put_file(...)
        gp_filesystem_put_file(_CameraFilesystem fs, char const * folder, char const * filename, CameraFileType type, CameraFile file, Context context) -> int
        
        Upload a file to a folder on the device filesystem.  
        
        Parameters
        ----------
        * `fs` :  
            a CameraFilesystem  
        * `folder` :  
            the folder where to put the file into  
        * `file` :  
            the file  
        * `context` :  
            a GPContext  
        
        Uploads a file to the camera if a put_file_func has been previously
        supplied to the fs. If the upload is successful, the file will get
        cached in the fs.  
        
        Returns
        -------
        a gphoto2 error code.
    
    gp_filesystem_read_file(...)
        gp_filesystem_read_file(_CameraFilesystem fs, char const * folder, char const * filename, CameraFileType type, uint64_t offset, char * buf, uint64_t * size, Context context) -> int
        
        Get partial file data from the filesystem.  
        
        Parameters
        ----------
        * `fs` :  
            a CameraFilesystem  
        * `folder` :  
            the folder in which the file can be found  
        * `filename` :  
            the name of the file to download  
        * `type` :  
            the type of the file  
        * `offset` :  
            the offset where the data starts  
        * `buf` :  
            the targetbuffer where the data will be put  
        * `size` :  
            the size to read and that was read into the buffer  
        * `context` :  
            a GPContext  
        
        Downloads the file called filename from the folder using the
        read_file_func if such a function has been previously supplied. If the
        file has been previously downloaded, the file is retrieved from cache.  
        
        The file is read partially into the passed buffer. The read starts at
        offset on the device and goes for at most size bytes. Reading over the
        end of the file might give errors, so get the maximum file size via an
        info function before.  
        
        Returns
        -------
        a gphoto2 error code.
    
    gp_filesystem_remove_dir(...)
        gp_filesystem_remove_dir(_CameraFilesystem fs, char const * folder, char const * name, Context context) -> int
        
        Remove a subfolder from within a folder.  
        
        Parameters
        ----------
        * `fs` :  
            a CameraFilesystem  
        * `folder` :  
            the folder in which the directory should be created  
        * `name` :  
            the name of the directory to be created  
        * `context` :  
            a GPContext  
        
        Removes a directory called name from the given folder.  
        
        Returns
        -------
        a gphoto2 error code
    
    gp_filesystem_reset(...)
        gp_filesystem_reset(_CameraFilesystem fs) -> int
        
        Clear the filesystem.  
        
        Parameters
        ----------
        * `fs` :  
            the filesystem to be cleared  
        
        Resets the filesystem. All cached information including the folder tree
        will get lost and will be queried again on demand.  
        
        Returns
        -------
        a gphoto2 error code.
    
    gp_filesystem_set_file_noop(...)
        gp_filesystem_set_file_noop(_CameraFilesystem fs, char const * folder, char const * filename, CameraFileType type, CameraFile file, Context context) -> int
        
        Attach file content to a specified file.  
        
        Parameters
        ----------
        * `fs` :  
            a CameraFilesystem  
        * `folder` :  
            a folder in the filesystem  
        * `file` :  
            a CameraFile  
        * `context` :  
            a GPContext  
        
        Tells the fs about a file. Typically, camera drivers will call this
        function in case they get information about a file (i.e. preview) "for
        free" on gp_camera_capture() or gp_camera_folder_list_files().  
        
        Returns
        -------
        a gphoto2 error code.
    
    gp_filesystem_set_funcs(...)
        gp_filesystem_set_funcs(_CameraFilesystem fs, _CameraFilesystemFuncs funcs, void * data) -> int
        
        Set all filesystem related function pointers.  
        
        Parameters
        ----------
        * `fs` :  
            a CameraFilesystem  
        * `funcs` :  
            pointer to a struct of filesystem functions  
        * `data` :  
            private data  
        
        Tells the filesystem which functions to call for camera/filesystem
        specific functions, like listing, retrieving, uploading files and so on.  
        
        Returns
        -------
        a gphoto2 error code.
    
    gp_filesystem_set_info(...)
        gp_filesystem_set_info(_CameraFilesystem fs, char const * folder, char const * filename, CameraFileInfo info, Context context) -> int
        
        Set information about a file.  
        
        Parameters
        ----------
        * `fs` :  
            a CameraFilesystem  
        * `folder` :  
            foldername where the file resides  
        * `filename` :  
            the files name  
        * `info` :  
            the CameraFileInfo to set  
        * `context` :  
            a GPContext  
        
        Sets information about a file in the camera.  
        
        Returns
        -------
        a gphoto2 error code.
    
    gp_filesystem_set_info_noop(...)
        gp_filesystem_set_info_noop(_CameraFilesystem fs, char const * folder, char const * filename, CameraFileInfo info, Context context) -> int
        
        Store the file information in the virtual fs.  
        
        Parameters
        ----------
        * `fs` :  
            a CameraFilesystem  
        * `folder` :  
            the foldername  
        * `info` :  
            the CameraFileInfo to store  
        * `context` :  
            a GPContext  
        
        In contrast to gp_filesystem_set_info, gp_filesystem_set_info_noop will
        only change the file information in the fs. Typically, camera drivers
        will use this function in case they get file information "for free" on
        gp_camera_capture or gp_camera_folder_list_files.  
        
        Returns
        -------
        a gphoto2 error code
    
    gp_library_version(...)
        gp_library_version(GPVersionVerbosity verbose) -> char const **
    
    gp_list_append(...)
        gp_list_append(CameraList list, char const * name, char const * value) -> int
        
        Appends `name` and `value` to the `list`.  
        
        Parameters
        ----------
        * `list` :  
            a CameraList  
        * `name` :  
            the name of the entry to append  
        * `value` :  
            the value of the entry to append  
        
        Returns
        -------
        a gphoto2 error code
        
        See also gphoto2.CameraList.append
    
    gp_list_count(...)
        gp_list_count(CameraList list) -> int
        
        Counts the entries in the `list`.  
        
        Parameters
        ----------
        * `list` :  
            a CameraList  
        
        Returns
        -------
        a gphoto2 error code
        
        See also gphoto2.CameraList.count
    
    gp_list_find_by_name(...)
        gp_list_find_by_name(CameraList list, int * index, char const * name) -> int
        
        Retrieves the `index` of an arbitrary entry with `name`.  
        
        Parameters
        ----------
        * `list` :  
            a CameraList  
        * `index` :  
            pointer to the result index (may be NULL, only set if found)  
        * `name` :  
            name of the entry  
        
        Returns
        -------
        a gphoto2 error code: GP_OK if found.  
        
        No guarantees as to the speed of the search, or in what sequence the
        list is searched.
        
        See also gphoto2.CameraList.find_by_name
    
    gp_list_get_name(...)
        gp_list_get_name(CameraList list, int index) -> int
        
        Retrieves the `name` of entry with `index`.  
        
        Parameters
        ----------
        * `list` :  
            a CameraList  
        * `index` :  
            index of the entry  
        * `name` :  
        
        Returns
        -------
        a gphoto2 error code.
        
        See also gphoto2.CameraList.get_name
    
    gp_list_get_value(...)
        gp_list_get_value(CameraList list, int index) -> int
        
        Retrieves the value of entry with `index`.  
        
        Parameters
        ----------
        * `list` :  
            a CameraList  
        * `index` :  
            index of the entry  
        * `value` :  
        
        Returns
        -------
        a gphoto2 error code
        
        See also gphoto2.CameraList.get_value
    
    gp_list_new(...)
        gp_list_new() -> int
        
        Creates a new CameraList.  
        
        Parameters
        ----------
        * `list` :  
        
        Returns
        -------
        a gphoto2 error code
        
        See also gphoto2.CameraList.new
    
    gp_list_populate(...)
        gp_list_populate(CameraList list, char const * format, int count) -> int
        
        Adds `count` entries to the list.  
        
        Parameters
        ----------
        * `list` :  
            a CameraList  
        * `format` :  
            the format  
        * `count` :  
            number of entries to be added to the list return a gphoto2 error
            code  
        
        Typically, this function is called by a camera driver when there is no
        way of retrieving the real name of a picture. In this case, when asked
        for a file list (see #CameraFilesystemListFunc), the list is populated
        with dummy names generated by this function.
        
        See also gphoto2.CameraList.populate
    
    gp_list_reset(...)
        gp_list_reset(CameraList list) -> int
        
        Resets the `list` and removes all entries.  
        
        Parameters
        ----------
        * `list` :  
            a CameraList  
        
        Returns
        -------
        a gphoto2 error code
        
        See also gphoto2.CameraList.reset
    
    gp_list_set_name(...)
        gp_list_set_name(CameraList list, int index, char const * name) -> int
        
        Sets the name of an entry.  
        
        Parameters
        ----------
        * `list` :  
            a CameraList  
        * `index` :  
            index of entry  
        * `name` :  
            name to be set  
        
        Returns
        -------
        a gphoto2 error code
        
        See also gphoto2.CameraList.set_name
    
    gp_list_set_value(...)
        gp_list_set_value(CameraList list, int index, char const * value) -> int
        
        Sets the `value` of an entry.  
        
        Parameters
        ----------
        * `list` :  
            a CameraList  
        * `index` :  
            index of the entry  
        * `value` :  
            the value to be set  
        
        Returns
        -------
        a gphoto2 error code
        
        See also gphoto2.CameraList.set_value
    
    gp_list_sort(...)
        gp_list_sort(CameraList list) -> int
        
        Sorts the `list` entries with respect to the names.  
        
        Parameters
        ----------
        * `list` :  
            a CameraList  
        
        Returns
        -------
        a gphoto2 error code
        
        See also gphoto2.CameraList.sort
    
    gp_log(...)
        gp_log(GPLogLevel level, char const * domain, char const * format)
        
        Log a debug or error message.  
        
        Parameters
        ----------
        * `level` :  
            gphoto2 log level  
        * `domain` :  
            the log domain  
        * `format` :  
            a printf style format string  
        * `...` :  
            the variable argumentlist for above format string  
        
        Logs a message at the given log level. You would normally use this
        function to log general debug output in a printf way.
    
    gp_log_add_func(...)
        gp_log_add_func(GPLogLevel level, GPLogFunc func, void * data) -> int
        
        Add a function to get logging information.  
        
        Parameters
        ----------
        * `level` :  
            the maximum level of logging it will get, up to and including the
            passed value  
        * `func` :  
            a GPLogFunc  
        * `data` :  
            data  
        
        Adds a log function that will be called for each log message that is
        flagged with a log level that appears in given log level. This function
        returns an id that you can use for removing the log function again
        (using gp_log_remove_func).  
        
        Returns
        -------
        an id or a gphoto2 error code
    
    gp_log_remove_func(...)
        gp_log_remove_func(int id) -> int
        
        Remove a logging receiving function.  
        
        Parameters
        ----------
        * `id` :  
            an id (return value of gp_log_add_func)  
        
        Removes the log function with given id.  
        
        Returns
        -------
        a gphoto2 error code
    
    gp_message_codeset(...)
        gp_message_codeset(char const * arg1) -> char const *
        
        Set the current character codeset libgphoto2 is operating in.  
        
        Set the codeset for all messages returned by libgphoto2.  
        
        Parameters
        ----------
        * `codeset` :  
            New codeset for the messages. For instance "utf-8".  
        
        Returns
        -------
        old codeset as returned from bind_textdomain_codeset().  
        
        You would then call gp_abilities_list_load() in order to populate it.
    
    gp_port_info_get_name(...)
        gp_port_info_get_name(_GPPortInfo info) -> int
        
        Get name of a specific port entry.  
        
        Parameters
        ----------
        * `info` :  
            a #GPPortInfo  
        * `name` :  
            a pointer to a char* which will receive the name  
        
        Retreives the name of the passed in GPPortInfo, by reference.  
        
        Returns
        -------
        a gphoto2 error code
        
        See also gphoto2.PortInfo.get_name
    
    gp_port_info_get_path(...)
        gp_port_info_get_path(_GPPortInfo info) -> int
        
        Get path of a specific port entry.  
        
        Parameters
        ----------
        * `info` :  
            a #GPPortInfo  
        * `path` :  
            a pointer to a char* which will receive the path  
        
        Retreives the path of the passed in GPPortInfo, by reference.  
        
        Returns
        -------
        a gphoto2 error code
        
        See also gphoto2.PortInfo.get_path
    
    gp_port_info_get_type(...)
        gp_port_info_get_type(_GPPortInfo info) -> int
        
        Get type of a specific port entry.  
        
        Parameters
        ----------
        * `info` :  
            a #GPPortInfo  
        * `type` :  
            a pointer to a GPPortType variable which will receive the type  
        
        Retreives the type of the passed in GPPortInfo  
        
        Returns
        -------
        a gphoto2 error code
        
        See also gphoto2.PortInfo.get_type
    
    gp_port_info_list_append(...)
        gp_port_info_list_append(PortInfoList list, _GPPortInfo info) -> int
        
        Append a portinfo to the port information list.  
        
        Parameters
        ----------
        * `list` :  
            a #GPPortInfoList  
        * `info` :  
            the info to append  
        
        Appends an entry to the list. This function is typically called by an
        io-driver during #gp_port_library_list. If you leave info.name blank,
        gp_port_info_list_lookup_path will try to match non-existent paths
        against info.path and - if successfull - will append this entry to the
        list.  
        
        Returns
        -------
        A gphoto2 error code, or an index into the port list (excluding generic
        entries). which can be used for gp_port_info_list_get_info.
        
        See also gphoto2.PortInfoList.append
    
    gp_port_info_list_count(...)
        gp_port_info_list_count(PortInfoList list) -> int
        
        Number of ports in the list.  
        
        Parameters
        ----------
        * `list` :  
            a #GPPortInfoList  
        
        Returns the number of entries in the passed list.  
        
        Returns
        -------
        The number of entries or a gphoto2 error code
        
        See also gphoto2.PortInfoList.count
    
    gp_port_info_list_get_info(...)
        gp_port_info_list_get_info(PortInfoList list, int n) -> int
        
        Get port information of specific entry.  
        
        Parameters
        ----------
        * `list` :  
            a #GPPortInfoList  
        * `n` :  
            the index of the entry  
        * `info` :  
            the returned information  
        
        Returns a pointer to the current port entry.  
        
        Returns
        -------
        a gphoto2 error code
        
        See also gphoto2.PortInfoList.get_info
    
    gp_port_info_list_load(...)
        gp_port_info_list_load(PortInfoList list) -> int
        
        Load system ports.  
        
        Parameters
        ----------
        * `list` :  
            a #GPPortInfoList  
        
        Searches the system for io-drivers and appends them to the list. You
        would normally call this function once after gp_port_info_list_new and
        then use this list in order to supply gp_port_set_info with parameters
        or to do autodetection.  
        
        Returns
        -------
        a gphoto2 error code
        
        See also gphoto2.PortInfoList.load
    
    gp_port_info_list_lookup_name(...)
        gp_port_info_list_lookup_name(PortInfoList list, char const * name) -> int
        
        Look up a name in the list.  
        
        Parameters
        ----------
        * `list` :  
            a #GPPortInfoList  
        * `name` :  
            a name  
        
        Looks for an entry in the list with the exact given name.  
        
        Returns
        -------
        The index of the entry or a gphoto2 error code
        
        See also gphoto2.PortInfoList.lookup_name
    
    gp_port_info_list_lookup_path(...)
        gp_port_info_list_lookup_path(PortInfoList list, char const * path) -> int
        
        Lookup a specific path in the list.  
        
        Parameters
        ----------
        * `list` :  
            a #GPPortInfoList  
        * `path` :  
            a path  
        
        Looks for an entry in the list with the supplied path. If no exact match
        can be found, a regex search will be performed in the hope some driver
        claimed ports like "serial:*".  
        
        Returns
        -------
        The index of the entry or a gphoto2 error code
        
        See also gphoto2.PortInfoList.lookup_path
    
    gp_port_info_list_new(...)
        gp_port_info_list_new() -> int
        
        Create a new GPPortInfoList.  
        
        Parameters
        ----------
        * `list` :  
            pointer to a GPPortInfoList* which is allocated  
        
        Creates a new list which can later be filled with port infos
        (#GPPortInfo) using gp_port_info_list_load.  
        
        Returns
        -------
        a gphoto2 error code
        
        See also gphoto2.PortInfoList.new
    
    gp_port_library_version(...)
        gp_port_library_version(GPVersionVerbosity verbose) -> char const **
    
    gp_port_message_codeset(...)
        gp_port_message_codeset(char const * arg1) -> char const *
        
        Specify codeset for translations.  
        
        This function specifies the codeset that are used for the translated
        strings that are passed back by the libgphoto2_port functions.  
        
        This function is called by the gp_message_codeset() function, there is
        no need to call it yourself.  
        
        Parameters
        ----------
        * `codeset` :  
            new codeset to use  
        
        Returns
        -------
        the previous codeset
    
    gp_port_result_as_string(...)
        gp_port_result_as_string(int result) -> char const *
        
        gp_port_result_as_string:  
        
        Returns
        -------
        : a gphoto2 error code  
        
        Returns a string representation of a gphoto2 error code. Those are
        static error descriptions. You can get dynamic ones that explain the
        error more in depth using gp_port_get_error.  
        
        Return value: a string representation of a gphoto2 error code
    
    gp_result_as_string(...)
        gp_result_as_string(int result) -> char const *
        
        Translate a gphoto error code into a localized string.  
        
        Parameters
        ----------
        * `result` :  
            a gphoto2 error code  
        
        Translates a gphoto2 error code into a human readable string. If the
        error occurred in combination with a camera,
        gp_camera_get_result_as_string() should be used instead.  
        
        Returns
        -------
        A string representation of a gphoto2 error code
    
    gp_widget_add_choice(...)
        gp_widget_add_choice(CameraWidget widget, char const * choice) -> int
        
        Adds a choice to the CameraWidget.  
        
        Parameters
        ----------
        * `widget` :  
            a CameraWidget of type GP_WIDGET_RADIO or GP_WIDGET_MENU  
        * `choice` :  
        
        Returns
        -------
        a gphoto2 error code.
        
        See also gphoto2.CameraWidget.add_choice
    
    gp_widget_append(...)
        gp_widget_append(CameraWidget widget, CameraWidget child) -> int
        
        Appends a CameraWidget to a CameraWidget.  
        
        Parameters
        ----------
        * `widget` :  
            a CameraWidget  
        * `child` :  
            the CameraWidget you would like to append to above  
        
        Returns
        -------
        a gphoto2 error code.
        
        See also gphoto2.CameraWidget.append
    
    gp_widget_changed(...)
        gp_widget_changed(CameraWidget widget) -> int
        
        Tells if the widget has been changed.  
        
        Parameters
        ----------
        * `widget` :  
            a CameraWidget  
        
        Returns
        -------
        a gphoto2 error code or changed flag.  
        
        Returns 1 if the state of the CameraWidget has been changed or 0 if not.  
        
        Note: this formerly cleared the changed state. It no longer does with
        2.5.11.
        
        See also gphoto2.CameraWidget.changed
    
    gp_widget_count_children(...)
        gp_widget_count_children(CameraWidget widget) -> int
        
        Counts the children of the CameraWidget.  
        
        Parameters
        ----------
        * `widget` :  
            a CameraWidget  
        
        Returns
        -------
        a gphoto2 error code or number of children
        
        See also gphoto2.CameraWidget.count_children
    
    gp_widget_count_choices(...)
        gp_widget_count_choices(CameraWidget widget) -> int
        
        Counts the choices of the CameraWidget.  
        
        Parameters
        ----------
        * `widget` :  
            a CameraWidget of type GP_WIDGET_RADIO or GP_WIDGET_MENU  
        
        Returns
        -------
        a gphoto2 error code or number of choices.
        
        See also gphoto2.CameraWidget.count_choices
    
    gp_widget_get_child(...)
        gp_widget_get_child(CameraWidget widget, int child_number) -> int
        
        Retrieves the child number `child_number` of the parent.  
        
        Parameters
        ----------
        * `widget` :  
            a CameraWidget  
        * `child_number` :  
            the number of the child  
        * `child` :  
        
        Returns
        -------
        a gphoto2 error code.
        
        See also gphoto2.CameraWidget.get_child
    
    gp_widget_get_child_by_id(...)
        gp_widget_get_child_by_id(CameraWidget widget, int id) -> int
        
        Retrieves the child with id `id` of the widget.  
        
        Parameters
        ----------
        * `widget` :  
            a CameraWidget  
        * `id` :  
            the id of the child  
        * `child` :  
        
        Returns
        -------
        a gphoto2 error code.
        
        See also gphoto2.CameraWidget.get_child_by_id
    
    gp_widget_get_child_by_label(...)
        gp_widget_get_child_by_label(CameraWidget widget, char const * label) -> int
        
        Retrieves the child with label `label` of the CameraWidget.  
        
        Parameters
        ----------
        * `widget` :  
            a CameraWidget  
        * `label` :  
            the label of the child  
        * `child` :  
        
        Returns
        -------
        a gphoto2 error code.
        
        See also gphoto2.CameraWidget.get_child_by_label
    
    gp_widget_get_child_by_name(...)
        gp_widget_get_child_by_name(CameraWidget widget, char const * name) -> int
        
        Retrieves the child with name `name` of the widget.  
        
        Parameters
        ----------
        * `widget` :  
            a CameraWidget  
        * `name` :  
            the name of the child  
        
        Returns
        -------
        a gphoto2 error code.
        
        See also gphoto2.CameraWidget.get_child_by_name
    
    gp_widget_get_children(...)
        gp_widget_get_children(CameraWidget widget) -> int
        
        Gets all the child widgets of a CameraWidget. The return value is a list
        containing a gphoto2 error code and a Python iterator. The iterator can
        be used to get each child in sequence.
        
        Parameters
        ----------
        * `widget` :
            a CameraWidget
        
        Returns
        -------
        a gphoto2 error code and a Python iterator.
        
        See also gphoto2.CameraWidget.get_children
    
    gp_widget_get_choice(...)
        gp_widget_get_choice(CameraWidget widget, int choice_number) -> int
        
        Retrieves the choice number `choice_number`.  
        
        Parameters
        ----------
        * `widget` :  
            a CameraWidget of type GP_WIDGET_RADIO or GP_WIDGET_MENU  
        * `choice_number` :  
        * `choice` :  
        
        Returns
        -------
        a gphoto2 error code
        
        See also gphoto2.CameraWidget.get_choice
    
    gp_widget_get_choices(...)
        gp_widget_get_choices(CameraWidget widget) -> int
        
        Gets all the choice values of a CameraWidget. The return value is a list
        containing a gphoto2 error code and a Python iterator. The iterator can
        be used to get each choice in sequence.
        
        Parameters
        ----------
        * `widget` :
            a CameraWidget
        
        Returns
        -------
        a gphoto2 error code and a Python iterator.
        
        See also gphoto2.CameraWidget.get_choices
    
    gp_widget_get_id(...)
        gp_widget_get_id(CameraWidget widget) -> int
        
        Retrieves the unique id of the CameraWidget.  
        
        Parameters
        ----------
        * `widget` :  
            a CameraWidget  
        * `id` :  
        
        Returns
        -------
        a gphoto2 error code.
        
        See also gphoto2.CameraWidget.get_id
    
    gp_widget_get_info(...)
        gp_widget_get_info(CameraWidget widget) -> int
        
        Retrieves the information about the widget.  
        
        Parameters
        ----------
        * `widget` :  
            a CameraWidget  
        * `info` :  
        
        Returns
        -------
        a gphoto2 error code.
        
        See also gphoto2.CameraWidget.get_info
    
    gp_widget_get_label(...)
        gp_widget_get_label(CameraWidget widget) -> int
        
        Retrieves the label of the CameraWidget.  
        
        Parameters
        ----------
        * `widget` :  
            a CameraWidget  
        * `label` :  
        
        Returns
        -------
        a gphoto2 error code.
        
        See also gphoto2.CameraWidget.get_label
    
    gp_widget_get_name(...)
        gp_widget_get_name(CameraWidget widget) -> int
        
        Gets the name of the widget.  
        
        Parameters
        ----------
        * `widget` :  
            a CameraWidget  
        * `name` :  
            Name of above widget  
        
        Returns
        -------
        a gphoto2 error code.
        
        See also gphoto2.CameraWidget.get_name
    
    gp_widget_get_parent(...)
        gp_widget_get_parent(CameraWidget widget) -> int
        
        Retrieves the parent of a CameraWidget.  
        
        Parameters
        ----------
        * `widget` :  
            a CameraWidget  
        * `parent` :  
            the pointer to the parent to return  
        
        Returns
        -------
        a gphoto2 error code.
        
        See also gphoto2.CameraWidget.get_parent
    
    gp_widget_get_range(...)
        gp_widget_get_range(CameraWidget range) -> int
        
        Retrieves some range parameters of the CameraWidget.  
        
        Parameters
        ----------
        * `range` :  
            a CameraWidget of type GP_WIDGET_RANGE  
        * `min` :  
        * `max` :  
        * `increment` :  
        
        Returns
        -------
        a gphoto2 error code.
        
        See also gphoto2.CameraWidget.get_range
    
    gp_widget_get_readonly(...)
        gp_widget_get_readonly(CameraWidget widget) -> int
        
        Retrieves the readonly state of the CameraWidget.  
        
        Parameters
        ----------
        * `widget` :  
            a CameraWidget  
        * `readonly` :  
        
        Returns
        -------
        a gphoto2 error code.
        
        See also gphoto2.CameraWidget.get_readonly
    
    gp_widget_get_root(...)
        gp_widget_get_root(CameraWidget widget) -> int
        
        Retrieves the root of the CameraWidget.  
        
        Parameters
        ----------
        * `widget` :  
            a CameraWidget  
        * `root` :  
        
        Returns
        -------
        a gphoto2 error code.
        
        See also gphoto2.CameraWidget.get_root
    
    gp_widget_get_type(...)
        gp_widget_get_type(CameraWidget widget) -> int
        
        Retrieves the type of the CameraWidget.  
        
        Parameters
        ----------
        * `widget` :  
            a CameraWidget  
        * `type` :  
        
        Returns
        -------
        a gphoto2 error code.
        
        See also gphoto2.CameraWidget.get_type
    
    gp_widget_get_value(...)
        gp_widget_get_value(CameraWidget widget) -> int
        gp_widget_get_value(CameraWidget widget) -> int
        gp_widget_get_value(CameraWidget widget) -> int
        
        Retrieves the value of the CameraWidget.  
        
        Parameters
        ----------
        * `widget` :  
            a CameraWidget  
        * `value` :  
        
        Returns
        -------
        a gphoto2 error code.
        
        See also gphoto2.CameraWidget.get_value
    
    gp_widget_get_value_float(...)
        gp_widget_get_value_float(CameraWidget widget) -> int
        
        Deprecated
    
    gp_widget_get_value_int(...)
        gp_widget_get_value_int(CameraWidget widget) -> int
        
        Deprecated
    
    gp_widget_get_value_text(...)
        gp_widget_get_value_text(CameraWidget widget) -> int
        
        Deprecated
    
    gp_widget_new(...)
        gp_widget_new(CameraWidgetType type, char const * label) -> int
        
        Create a new widget.  
        
        The function creates a new CameraWidget of specified type and with given
        label.  
        
        Parameters
        ----------
        * `type` :  
            the type  
        * `label` :  
            the label  
        * `widget` :  
        
        Returns
        -------
        a gphoto2 error code.
        
        See also gphoto2.CameraWidget.new
    
    gp_widget_prepend(...)
        gp_widget_prepend(CameraWidget widget, CameraWidget child) -> int
        
        Prepends a CameraWidget to a CameraWidget.  
        
        Parameters
        ----------
        * `widget` :  
            a CameraWidget  
        * `child` :  
            the CameraWidget you would like to prepend to above  
        
        Returns
        -------
        a gphoto2 error code.
        
        See also gphoto2.CameraWidget.prepend
    
    gp_widget_set_changed(...)
        gp_widget_set_changed(CameraWidget widget, int changed) -> int
        
        Tells that the widget has been changed.  
        
        Parameters
        ----------
        * `widget` :  
            a CameraWidget  
        * `changed` :  
            a boolean whether we changed or not  
        
        Returns
        -------
        a gphoto2 error code  
        
        Sets the changed of the CameraWidget depending on the changed parameter.
        
        See also gphoto2.CameraWidget.set_changed
    
    gp_widget_set_info(...)
        gp_widget_set_info(CameraWidget widget, char const * info) -> int
        
        Sets the information about the widget.  
        
        Parameters
        ----------
        * `widget` :  
            a CameraWidget  
        * `info` :  
            Information about above widget  
        
        Returns
        -------
        a gphoto2 error code.
        
        See also gphoto2.CameraWidget.set_info
    
    gp_widget_set_name(...)
        gp_widget_set_name(CameraWidget widget, char const * name) -> int
        
        Sets the name of the widget.  
        
        Parameters
        ----------
        * `widget` :  
            a CameraWidget  
        * `name` :  
            Name of above widget  
        
        Returns
        -------
        a gphoto2 error code.
        
        See also gphoto2.CameraWidget.set_name
    
    gp_widget_set_range(...)
        gp_widget_set_range(CameraWidget range, float low, float high, float increment) -> int
        
        Sets some range parameters of the CameraWidget.  
        
        Parameters
        ----------
        * `range` :  
            a CameraWidget of type GP_WIDGET_RANGE  
        * `min` :  
        * `max` :  
        * `increment` :  
        
        Returns
        -------
        a gphoto2 error code.
        
        See also gphoto2.CameraWidget.set_range
    
    gp_widget_set_readonly(...)
        gp_widget_set_readonly(CameraWidget widget, int readonly) -> int
        
        Tells that the widget is readonly.  
        
        Parameters
        ----------
        * `widget` :  
            a CameraWidget  
        * `changed` :  
            a boolean whether we are readonly or not  
        
        Returns
        -------
        a gphoto2 error code  
        
        Sets the readonly of the CameraWidget depending on the changed
        parameter.  
        
        Only useful when called from the camera driver.
        
        See also gphoto2.CameraWidget.set_readonly
    
    gp_widget_set_value(...)
        gp_widget_set_value(CameraWidget widget, char const * value) -> int
        gp_widget_set_value(CameraWidget widget, float const * value) -> int
        gp_widget_set_value(CameraWidget widget, int const * value) -> int
        
        Sets the value of the widget.  
        
        Parameters
        ----------
        * `widget` :  
            a CameraWidget  
        * `value` :  
        
        Returns
        -------
        a gphoto2 error code.  
        
        Please pass (char*) for GP_WIDGET_MENU, GP_WIDGET_TEXT, GP_WIDGET_RADIO,
        (float) for GP_WIDGET_RANGE, (int) for GP_WIDGET_DATE, GP_WIDGET_TOGGLE,
        and (CameraWidgetCallback) for GP_WIDGET_BUTTON.
        
        See also gphoto2.CameraWidget.set_value
    
    gp_widget_set_value_float(...)
        gp_widget_set_value_float(CameraWidget widget, float const value) -> int
        
        Deprecated
    
    gp_widget_set_value_int(...)
        gp_widget_set_value_int(CameraWidget widget, int const value) -> int
        
        Deprecated
    
    gp_widget_set_value_text(...)
        gp_widget_set_value_text(CameraWidget widget, char const * value) -> int
        
        Deprecated

DATA
    GP_CAPTURE_IMAGE = 0
    GP_CAPTURE_MOVIE = 1
    GP_CAPTURE_SOUND = 2
    GP_CONTEXT_FEEDBACK_CANCEL = 1
    GP_CONTEXT_FEEDBACK_OK = 0
    GP_DEVICE_AUDIO_PLAYER = 1
    GP_DEVICE_STILL_CAMERA = 0
    GP_DRIVER_STATUS_DEPRECATED = 3
    GP_DRIVER_STATUS_EXPERIMENTAL = 2
    GP_DRIVER_STATUS_PRODUCTION = 0
    GP_DRIVER_STATUS_TESTING = 1
    GP_ERROR = -1
    GP_ERROR_BAD_PARAMETERS = -2
    GP_ERROR_CAMERA_BUSY = -110
    GP_ERROR_CAMERA_ERROR = -113
    GP_ERROR_CANCEL = -112
    GP_ERROR_CORRUPTED_DATA = -102
    GP_ERROR_DIRECTORY_EXISTS = -109
    GP_ERROR_DIRECTORY_NOT_FOUND = -107
    GP_ERROR_FILE_EXISTS = -103
    GP_ERROR_FILE_NOT_FOUND = -108
    GP_ERROR_FIXED_LIMIT_EXCEEDED = -8
    GP_ERROR_HAL = -70
    GP_ERROR_IO = -7
    GP_ERROR_IO_INIT = -31
    GP_ERROR_IO_LOCK = -60
    GP_ERROR_IO_READ = -34
    GP_ERROR_IO_SERIAL_SPEED = -41
    GP_ERROR_IO_SUPPORTED_SERIAL = -20
    GP_ERROR_IO_SUPPORTED_USB = -21
    GP_ERROR_IO_UPDATE = -37
    GP_ERROR_IO_USB_CLAIM = -53
    GP_ERROR_IO_USB_CLEAR_HALT = -51
    GP_ERROR_IO_USB_FIND = -52
    GP_ERROR_IO_WRITE = -35
    GP_ERROR_LIBRARY = -4
    GP_ERROR_MODEL_NOT_FOUND = -105
    GP_ERROR_NOT_SUPPORTED = -6
    GP_ERROR_NO_MEMORY = -3
    GP_ERROR_NO_SPACE = -115
    GP_ERROR_OS_FAILURE = -114
    GP_ERROR_PATH_NOT_ABSOLUTE = -111
    GP_ERROR_TIMEOUT = -10
    GP_ERROR_UNKNOWN_PORT = -5
    GP_EVENT_CAPTURE_COMPLETE = 4
    GP_EVENT_FILE_ADDED = 2
    GP_EVENT_FOLDER_ADDED = 3
    GP_EVENT_TIMEOUT = 1
    GP_EVENT_UNKNOWN = 0
    GP_FILE_ACCESSTYPE_FD = 1
    GP_FILE_ACCESSTYPE_HANDLER = 2
    GP_FILE_ACCESSTYPE_MEMORY = 0
    GP_FILE_INFO_ALL = 255
    GP_FILE_INFO_HEIGHT = 16
    GP_FILE_INFO_MTIME = 128
    GP_FILE_INFO_NONE = 0
    GP_FILE_INFO_PERMISSIONS = 32
    GP_FILE_INFO_SIZE = 4
    GP_FILE_INFO_STATUS = 64
    GP_FILE_INFO_TYPE = 1
    GP_FILE_INFO_WIDTH = 8
    GP_FILE_OPERATION_AUDIO = 32
    GP_FILE_OPERATION_DELETE = 2
    GP_FILE_OPERATION_EXIF = 64
    GP_FILE_OPERATION_NONE = 0
    GP_FILE_OPERATION_PREVIEW = 8
    GP_FILE_OPERATION_RAW = 16
    GP_FILE_PERM_ALL = 255
    GP_FILE_PERM_DELETE = 2
    GP_FILE_PERM_NONE = 0
    GP_FILE_PERM_READ = 1
    GP_FILE_STATUS_DOWNLOADED = 1
    GP_FILE_STATUS_NOT_DOWNLOADED = 0
    GP_FILE_TYPE_AUDIO = 3
    GP_FILE_TYPE_EXIF = 4
    GP_FILE_TYPE_METADATA = 5
    GP_FILE_TYPE_NORMAL = 1
    GP_FILE_TYPE_PREVIEW = 0
    GP_FILE_TYPE_RAW = 2
    GP_FOLDER_OPERATION_DELETE_ALL = 1
    GP_FOLDER_OPERATION_MAKE_DIR = 4
    GP_FOLDER_OPERATION_NONE = 0
    GP_FOLDER_OPERATION_PUT_FILE = 2
    GP_FOLDER_OPERATION_REMOVE_DIR = 8
    GP_LOG_DATA = 3
    GP_LOG_DEBUG = 2
    GP_LOG_ERROR = 0
    GP_LOG_VERBOSE = 1
    GP_MIME_ARW = 'image/x-sony-arw'
    GP_MIME_ASF = 'audio/x-asf'
    GP_MIME_AVCHD = 'video/mp2t'
    GP_MIME_AVI = 'video/x-msvideo'
    GP_MIME_BMP = 'image/bmp'
    GP_MIME_CR2 = 'image/x-canon-cr2'
    GP_MIME_CRW = 'image/x-canon-raw'
    GP_MIME_EXIF = 'application/x-exif'
    GP_MIME_JPEG = 'image/jpeg'
    GP_MIME_MP3 = 'audio/mpeg'
    GP_MIME_MPEG = 'video/mpeg'
    GP_MIME_NEF = 'image/x-nikon-nef'
    GP_MIME_OGG = 'application/ogg'
    GP_MIME_PGM = 'image/x-portable-graymap'
    GP_MIME_PNG = 'image/png'
    GP_MIME_PNM = 'image/x-portable-anymap'
    GP_MIME_PPM = 'image/x-portable-pixmap'
    GP_MIME_QUICKTIME = 'video/quicktime'
    GP_MIME_RAW = 'image/x-raw'
    GP_MIME_RW2 = 'image/x-panasonic-raw2'
    GP_MIME_TIFF = 'image/tiff'
    GP_MIME_TXT = 'text/plain'
    GP_MIME_UNKNOWN = 'application/octet-stream'
    GP_MIME_WAV = 'audio/wav'
    GP_MIME_WMA = 'audio/x-wma'
    GP_OK = 0
    GP_OPERATION_CAPTURE_AUDIO = 4
    GP_OPERATION_CAPTURE_IMAGE = 1
    GP_OPERATION_CAPTURE_PREVIEW = 8
    GP_OPERATION_CAPTURE_VIDEO = 2
    GP_OPERATION_CONFIG = 16
    GP_OPERATION_NONE = 0
    GP_OPERATION_TRIGGER_CAPTURE = 32
    GP_PORT_DISK = 8
    GP_PORT_NONE = 0
    GP_PORT_PTPIP = 16
    GP_PORT_SERIAL = 1
    GP_PORT_USB = 4
    GP_PORT_USB_DISK_DIRECT = 32
    GP_PORT_USB_SCSI = 64
    GP_STORAGEINFO_ACCESS = 8
    GP_STORAGEINFO_AC_READONLY = 1
    GP_STORAGEINFO_AC_READONLY_WITH_DELETE = 2
    GP_STORAGEINFO_AC_READWRITE = 0
    GP_STORAGEINFO_BASE = 1
    GP_STORAGEINFO_DESCRIPTION = 4
    GP_STORAGEINFO_FILESYSTEMTYPE = 32
    GP_STORAGEINFO_FREESPACEIMAGES = 256
    GP_STORAGEINFO_FREESPACEKBYTES = 128
    GP_STORAGEINFO_FST_DCF = 3
    GP_STORAGEINFO_FST_GENERICFLAT = 1
    GP_STORAGEINFO_FST_GENERICHIERARCHICAL = 2
    GP_STORAGEINFO_FST_UNDEFINED = 0
    GP_STORAGEINFO_LABEL = 2
    GP_STORAGEINFO_MAXCAPACITY = 64
    GP_STORAGEINFO_STORAGETYPE = 16
    GP_STORAGEINFO_ST_FIXED_RAM = 3
    GP_STORAGEINFO_ST_FIXED_ROM = 1
    GP_STORAGEINFO_ST_REMOVABLE_RAM = 4
    GP_STORAGEINFO_ST_REMOVABLE_ROM = 2
    GP_STORAGEINFO_ST_UNKNOWN = 0
    GP_VERSION_SHORT = 0
    GP_VERSION_VERBOSE = 1
    GP_WIDGET_BUTTON = 7
    GP_WIDGET_DATE = 8
    GP_WIDGET_MENU = 6
    GP_WIDGET_RADIO = 5
    GP_WIDGET_RANGE = 3
    GP_WIDGET_SECTION = 1
    GP_WIDGET_TEXT = 2
    GP_WIDGET_TOGGLE = 4
    GP_WIDGET_WINDOW = 0
    error_exception = 40
    error_severity = {-112: 20, -109: 30}

VERSION
    1.8.2

FILE
    /Users/dnarayanan/currentproj/seniordesign/Camera-Control/camEnv/lib/python3.6/site-packages/gphoto2/__init__.py