Prototype delete of object from Python

GrpcInterface/GrpcProtos/PdmObject.proto

@@ -14,6 +14,7 @@ service PdmObjectService
 	rpc CallPdmObjectGetter(PdmObjectGetterRequest) returns (stream PdmObjectGetterReply) {}
 	rpc CallPdmObjectSetter(stream PdmObjectSetterChunk) returns (ClientToServerStreamReply) {}
 	rpc CallPdmObjectMethod(PdmObjectMethodRequest) returns (PdmObject) {}
+	rpc DeleteExistingPdmObject(PdmObject) returns (Empty) {}
 }
 
 message PdmDescendantObjectRequest

GrpcInterface/Python/rips/pdmobject.py

@@ -511,3 +511,13 @@ def update(self) -> None:
             raise Exception(
                 "Object is not connected to GRPC service so cannot update ResInsight"
             )
+
+    def delete(self) -> None:
+        """Delete object in ResInsight"""
+        self.__copy_to_pb2()
+        if self._pdm_object_stub is not None:
+            self._pdm_object_stub.DeleteExistingPdmObject(self._pb2_object)
+        else:
+            raise Exception(
+                "Object is not connected to GRPC service so cannot update ResInsight"
+            )

GrpcInterface/Python/rips/tests/test_object_lifetime.py

@@ -0,0 +1,27 @@
+import sys
+import os
+
+sys.path.insert(1, os.path.join(sys.path[0], "../../"))
+import rips
+
+
+def test_well_path(rips_instance, initialize_test):
+    well_path_coll = rips_instance.project.descendants(rips.WellPathCollection)[0]
+    assert len(well_path_coll.well_paths()) is 0
+
+    well_path = well_path_coll.add_new_object(rips.ModeledWellPath)
+    well_path2 = well_path_coll.add_new_object(rips.ModeledWellPath)
+    assert len(well_path_coll.well_paths()) is 2
+
+    well_path.delete()
+    assert len(well_path_coll.well_paths()) is 1
+
+    try:
+        # Delete again should throw exception
+        well_path.delete()
+        assert False
+    except Exception:
+        assert True
+
+    well_path2.delete()
+    assert len(well_path_coll.well_paths()) is 0

GrpcInterface/RiaGrpcCallbacks.h

@@ -33,8 +33,6 @@ using grpc::ServerCompletionQueue;
 using grpc::ServerContext;
 using grpc::Status;
 
-class RiaGrpcServiceInterface;
-
 //==================================================================================================
 //
 // Base class for all gRPC-callbacks

GrpcInterface/RiaGrpcCaseService.cpp

