rename object to entry where applicable

src/datacat_integration/connection.py

@@ -18,7 +18,7 @@ class DataCatalogEntry:
         self.metadata = metadata
 
     def json(self):
-        """returns a json-compatible representation of the object."""
+        """returns a json-compatible representation of the entry."""
         return json.dumps(
             {
             "name" : self.name,
@@ -28,7 +28,7 @@ class DataCatalogEntry:
         )
 
     def from_json(data: json):
-        """returns a DataCatalogEntry object from the given json string"""
+        """returns a DataCatalogEntry entry from the given json string"""
         dict_data = json.loads(data)
         return DataCatalogEntry(dict_data['name'], dict_data['url'], dict_data['metadata'])
 
@@ -76,22 +76,22 @@ class DataCatConnection:
             return self.refresh_token()
         
 
-    def get_object(self, datacat_type: str, oid: uuid.UUID): # GET /<type>/<oid>
-        """Returns a json of the given object from the server."""
+    def get_entry(self, datacat_type: str, oid: uuid.UUID): # GET /<type>/<oid>
+        """Returns a json of the given entry from the server."""
         headers = {
             'accept' : 'application/json'
         }
         url = urljoin(self.url, "{}/{}".format(datacat_type, oid))
         return json.dumps(requests.get(url, headers=headers).json())
 
-    def create_object(self, datacat_type: str, object: DataCatalogEntry): # POST /<type>
-        """Creates a new object in the datacatalog. Returns the oid of successful."""
+    def create_entry(self, datacat_type: str, entry: DataCatalogEntry): # POST /<type>
+        """Creates a new entry in the datacatalog. Returns the oid of successful."""
         headers = {
             'accept' : 'application/json',
             'Content-Type' : 'application/json',
             'Authorization' : 'Bearer {}'.format(self._auth_token)
         }
-        response = requests.post(urljoin(self.url, datacat_type), headers=headers, data=object.json())
+        response = requests.post(urljoin(self.url, datacat_type), headers=headers, data=entry.json())
         if response.ok:
             return response.json()[0]
         else:

src/datacat_integration/hooks.py

@@ -13,7 +13,7 @@ from datacat_integration.auth import BearerAuth
 
 
 def get_connection_from_entry(data: Dict[str, Any], datacat_type: str, oid: str) -> Connection:
-    """returns an aiflow connection from the data provided in the datacat entry."""
+    """returns an airflow connection from the data provided in the datacat entry."""
     conn_type = data['metadata']['conn_type']
     host = data['metadata']['host']
     port = data['metadata']['port']
@@ -51,19 +51,18 @@ class DataCatalogHook(HttpHook):
         conn.auth = BearerAuth(self.connection.get_token())
         return conn
 
-    def get_object(self, datacat_type: str, oid: str):
-        return self.connection.get_object(datacat_type, oid)
+    def get_entry(self, datacat_type: str, oid: str):
+        return self.connection.get_entry(datacat_type, oid)
 
-    def create_object(self, datacat_type: str, object: DataCatalogEntry):
-        return self.connection.create_object(datacat_type, object)
+    def create_entry(self, datacat_type: str, entry: DataCatalogEntry):
+        return self.connection.create_entry(datacat_type, entry)
 
     def list_type(self, datacat_type: str):
         return self.connection.list_type(datacat_type)
 
-    def create_get_object_connection(self, datacat_type: str, oid: str):
-        object = self.get_object(datacat_type=datacat_type, oid=oid)
-        # TODO decide some factors, such as connection type
-        conn = get_connection_from_entry(object, datacat_type, oid)
+    def create_get_entry_connection(self, datacat_type: str, oid: str):
+        entry = self.get_entry(datacat_type, oid)
+        conn = get_connection_from_entry(entry, datacat_type, oid)
         
         session = settings.Session()
 

src/datacat_integration/operators.py

@@ -15,7 +15,7 @@ class GetDatacatalogEntryOperator(BaseOperator):
 
     def execute(self, context):
         cat_conn = DataCatalogHook('datacatalog')
-        return cat_conn.get_object(self.datacat_type, self.oid)
+        return cat_conn.get_entry(self.datacat_type, self.oid)
 
 class GetDatacatalogEntryConnectionOperator(BaseOperator):
     """This task returns the data for an entry in the datacatalog."""
@@ -31,4 +31,4 @@ class GetDatacatalogEntryConnectionOperator(BaseOperator):
 
     def execute(self, context):
         hook = DataCatalogHook("datacatalog")
-        hook.create_get_object_connection(self.datacat_type, self.oid)
+        hook.create_get_entry_connection(self.datacat_type, self.oid)
\ No newline at end of file

src/datacat_integration/secrets.py

@@ -77,20 +77,19 @@ class DatacatSecretsBackend(BaseSecretsBackend):
 
     def __init__(self, **kwargs):
         log.debug("Init of Datacat Secrets Backend")
-        super().__init__(**kwargs)
         self.url = kwargs["url"]
         self.user = kwargs["user"]
         self.password = kwargs["password"]
 
     def get_connection(self, conn_id: str):
-        """returns a Connection object created from the <conenction_type>/<conn_id> object in the datacatalog"""
+        """returns a Connection created from the <conenction_type>/<conn_id> entry in the datacatalog"""
         # only for testing: check that a specific oid has been requested
         log.debug(f"Get connection: {conn_id}")
         if conn_id != "860355e9-975f-4253-9421-1815e20c879b":
             return None
 
         secrets_conn = DataCatConnectionWithSecrets(self.url, self.user, self.password)
-        data = secrets_conn.get_object(connection_backend_type, conn_id)
+        data = secrets_conn.get_entry(connection_backend_type, conn_id)
         secrets = secrets_conn.get_all_secret_key_value(connection_backend_type, conn_id)
         conn = get_connection_from_entry(data, secrets, connection_backend_type, conn_id)
         return conn
\ No newline at end of file

tests/test_connection.py

@@ -45,10 +45,10 @@ class ConnectionTest(TestCase):
         self.assertEqual(token, token2)
 
     
-    # may fail in future when the testing instance is moved or redeployed - test may need to be updated in that case, since the tested object may no longer exist
+    # may fail in future when the testing instance is moved or redeployed - test may need to be updated in that case, since the tested entry may no longer exist
     def test_get_entry(self):
         connection = DataCatConnection(self.url, self.user, self.password)
-        entry_json = connection.get_object("storage_target", "7aa3877e-2860-4c65-8d48-3e080ceedca2")
+        entry_json = connection.get_entry("storage_target", "7aa3877e-2860-4c65-8d48-3e080ceedca2")
         entry = DataCatalogEntry.from_json(entry_json)
         self.assertEqual(entry.name, "Yet Another Test Object")
         self.assertEqual(entry.url, "1234")
@@ -58,13 +58,13 @@ class ConnectionTest(TestCase):
     def test_create_entry(self):
         connection = DataCatConnection(self.url, self.user, self.password)
         entry = DataCatalogEntry("foo", "bar", {"1" : "2", "source" : "automated tests", "random" : str(random.getrandbits(32))})
-        oid = connection.create_object("storage_target", entry)
-        entry_from_server = DataCatalogEntry.from_json(connection.get_object("storage_target", oid))
+        oid = connection.create_entry("storage_target", entry)
+        entry_from_server = DataCatalogEntry.from_json(connection.get_entry("storage_target", oid))
         self.assertDictEqual(entry.metadata, entry_from_server.metadata)
         self.assertEqual(entry.name, entry_from_server.name)
         self.assertEqual(entry.url, entry_from_server.url)
 
-    # may fail in future when the testing instance is moved or redeployed - test may need to be updated in that case, since the tested objects may no longer exist
+    # may fail in future when the testing instance is moved or redeployed - test may need to be updated in that case, since the tested entries may no longer exist
     def test_list_entries(self):
         connection = DataCatConnection(self.url, self.user, self.password)
         entries = connection.list_type("storage_target")
@@ -79,4 +79,4 @@ class ConnectionTest(TestCase):
         self.assertRaises(ConnectionError, connection.refresh_token)
         connection._auth_token = "foobar"
         self.assertRaises(ConnectionError, connection.get_token)
-        self.assertRaises(ConnectionError, connection.create_object, "storage_target", DataCatalogEntry("foo", "bar", {}))
+        self.assertRaises(ConnectionError, connection.create_entry, "storage_target", DataCatalogEntry("foo", "bar", {}))
\ No newline at end of file