void register_ChainVariantProperty_class(){

    { //::SireMol::ChainProperty< QVariant >
        typedef bp::class_< SireMol::ChainProperty< QVariant >, bp::bases< SireMol::ChainProp, SireMol::MolViewProperty, SireBase::Property > > ChainVariantProperty_exposer_t;
        ChainVariantProperty_exposer_t ChainVariantProperty_exposer = ChainVariantProperty_exposer_t( "ChainVariantProperty", "", bp::init< >("") );
        bp::scope ChainVariantProperty_scope( ChainVariantProperty_exposer );
        ChainVariantProperty_exposer.def( bp::init< SireMol::MoleculeInfoData const & >(( bp::arg("molinfo") ), "") );
        ChainVariantProperty_exposer.def( bp::init< QVector< QVariant > const & >(( bp::arg("values") ), "") );
        ChainVariantProperty_exposer.def( bp::init< SireMol::ChainProperty< QVariant > const & >(( bp::arg("other") ), "") );
        { //::SireMol::ChainProperty< QVariant >::array
        
            typedef SireMol::ChainProperty< QVariant > exported_class_t;
            typedef ::QVector< QVariant > const & ( ::SireMol::ChainProperty< QVariant >::*array_function_type)(  ) const;
            array_function_type array_function_value( &::SireMol::ChainProperty< QVariant >::array );
            
            ChainVariantProperty_exposer.def( 
                "array"
                , array_function_value
                , bp::return_value_policy< bp::copy_const_reference >()
                , "" );
        
        }
        { //::SireMol::ChainProperty< QVariant >::assertCanConvert
        
            typedef SireMol::ChainProperty< QVariant > exported_class_t;
            typedef void ( ::SireMol::ChainProperty< QVariant >::*assertCanConvert_function_type)( ::QVariant const & ) const;
            assertCanConvert_function_type assertCanConvert_function_value( &::SireMol::ChainProperty< QVariant >::assertCanConvert );
            
            ChainVariantProperty_exposer.def( 
                "assertCanConvert"
                , assertCanConvert_function_value
                , ( bp::arg("value") )
                , "" );
        
        }
        { //::SireMol::ChainProperty< QVariant >::assignFrom
        
            typedef SireMol::ChainProperty< QVariant > exported_class_t;
            typedef void ( ::SireMol::ChainProperty< QVariant >::*assignFrom_function_type)( ::SireMol::ChainProperty< QVariant > const & ) ;
            assignFrom_function_type assignFrom_function_value( &::SireMol::ChainProperty< QVariant >::assignFrom );
            
            ChainVariantProperty_exposer.def( 
                "assignFrom"
                , assignFrom_function_value
                , ( bp::arg("values") )
                , "" );
        
        }
        { //::SireMol::ChainProperty< QVariant >::at
        
            typedef SireMol::ChainProperty< QVariant > exported_class_t;
            typedef ::QVariant const & ( ::SireMol::ChainProperty< QVariant >::*at_function_type)( ::SireMol::ChainIdx const & ) const;
            at_function_type at_function_value( &::SireMol::ChainProperty< QVariant >::at );
            
            ChainVariantProperty_exposer.def( 
                "at"
                , at_function_value
                , ( bp::arg("chainidx") )
                , bp::return_value_policy< bp::copy_const_reference >()
                , "" );
        
        }
        { //::SireMol::ChainProperty< QVariant >::canConvert
        
            typedef SireMol::ChainProperty< QVariant > exported_class_t;
            typedef bool ( ::SireMol::ChainProperty< QVariant >::*canConvert_function_type)( ::QVariant const & ) const;
            canConvert_function_type canConvert_function_value( &::SireMol::ChainProperty< QVariant >::canConvert );
            
            ChainVariantProperty_exposer.def( 
                "canConvert"
                , canConvert_function_value
                , ( bp::arg("value") )
                , "" );
        
        }
        { //::SireMol::ChainProperty< QVariant >::count
        
            typedef SireMol::ChainProperty< QVariant > exported_class_t;
            typedef int ( ::SireMol::ChainProperty< QVariant >::*count_function_type)(  ) const;
            count_function_type count_function_value( &::SireMol::ChainProperty< QVariant >::count );
            
            ChainVariantProperty_exposer.def( 
                "count"
                , count_function_value
                , "" );
        
        }
        { //::SireMol::ChainProperty< QVariant >::fromVariant
        
            typedef SireMol::ChainProperty< QVariant > exported_class_t;
            typedef ::SireMol::ChainProperty< QVariant > ( *fromVariant_function_type )( ::SireMol::ChainProperty< QVariant > const & );
            fromVariant_function_type fromVariant_function_value( &::SireMol::ChainProperty< QVariant >::fromVariant );
            
            ChainVariantProperty_exposer.def( 
                "fromVariant"
                , fromVariant_function_value
                , ( bp::arg("values") )
                , "" );
        
        }
        { //::SireMol::ChainProperty< QVariant >::get
        
            typedef SireMol::ChainProperty< QVariant > exported_class_t;
            typedef ::QVariant const & ( ::SireMol::ChainProperty< QVariant >::*get_function_type)( ::SireMol::ChainIdx const & ) const;
            get_function_type get_function_value( &::SireMol::ChainProperty< QVariant >::get );
            
            ChainVariantProperty_exposer.def( 
                "get"
                , get_function_value
                , ( bp::arg("chainidx") )
                , bp::return_value_policy< bp::copy_const_reference >()
                , "" );
        
        }
        { //::SireMol::ChainProperty< QVariant >::isCompatibleWith
        
            typedef SireMol::ChainProperty< QVariant > exported_class_t;
            typedef bool ( ::SireMol::ChainProperty< QVariant >::*isCompatibleWith_function_type)( ::SireMol::MoleculeInfoData const & ) const;
            isCompatibleWith_function_type isCompatibleWith_function_value( &::SireMol::ChainProperty< QVariant >::isCompatibleWith );
            
            ChainVariantProperty_exposer.def( 
                "isCompatibleWith"
                , isCompatibleWith_function_value
                , ( bp::arg("molinfo") )
                , "" );
        
        }
        { //::SireMol::ChainProperty< QVariant >::isEmpty
        
            typedef SireMol::ChainProperty< QVariant > exported_class_t;
            typedef bool ( ::SireMol::ChainProperty< QVariant >::*isEmpty_function_type)(  ) const;
            isEmpty_function_type isEmpty_function_value( &::SireMol::ChainProperty< QVariant >::isEmpty );
            
            ChainVariantProperty_exposer.def( 
                "isEmpty"
                , isEmpty_function_value
                , "" );
        
        }
        { //::SireMol::ChainProperty< QVariant >::nChains
        
            typedef SireMol::ChainProperty< QVariant > exported_class_t;
            typedef int ( ::SireMol::ChainProperty< QVariant >::*nChains_function_type)(  ) const;
            nChains_function_type nChains_function_value( &::SireMol::ChainProperty< QVariant >::nChains );
            
            ChainVariantProperty_exposer.def( 
                "nChains"
                , nChains_function_value
                , "" );
        
        }
        ChainVariantProperty_exposer.def( bp::self != bp::self );
        { //::SireMol::ChainProperty< QVariant >::operator=
        
            typedef SireMol::ChainProperty< QVariant > exported_class_t;
            typedef ::SireMol::ChainProperty< QVariant > & ( ::SireMol::ChainProperty< QVariant >::*assign_function_type)( ::SireMol::ChainProperty< QVariant > const & ) ;
            assign_function_type assign_function_value( &::SireMol::ChainProperty< QVariant >::operator= );
            
            ChainVariantProperty_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >()
                , "" );
        
        }
        ChainVariantProperty_exposer.def( bp::self == bp::self );
        { //::SireMol::ChainProperty< QVariant >::operator[]
        
            typedef SireMol::ChainProperty< QVariant > exported_class_t;
            typedef ::QVariant const & ( ::SireMol::ChainProperty< QVariant >::*__getitem___function_type)( ::SireMol::ChainIdx const & ) const;
            __getitem___function_type __getitem___function_value( &::SireMol::ChainProperty< QVariant >::operator[] );
            
            ChainVariantProperty_exposer.def( 
                "__getitem__"
                , __getitem___function_value
                , ( bp::arg("chainidx") )
                , bp::return_value_policy< bp::copy_const_reference >()
                , "" );
        
        }
        { //::SireMol::ChainProperty< QVariant >::set
        
            typedef SireMol::ChainProperty< QVariant > exported_class_t;
            typedef ::SireMol::ChainProperty< QVariant > & ( ::SireMol::ChainProperty< QVariant >::*set_function_type)( ::SireMol::ChainIdx,::QVariant const & ) ;
            set_function_type set_function_value( &::SireMol::ChainProperty< QVariant >::set );
            
            ChainVariantProperty_exposer.def( 
                "set"
                , set_function_value
                , ( bp::arg("chainidx"), bp::arg("value") )
                , bp::return_self< >()
                , "" );
        
        }
        { //::SireMol::ChainProperty< QVariant >::size
        
            typedef SireMol::ChainProperty< QVariant > exported_class_t;
            typedef int ( ::SireMol::ChainProperty< QVariant >::*size_function_type)(  ) const;
            size_function_type size_function_value( &::SireMol::ChainProperty< QVariant >::size );
            
            ChainVariantProperty_exposer.def( 
                "size"
                , size_function_value
                , "" );
        
        }
        { //::SireMol::ChainProperty< QVariant >::toString
        
            typedef SireMol::ChainProperty< QVariant > exported_class_t;
            typedef ::QString ( ::SireMol::ChainProperty< QVariant >::*toString_function_type)(  ) const;
            toString_function_type toString_function_value( &::SireMol::ChainProperty< QVariant >::toString );
            
            ChainVariantProperty_exposer.def( 
                "toString"
                , toString_function_value
                , "" );
        
        }
        { //::SireMol::ChainProperty< QVariant >::toVariant
        
            typedef SireMol::ChainProperty< QVariant > exported_class_t;
            typedef ::SireMol::ChainProperty< QVariant > ( ::SireMol::ChainProperty< QVariant >::*toVariant_function_type)(  ) const;
            toVariant_function_type toVariant_function_value( &::SireMol::ChainProperty< QVariant >::toVariant );
            
            ChainVariantProperty_exposer.def( 
                "toVariant"
                , toVariant_function_value
                , "" );
        
        }
        { //::SireMol::ChainProperty< QVariant >::typeName
        
            typedef SireMol::ChainProperty< QVariant > exported_class_t;
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireMol::ChainProperty< QVariant >::typeName );
            
            ChainVariantProperty_exposer.def( 
                "typeName"
                , typeName_function_value
                , "" );
        
        }
        ChainVariantProperty_exposer.staticmethod( "fromVariant" );
        ChainVariantProperty_exposer.staticmethod( "typeName" );
        ChainVariantProperty_exposer.def( "__copy__", &__copy__);
        ChainVariantProperty_exposer.def( "__deepcopy__", &__copy__);
        ChainVariantProperty_exposer.def( "clone", &__copy__);
        ChainVariantProperty_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::ChainProperty<QVariant> >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        ChainVariantProperty_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::ChainProperty<QVariant> >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        ChainVariantProperty_exposer.def( "__str__", &__str__< ::SireMol::ChainProperty<QVariant> > );
        ChainVariantProperty_exposer.def( "__repr__", &__str__< ::SireMol::ChainProperty<QVariant> > );
        ChainVariantProperty_exposer.def( "__len__", &__len_size< ::SireMol::ChainProperty<QVariant> > );
    }

}
void register_PartialMolecule_class(){

    { //::SireMol::PartialMolecule
        typedef bp::class_< SireMol::PartialMolecule, bp::bases< SireMol::MoleculeView, SireBase::Property > > PartialMolecule_exposer_t;
        PartialMolecule_exposer_t PartialMolecule_exposer = PartialMolecule_exposer_t( "PartialMolecule", bp::init< >() );
        bp::scope PartialMolecule_scope( PartialMolecule_exposer );
        PartialMolecule_exposer.def( bp::init< SireMol::MoleculeView const & >(( bp::arg("molecule") )) );
        PartialMolecule_exposer.def( bp::init< SireMol::MoleculeData const &, SireMol::AtomSelection const & >(( bp::arg("moldata"), bp::arg("atoms") )) );
        PartialMolecule_exposer.def( bp::init< SireMol::PartialMolecule const & >(( bp::arg("other") )) );
        { //::SireMol::PartialMolecule::evaluate
        
            typedef ::SireMol::Evaluator ( ::SireMol::PartialMolecule::*evaluate_function_type )(  ) const;
            evaluate_function_type evaluate_function_value( &::SireMol::PartialMolecule::evaluate );
            
            PartialMolecule_exposer.def( 
                "evaluate"
                , evaluate_function_value );
        
        }
        { //::SireMol::PartialMolecule::extract
        
            typedef ::SireMol::PartialMolecule ( ::SireMol::PartialMolecule::*extract_function_type )(  ) const;
            extract_function_type extract_function_value( &::SireMol::PartialMolecule::extract );
            
            PartialMolecule_exposer.def( 
                "extract"
                , extract_function_value );
        
        }
        { //::SireMol::PartialMolecule::hasMetadata
        
            typedef bool ( ::SireMol::PartialMolecule::*hasMetadata_function_type )( ::SireBase::PropertyName const & ) const;
            hasMetadata_function_type hasMetadata_function_value( &::SireMol::PartialMolecule::hasMetadata );
            
            PartialMolecule_exposer.def( 
                "hasMetadata"
                , hasMetadata_function_value
                , ( bp::arg("metakey") ) );
        
        }
        { //::SireMol::PartialMolecule::hasMetadata
        
            typedef bool ( ::SireMol::PartialMolecule::*hasMetadata_function_type )( ::SireBase::PropertyName const &,::SireBase::PropertyName const & ) const;
            hasMetadata_function_type hasMetadata_function_value( &::SireMol::PartialMolecule::hasMetadata );
            
            PartialMolecule_exposer.def( 
                "hasMetadata"
                , hasMetadata_function_value
                , ( bp::arg("key"), bp::arg("metakey") ) );
        
        }
        { //::SireMol::PartialMolecule::hasProperty
        
            typedef bool ( ::SireMol::PartialMolecule::*hasProperty_function_type )( ::SireBase::PropertyName const & ) const;
            hasProperty_function_type hasProperty_function_value( &::SireMol::PartialMolecule::hasProperty );
            
            PartialMolecule_exposer.def( 
                "hasProperty"
                , hasProperty_function_value
                , ( bp::arg("key") ) );
        
        }
        { //::SireMol::PartialMolecule::isEmpty
        
            typedef bool ( ::SireMol::PartialMolecule::*isEmpty_function_type )(  ) const;
            isEmpty_function_type isEmpty_function_value( &::SireMol::PartialMolecule::isEmpty );
            
            PartialMolecule_exposer.def( 
                "isEmpty"
                , isEmpty_function_value );
        
        }
        { //::SireMol::PartialMolecule::metadata
        
            typedef ::SireBase::Property const & ( ::SireMol::PartialMolecule::*metadata_function_type )( ::SireBase::PropertyName const & ) const;
            metadata_function_type metadata_function_value( &::SireMol::PartialMolecule::metadata );
            
            PartialMolecule_exposer.def( 
                "metadata"
                , metadata_function_value
                , ( bp::arg("metakey") )
                , bp::return_value_policy<bp::clone_const_reference>() );
        
        }
        { //::SireMol::PartialMolecule::metadata
        
            typedef ::SireBase::Property const & ( ::SireMol::PartialMolecule::*metadata_function_type )( ::SireBase::PropertyName const &,::SireBase::PropertyName const & ) const;
            metadata_function_type metadata_function_value( &::SireMol::PartialMolecule::metadata );
            
            PartialMolecule_exposer.def( 
                "metadata"
                , metadata_function_value
                , ( bp::arg("key"), bp::arg("metakey") )
                , bp::return_value_policy<bp::clone_const_reference>() );
        
        }
        { //::SireMol::PartialMolecule::metadataKeys
        
            typedef ::QStringList ( ::SireMol::PartialMolecule::*metadataKeys_function_type )(  ) const;
            metadataKeys_function_type metadataKeys_function_value( &::SireMol::PartialMolecule::metadataKeys );
            
            PartialMolecule_exposer.def( 
                "metadataKeys"
                , metadataKeys_function_value );
        
        }
        { //::SireMol::PartialMolecule::metadataKeys
        
            typedef ::QStringList ( ::SireMol::PartialMolecule::*metadataKeys_function_type )( ::SireBase::PropertyName const & ) const;
            metadataKeys_function_type metadataKeys_function_value( &::SireMol::PartialMolecule::metadataKeys );
            
            PartialMolecule_exposer.def( 
                "metadataKeys"
                , metadataKeys_function_value
                , ( bp::arg("key") ) );
        
        }
        { //::SireMol::PartialMolecule::move
        
            typedef ::SireMol::Mover< SireMol::PartialMolecule > ( ::SireMol::PartialMolecule::*move_function_type )(  ) const;
            move_function_type move_function_value( &::SireMol::PartialMolecule::move );
            
            PartialMolecule_exposer.def( 
                "move"
                , move_function_value );
        
        }
        { //::SireMol::PartialMolecule::nAtoms
        
            typedef int ( ::SireMol::PartialMolecule::*nAtoms_function_type )(  ) const;
            nAtoms_function_type nAtoms_function_value( &::SireMol::PartialMolecule::nAtoms );
            
            PartialMolecule_exposer.def( 
                "nAtoms"
                , nAtoms_function_value );
        
        }
        { //::SireMol::PartialMolecule::nChains
        
            typedef int ( ::SireMol::PartialMolecule::*nChains_function_type )(  ) const;
            nChains_function_type nChains_function_value( &::SireMol::PartialMolecule::nChains );
            
            PartialMolecule_exposer.def( 
                "nChains"
                , nChains_function_value );
        
        }
        { //::SireMol::PartialMolecule::nCutGroups
        
            typedef int ( ::SireMol::PartialMolecule::*nCutGroups_function_type )(  ) const;
            nCutGroups_function_type nCutGroups_function_value( &::SireMol::PartialMolecule::nCutGroups );
            
            PartialMolecule_exposer.def( 
                "nCutGroups"
                , nCutGroups_function_value );
        
        }
        { //::SireMol::PartialMolecule::nResidues
        
            typedef int ( ::SireMol::PartialMolecule::*nResidues_function_type )(  ) const;
            nResidues_function_type nResidues_function_value( &::SireMol::PartialMolecule::nResidues );
            
            PartialMolecule_exposer.def( 
                "nResidues"
                , nResidues_function_value );
        
        }
        { //::SireMol::PartialMolecule::nSegments
        
            typedef int ( ::SireMol::PartialMolecule::*nSegments_function_type )(  ) const;
            nSegments_function_type nSegments_function_value( &::SireMol::PartialMolecule::nSegments );
            
            PartialMolecule_exposer.def( 
                "nSegments"
                , nSegments_function_value );
        
        }
        { //::SireMol::PartialMolecule::name
        
            typedef ::SireMol::MolName const & ( ::SireMol::PartialMolecule::*name_function_type )(  ) const;
            name_function_type name_function_value( &::SireMol::PartialMolecule::name );
            
            PartialMolecule_exposer.def( 
                "name"
                , name_function_value
                , bp::return_value_policy<bp::clone_const_reference>() );
        
        }
        { //::SireMol::PartialMolecule::number
        
            typedef ::SireMol::MolNum ( ::SireMol::PartialMolecule::*number_function_type )(  ) const;
            number_function_type number_function_value( &::SireMol::PartialMolecule::number );
            
            PartialMolecule_exposer.def( 
                "number"
                , number_function_value );
        
        }
        PartialMolecule_exposer.def( bp::self != bp::self );
        { //::SireMol::PartialMolecule::operator=
        
            typedef ::SireMol::PartialMolecule & ( ::SireMol::PartialMolecule::*assign_function_type )( ::SireMol::MoleculeView const & ) ;
            assign_function_type assign_function_value( &::SireMol::PartialMolecule::operator= );
            
            PartialMolecule_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >() );
        
        }
        { //::SireMol::PartialMolecule::operator=
        
            typedef ::SireMol::PartialMolecule & ( ::SireMol::PartialMolecule::*assign_function_type )( ::SireMol::PartialMolecule const & ) ;
            assign_function_type assign_function_value( &::SireMol::PartialMolecule::operator= );
            
            PartialMolecule_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >() );
        
        }
        PartialMolecule_exposer.def( bp::self == bp::self );
        { //::SireMol::PartialMolecule::property
        
            typedef ::SireBase::Property const & ( ::SireMol::PartialMolecule::*property_function_type )( ::SireBase::PropertyName const & ) const;
            property_function_type property_function_value( &::SireMol::PartialMolecule::property );
            
            PartialMolecule_exposer.def( 
                "property"
                , property_function_value
                , ( bp::arg("key") )
                , bp::return_value_policy<bp::clone_const_reference>() );
        
        }
        { //::SireMol::PartialMolecule::propertyKeys
        
            typedef ::QStringList ( ::SireMol::PartialMolecule::*propertyKeys_function_type )(  ) const;
            propertyKeys_function_type propertyKeys_function_value( &::SireMol::PartialMolecule::propertyKeys );
            
            PartialMolecule_exposer.def( 
                "propertyKeys"
                , propertyKeys_function_value );
        
        }
        { //::SireMol::PartialMolecule::selectedAll
        
            typedef bool ( ::SireMol::PartialMolecule::*selectedAll_function_type )(  ) const;
            selectedAll_function_type selectedAll_function_value( &::SireMol::PartialMolecule::selectedAll );
            
            PartialMolecule_exposer.def( 
                "selectedAll"
                , selectedAll_function_value );
        
        }
        { //::SireMol::PartialMolecule::selection
        
            typedef ::SireMol::AtomSelection ( ::SireMol::PartialMolecule::*selection_function_type )(  ) const;
            selection_function_type selection_function_value( &::SireMol::PartialMolecule::selection );
            
            PartialMolecule_exposer.def( 
                "selection"
                , selection_function_value );
        
        }
        { //::SireMol::PartialMolecule::toString
        
            typedef ::QString ( ::SireMol::PartialMolecule::*toString_function_type )(  ) const;
            toString_function_type toString_function_value( &::SireMol::PartialMolecule::toString );
            
            PartialMolecule_exposer.def( 
                "toString"
                , toString_function_value );
        
        }
        { //::SireMol::PartialMolecule::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireMol::PartialMolecule::typeName );
            
            PartialMolecule_exposer.def( 
                "typeName"
                , typeName_function_value );
        
        }
        { //::SireMol::PartialMolecule::version
        
            typedef ::quint64 ( ::SireMol::PartialMolecule::*version_function_type )(  ) const;
            version_function_type version_function_value( &::SireMol::PartialMolecule::version );
            
            PartialMolecule_exposer.def( 
                "version"
                , version_function_value );
        
        }
        { //::SireMol::PartialMolecule::version
        
            typedef ::quint64 ( ::SireMol::PartialMolecule::*version_function_type )( ::SireBase::PropertyName const & ) const;
            version_function_type version_function_value( &::SireMol::PartialMolecule::version );
            
            PartialMolecule_exposer.def( 
                "version"
                , version_function_value
                , ( bp::arg("key") ) );
        
        }
        PartialMolecule_exposer.staticmethod( "typeName" );
        PartialMolecule_exposer.def( "__copy__", &__copy__);
        PartialMolecule_exposer.def( "__deepcopy__", &__copy__);
        PartialMolecule_exposer.def( "clone", &__copy__);
        PartialMolecule_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::PartialMolecule >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        PartialMolecule_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::PartialMolecule >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        PartialMolecule_exposer.def( "__str__", &__str__< ::SireMol::PartialMolecule > );
        PartialMolecule_exposer.def( "__repr__", &__str__< ::SireMol::PartialMolecule > );
    }

}