@@ -54,7 +54,7 @@ grpc::Status RiaActiveCellInfoStateHandler::init( const rips::CellInfoRequest* r
     m_request = request;
 
     m_porosityModel  = RiaDefines::PorosityModelType( m_request->porosity_model() );
-    RimCase* rimCase = RiaGrpcServiceInterface::findCase( m_request->case_request().id() );
+    RimCase* rimCase = RiaGrpcHelper::findCase( m_request->case_request().id() );
     m_eclipseCase    = dynamic_cast<RimEclipseCase*>( rimCase );
 
     if ( !m_eclipseCase )
@@ -191,7 +191,7 @@ const std::vector<RigCell>& RiaActiveCellInfoStateHandler::reservoirCells() cons
 //--------------------------------------------------------------------------------------------------
 grpc::Status RiaActiveCellInfoStateHandler::assignReply( rips::CellInfoArray* reply )
 {
-    const size_t packageSize    = RiaGrpcServiceInterface::numberOfDataUnitsInPackage( sizeof( rips::CellInfo ) );
+    const size_t packageSize    = RiaGrpcHelper::numberOfDataUnitsInPackage( sizeof( rips::CellInfo ) );
     size_t       indexInPackage = 0u;
     reply->mutable_data()->Reserve( (int)packageSize );
 
@@ -259,7 +259,7 @@ void RiaActiveCellInfoStateHandler::assignCellCenter( rips::Vec3d*
 //--------------------------------------------------------------------------------------------------
 grpc::Status RiaActiveCellInfoStateHandler::assignCellCentersReply( rips::CellCenters* reply )
 {
-    const size_t packageSize    = RiaGrpcServiceInterface::numberOfDataUnitsInPackage( sizeof( rips::Vec3d ) );
+    const size_t packageSize    = RiaGrpcHelper::numberOfDataUnitsInPackage( sizeof( rips::Vec3d ) );
     size_t       indexInPackage = 0u;
     reply->mutable_centers()->Reserve( (int)packageSize );
     for ( ; indexInPackage < packageSize && m_currentCellIdx < m_activeCellInfo->reservoirCellCount(); ++indexInPackage )
@@ -332,7 +332,7 @@ void RiaActiveCellInfoStateHandler::assignCellCorners( rips::CellCorners*
 //--------------------------------------------------------------------------------------------------
 Status RiaActiveCellInfoStateHandler::assignCellCornersReply( rips::CellCornersArray* reply )
 {
-    const size_t packageSize    = RiaGrpcServiceInterface::numberOfDataUnitsInPackage( sizeof( rips::CellCorners ) );
+    const size_t packageSize    = RiaGrpcHelper::numberOfDataUnitsInPackage( sizeof( rips::CellCorners ) );
     size_t       indexInPackage = 0u;
     reply->mutable_cells()->Reserve( (int)packageSize );
     for ( ; indexInPackage < packageSize && m_currentCellIdx < m_activeCellInfo->reservoirCellCount(); ++indexInPackage )
@@ -363,7 +363,7 @@ grpc::Status RiaGrpcCaseService::GetGridCount( grpc::ServerContext*     context,
                                                const rips::CaseRequest* request,
                                                rips::GridCount*         reply )
 {
-    RimCase* rimCase = findCase( request->id() );
+    RimCase* rimCase = RiaGrpcHelper::findCase( request->id() );
 
     RimEclipseCase* eclipseCase = dynamic_cast<RimEclipseCase*>( rimCase );
     if ( eclipseCase )
@@ -382,7 +382,7 @@ grpc::Status RiaGrpcCaseService::GetCellCount( grpc::ServerContext*         cont
                                                const rips::CellInfoRequest* request,
                                                rips::CellCount*             reply )
 {
-    RimCase* rimCase = findCase( request->case_request().id() );
+    RimCase* rimCase = RiaGrpcHelper::findCase( request->case_request().id() );
 
     RimEclipseCase* eclipseCase = dynamic_cast<RimEclipseCase*>( rimCase );
     if ( eclipseCase )
@@ -403,7 +403,7 @@ grpc::Status RiaGrpcCaseService::GetTimeSteps( grpc::ServerContext*     context,
                                                const rips::CaseRequest* request,
                                                rips::TimeStepDates*     reply )
 {
-    RimCase* rimCase = findCase( request->id() );
+    RimCase* rimCase = RiaGrpcHelper::findCase( request->id() );
 
     if ( rimCase )
     {
@@ -430,7 +430,7 @@ grpc::Status RiaGrpcCaseService::GetDaysSinceStart( grpc::ServerContext*     con
                                                     const rips::CaseRequest* request,
                                                     rips::DaysSinceStart*    reply )
 {
-    RimCase* rimCase = findCase( request->id() );
+    RimCase* rimCase = RiaGrpcHelper::findCase( request->id() );
 
     RimEclipseCase* eclipseCase = dynamic_cast<RimEclipseCase*>( rimCase );
     if ( eclipseCase )
@@ -466,7 +466,7 @@ grpc::Status RiaGrpcCaseService::GetDaysSinceStart( grpc::ServerContext*     con
 grpc::Status
     RiaGrpcCaseService::GetCaseInfo( grpc::ServerContext* context, const rips::CaseRequest* request, rips::CaseInfo* reply )
 {
-    RimCase* rimCase = findCase( request->id() );
+    RimCase* rimCase = RiaGrpcHelper::findCase( request->id() );
     if ( rimCase )
     {
         qint64  caseId      = rimCase->caseId();
@@ -490,7 +490,7 @@ grpc::Status RiaGrpcCaseService::GetPdmObject( grpc::ServerContext*     context,
                                                const rips::CaseRequest* request,
                                                rips::PdmObject*         reply )
 {
-    RimCase* rimCase = findCase( request->id() );
+    RimCase* rimCase = RiaGrpcHelper::findCase( request->id() );
     if ( rimCase )
     {
         copyPdmObjectFromCafToRips( rimCase, reply );
@@ -549,7 +549,7 @@ Status RiaSelectedCellsStateHandler::init( const rips::CaseRequest* request )
     CAF_ASSERT( request );
     m_request = request;
 
-    RimCase* rimCase = RiaGrpcServiceInterface::findCase( m_request->id() );
+    RimCase* rimCase = RiaGrpcHelper::findCase( m_request->id() );
     m_eclipseCase    = dynamic_cast<RimEclipseCase*>( rimCase );
 
     if ( !m_eclipseCase )
@@ -624,7 +624,7 @@ grpc::Status RiaSelectedCellsStateHandler::assignReply( rips::SelectedCells* rep
         }
     }
 
-    const size_t packageSize    = RiaGrpcServiceInterface::numberOfDataUnitsInPackage( sizeof( rips::SelectedCell ) );
+    const size_t packageSize    = RiaGrpcHelper::numberOfDataUnitsInPackage( sizeof( rips::SelectedCell ) );
     size_t       indexInPackage = 0u;
     reply->mutable_cells()->Reserve( (int)packageSize );
     for ( ; indexInPackage < packageSize && m_currentItem < eclipseItems.size(); ++indexInPackage )
@@ -667,7 +667,7 @@ grpc::Status RiaGrpcCaseService::GetReservoirBoundingBox( grpc::ServerContext*
                                                           const rips::CaseRequest* request,
                                                           rips::BoundingBox*       reply )
 {
-    RimCase* rimCase = findCase( request->id() );
+    RimCase* rimCase = RiaGrpcHelper::findCase( request->id() );
     if ( rimCase )
     {
         cvf::BoundingBox boundingBox = rimCase->reservoirBoundingBox();
@@ -689,7 +689,7 @@ grpc::Status RiaGrpcCaseService::GetCoarseningInfoArray( grpc::ServerContext*
                                                          const rips::CaseRequest*   request,
                                                          rips::CoarseningInfoArray* reply )
 {
-    RimEclipseCase* rimCase = dynamic_cast<RimEclipseCase*>( findCase( request->id() ) );
+    RimEclipseCase* rimCase = dynamic_cast<RimEclipseCase*>( RiaGrpcHelper::findCase( request->id() ) );
     if ( rimCase && rimCase->eclipseCaseData() && rimCase->eclipseCaseData()->mainGrid() )
     {
         for ( size_t gridIdx = 0; gridIdx < rimCase->eclipseCaseData()->gridCount(); gridIdx++ )

GrpcInterface/RiaGrpcGridService.cpp

@@ -47,7 +47,7 @@ grpc::Status RiaCellCenterStateHandler::init( const rips::GridRequest* request )
     CAF_ASSERT( request );
     m_request = request;
 
-    RimCase* rimCase = RiaGrpcServiceInterface::findCase( m_request->case_request().id() );
+    RimCase* rimCase = RiaGrpcHelper::findCase( m_request->case_request().id() );
     m_eclipseCase    = dynamic_cast<RimEclipseCase*>( rimCase );
 
     if ( !m_eclipseCase )
@@ -71,7 +71,7 @@ grpc::Status RiaCellCenterStateHandler::init( const rips::GridRequest* request )
 //--------------------------------------------------------------------------------------------------
 grpc::Status RiaCellCenterStateHandler::assignReply( rips::CellCenters* reply )
 {
-    const size_t packageSize    = RiaGrpcServiceInterface::numberOfDataUnitsInPackage( sizeof( rips::Vec3d ) );
+    const size_t packageSize    = RiaGrpcHelper::numberOfDataUnitsInPackage( sizeof( rips::Vec3d ) );
     size_t       indexInPackage = 0u;
     reply->mutable_centers()->Reserve( (int)packageSize );
     for ( ; indexInPackage < packageSize && m_currentCellIdx < m_grid->cellCount(); ++indexInPackage )
@@ -98,7 +98,7 @@ grpc::Status RiaCellCenterStateHandler::assignReply( rips::CellCenters* reply )
 //--------------------------------------------------------------------------------------------------
 grpc::Status RiaCellCenterStateHandler::assignCornersReply( rips::CellCornersArray* reply )
 {
-    const size_t packageSize    = RiaGrpcServiceInterface::numberOfDataUnitsInPackage( sizeof( rips::CellCorners ) );
+    const size_t packageSize    = RiaGrpcHelper::numberOfDataUnitsInPackage( sizeof( rips::CellCorners ) );
     size_t       indexInPackage = 0u;
     reply->mutable_cells()->Reserve( (int)packageSize );
 
@@ -137,7 +137,7 @@ grpc::Status RiaGrpcGridService::GetDimensions( grpc::ServerContext*     context
                                                 const rips::GridRequest* request,
                                                 rips::GridDimensions*    reply )
 {
-    RimCase* rimCase = findCase( request->case_request().id() );
+    RimCase* rimCase = RiaGrpcHelper::findCase( request->case_request().id() );
 
     RimEclipseCase* eclipseCase = dynamic_cast<RimEclipseCase*>( rimCase );
     if ( eclipseCase )

GrpcInterface/RiaGrpcHelper.cpp

@@ -15,8 +15,18 @@
 //  for more details.
 //
 //////////////////////////////////////////////////////////////////////////////////
+
 #include "RiaGrpcHelper.h"
 
+#include "RiaApplication.h"
+#include "RimCase.h"
+#include "RimCommandRouter.h"
+#include "RimProject.h"
+
+#include "PdmObject.pb.h"
+
+#include "cafPdmObjectScriptingCapabilityRegister.h"
+
 //--------------------------------------------------------------------------------------------------
 /// Convert internal ResInsight representation of cells with negative depth to positive depth.
 //--------------------------------------------------------------------------------------------------
@@ -35,3 +45,63 @@ void RiaGrpcHelper::setCornerValues( rips::Vec3d* out, const cvf::Vec3d& in )
     out->set_y( in.y() );
     out->set_z( in.z() );
 }
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+caf::PdmObject* RiaGrpcHelper::findCafObjectFromRipsObject( const rips::PdmObject& ripsObject )
+{
+    QString  scriptClassName = QString::fromStdString( ripsObject.class_keyword() );
+    uint64_t address         = ripsObject.address();
+    return findCafObjectFromScriptNameAndAddress( scriptClassName, address );
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+caf::PdmObject* RiaGrpcHelper::findCafObjectFromScriptNameAndAddress( const QString& scriptClassName, uint64_t address )
+{
+    QString classKeyword = caf::PdmObjectScriptingCapabilityRegister::classKeywordFromScriptClassName( scriptClassName );
+
+    if ( classKeyword == RimCommandRouter::classKeywordStatic() ) return RiaApplication::instance()->commandRouter();
+
+    RimProject*                  project = RimProject::current();
+    std::vector<caf::PdmObject*> objectsOfCurrentClass;
+
+    project->descendantsIncludingThisFromClassKeyword( classKeyword, objectsOfCurrentClass );
+
+    caf::PdmObject* matchingObject = nullptr;
+    for ( caf::PdmObject* testObject : objectsOfCurrentClass )
+    {
+        if ( reinterpret_cast<uint64_t>( testObject ) == address )
+        {
+            matchingObject = testObject;
+        }
+    }
+    return matchingObject;
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+size_t RiaGrpcHelper::numberOfDataUnitsInPackage( size_t dataUnitSize, size_t packageByteCount /*= 64 * 1024u */ )
+{
+    size_t dataUnitCount = packageByteCount / dataUnitSize;
+    return dataUnitCount;
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+RimCase* RiaGrpcHelper::findCase( int caseId )
+{
+    std::vector<RimCase*> cases = RimProject::current()->allGridCases();
+    for ( RimCase* rimCase : cases )
+    {
+        if ( caseId == rimCase->caseId() )
+        {
+            return rimCase;
+        }
+    }
+    return nullptr;
+}

GrpcInterface/RiaGrpcHelper.h

@@ -21,6 +21,20 @@
 
 #include "cvfVector3.h"
 
+#include <QString>
+
+class RimCase;
+
+namespace caf
+{
+class PdmObject;
+}
+
+namespace rips
+{
+class PdmObject;
+}
+
 //==================================================================================================
 //
 // Various gRPC helper methods
@@ -31,4 +45,10 @@ class RiaGrpcHelper
 public:
     static void convertVec3dToPositiveDepth( cvf::Vec3d* vec );
     static void setCornerValues( rips::Vec3d* out, const cvf::Vec3d& in );
+
+    static caf::PdmObject* findCafObjectFromRipsObject( const rips::PdmObject& ripsObject );
+    static caf::PdmObject* findCafObjectFromScriptNameAndAddress( const QString& scriptClassName, uint64_t address );
+
+    static size_t   numberOfDataUnitsInPackage( size_t dataUnitSize, size_t packageByteCount = 64 * 1024u );
+    static RimCase* findCase( int caseId );
 };