rolled in reivew comments

Author: scmacdon

python/example_code/neptune/analytics/create_neptune_graph_example.py

@@ -3,7 +3,7 @@
 
 import boto3
 from botocore.exceptions import ClientError, BotoCoreError
-
+from botocore.config import Config
 # snippet-start:[neptune.python.graph.create.main]
 """
 Running this example.
@@ -26,31 +26,21 @@ def main():
     """
     Main entry point: create NeptuneGraph client and call graph creation.
     """
-    # Hypothetical client - boto3 currently doesn't have NeptuneGraph client, so replace with actual client if available
-    neptune_graph_client = boto3.client("neptune")
-
-    execute_create_graph(neptune_graph_client, GRAPH_NAME)
+    config = Config(retries={"total_max_attempts": 1, "mode": "standard"}, read_timeout=None)
+    client = boto3.client("neptune-graph", config=config)
+    execute_create_graph(client, GRAPH_NAME)
 
 
 def execute_create_graph(client, graph_name):
-    """
-    Creates a new Neptune graph.
-
-    :param client: Boto3 Neptune graph client (hypothetical)
-    :param graph_name: Name of the graph to create
-    """
     try:
         print("Creating Neptune graph...")
-
-        # Hypothetical method for create_graph, adjust accordingly if you use HTTP API or SDK extensions
         response = client.create_graph(
-            GraphName=graph_name,
-            ProvisionedMemory=16  # Example parameter, adjust if API differs
+            GraphName=graph_name
         )
 
-        created_graph_name = response.get("Name")
-        graph_arn = response.get("Arn")
-        graph_endpoint = response.get("Endpoint")
+        created_graph_name = response.get("GraphName")
+        graph_arn = response.get("GraphArn")
+        graph_endpoint = response.get("GraphEndpoint")
 
         print("Graph created successfully!")
         print(f"Graph Name: {created_graph_name}")
@@ -65,6 +55,7 @@ def execute_create_graph(client, graph_name):
         print(f"Unexpected error: {str(e)}")
 
 
+
 if __name__ == "__main__":
     main()
 # snippet-end:[neptune.python.graph.create.main]

python/example_code/neptune/analytics/neptune_analytics_query_example.py

@@ -3,7 +3,7 @@
 
 import boto3
 from botocore.exceptions import ClientError
-
+from botocore.config import Config
 # snippet-start:[neptune.python.graph.execute.main]
 """
 Running this example.
@@ -20,49 +20,85 @@
 
 """
 
-NEPTUNE_ANALYTICS_ENDPOINT = "https://<your-neptune-analytics-endpoint>:8182"
 GRAPH_ID = "<your-graph-id>"
 
 def main():
-    # Build the boto3 client for neptune-graph with endpoint override
-    client = boto3.client(
-        "neptune-graph",
-        endpoint_url=NEPTUNE_ANALYTICS_ENDPOINT
-    )
+    config = Config(retries={"total_max_attempts": 1, "mode": "standard"}, read_timeout=None)
+    client = boto3.client("neptune-graph", config=config)
 
     try:
-        execute_gremlin_profile_query(client, GRAPH_ID)
+        print("\n--- Running OpenCypher query without parameters ---")
+        run_open_cypher_query(client, GRAPH_ID)
+
+        print("\n--- Running OpenCypher query with parameters ---")
+        run_open_cypher_query_with_params(client, GRAPH_ID)
+
+        print("\n--- Running OpenCypher explain query ---")
+        run_open_cypher_explain_query(client, GRAPH_ID)
+
     except Exception as e:
         print(f"Unexpected error in main: {e}")
 
-def execute_gremlin_profile_query(client, graph_id):
+def run_open_cypher_query(client, graph_id):
     """
-    Executes a Gremlin or OpenCypher query on Neptune Analytics graph.
-
-    Args:
-        client (boto3.client): The NeptuneGraph client.
-        graph_id (str): The graph identifier.
+    Run an OpenCypher query without parameters.
     """
-    print("Running openCypher query on Neptune Analytics...")
-
     try:
-        response = client.execute_query(
+        resp = client.execute_query(
             GraphIdentifier=graph_id,
             QueryString="MATCH (n {code: 'ANC'}) RETURN n",
             Language="OPEN_CYPHER"
         )
+        if 'Payload' in resp:
+            result = resp['Payload'].read().decode('utf-8')
+            print(result)
+        else:
+            print("No query result returned.")
+    except ClientError as e:
+        print(f"NeptuneGraph ClientError: {e.response['Error']['Message']}")
+    except Exception as e:
+        print(f"Unexpected error: {e}")
 
-        # The response 'Payload' may contain the query results as a streaming bytes object
-        # Convert to string and print
-        if 'Payload' in response:
-            result = response['Payload'].read().decode('utf-8')
-            print("Query Result:")
+def run_open_cypher_query_with_params(client, graph_id):
+    """
+    Run an OpenCypher query with parameters.
+    """
+    try:
+        parameters = {'code': 'ANC'}
+        resp = client.execute_query(
+            GraphIdentifier=graph_id,
+            QueryString="MATCH (n {code: $code}) RETURN n",
+            Language="OPEN_CYPHER",
+            Parameters=parameters
+        )
+        if 'Payload' in resp:
+            result = resp['Payload'].read().decode('utf-8')
             print(result)
         else:
             print("No query result returned.")
+    except ClientError as e:
+        print(f"NeptuneGraph ClientError: {e.response['Error']['Message']}")
+    except Exception as e:
+        print(f"Unexpected error: {e}")
 
+def run_open_cypher_explain_query(client, graph_id):
+    """
+    Run an OpenCypher explain query (explainMode = "debug").
+    """
+    try:
+        resp = client.execute_query(
+            GraphIdentifier=graph_id,
+            QueryString="MATCH (n {code: 'ANC'}) RETURN n",
+            Language="OPEN_CYPHER",
+            ExplainMode="debug"
+        )
+        if 'Payload' in resp:
+            result = resp['Payload'].read().decode('utf-8')
+            print(result)
+        else:
+            print("No query result returned.")
     except ClientError as e:
-        print(f"NeptuneGraph error: {e.response['Error']['Message']}")
+        print(f"NeptuneGraph ClientError: {e.response['Error']['Message']}")
     except Exception as e:
         print(f"Unexpected error: {e}")
 

python/example_code/neptune/database/neptune_gremlin_query_example.py renamed to python/example_code/neptune/database/neptune_execute_gremlin_explain_query.py

@@ -40,25 +40,17 @@ def main():
 def execute_gremlin_query(neptune_client):
     """
     Executes a Gremlin query against an Amazon Neptune database.
-
-    :param neptune_client: Boto3 Neptunedata client
     """
     try:
         print("Querying Neptune...")
 
-        response = neptune_client.execute_gremlin_query(
+        response = neptune_client.execute_gremlin_explain_query(
             gremlinQuery="g.V().has('code', 'ANC')"
         )
 
         print("Full Response:")
-        print(response)
+        print(response['output'].read().decode('UTF-8'))
 
-        result = response.get("result")
-        if result:
-            print("Query Result:")
-            print(result)
-        else:
-            print("No result returned from the query.")
     except ClientError as e:
         print(f"Error calling Neptune: {e.response['Error']['Message']}")
     except BotoCoreError as e:

python/example_code/neptune/database/neptune_gremlin_explain_and_profile_example.py renamed to python/example_code/neptune/database/neptune_execute_gremlin_profile_query.py

@@ -74,7 +74,7 @@ def run_profile_query(neptune_client):
             gremlinQuery="g.V().has('code', 'ANC')"
         )
         print("Profile Query Result:")
-        print(response.get("output", "No profile output returned."))
+        print(response['output'].read().decode('UTF-8'))
     except Exception as e:
         print(f"Failed to execute PROFILE query: {str(e)}")
 

python/example_code/neptune/database/gremlin_profile_query_example.py renamed to python/example_code/neptune/database/neptune_execute_gremlin_query.py

@@ -21,28 +21,22 @@
   - A connected environment such as a **VPN**, **AWS Direct Connect**, or a **peered VPC**
 
 """
-
-
 # Customize this with your Neptune endpoint
 NEPTUNE_ENDPOINT = "https://<your-neptune-endpoint>:8182"
 
 def execute_gremlin_profile_query(client):
     """
-    Executes a Gremlin PROFILE query using the provided Neptune client.
+    Executes a Gremlin query using the provided Neptune Data client.
     """
     print("Executing Gremlin PROFILE query...")
 
     try:
-        response = client.execute_gremlin_profile_query(
-            gremlinQuery="g.V().has('code', 'ANC')"
+        response = client.execute_gremlin_query(
+            gremlinQueyr="g.V().has('code', 'ANC')"
         )
-        output = response.get("output")
 
-        if output:
-            print("Query Profile Output:")
-            print(json.dumps(output, indent=2))
-        else:
-            print("No output returned from the profile query.")
+        print("Response is:")
+        print(response['result'])
 
     except ClientError as e:
         print(f"Neptune error: {e.response['Error']['Message']}")

python/example_code/neptune/database/open_cypher_explain_example.py renamed to python/example_code/neptune/database/neptune_execute_open_cypher_query.py

@@ -2,6 +2,7 @@
 # SPDX-License-Identifier: Apache-2.0
 
 import boto3
+import json
 from botocore.config import Config
 from botocore.exceptions import ClientError, BotoCoreError
 
@@ -20,12 +21,13 @@
 
 """
 # snippet-start:[neptune.python.data.query.opencypher.main]
+
 # Replace with your actual Neptune endpoint URL
 NEPTUNE_ENDPOINT = "https://<your-neptune-endpoint>:8182"
 
 def main():
     """
-    Entry point: Create Neptune client and execute the OpenCypher EXPLAIN query.
+    Entry point: Create Neptune client and execute different OpenCypher queries.
     """
     config = Config(connect_timeout=10, read_timeout=30, retries={'max_attempts': 3})
 
@@ -35,34 +37,63 @@ def main():
         config=config
     )
 
-    execute_opencypher_explain_query(neptune_client)
-
+    execute_open_cypher_query_without_params(neptune_client)
+    execute_open_cypher_query_with_params(neptune_client)
+    execute_open_cypher_explain_query(neptune_client)
 
-def execute_opencypher_explain_query(neptune_client):
+def execute_open_cypher_query_without_params(client):
+    """
+    Executes a simple OpenCypher query without parameters.
     """
-    Executes an OpenCypher EXPLAIN query on Amazon Neptune.
+    try:
+        print("\nRunning OpenCypher query without parameters...")
+        resp = client.execute_open_cypher_query(
+            openCypherQuery="MATCH (n {code: 'ANC'}) RETURN n"
+        )
+        print("Results:")
+        print(resp['results'])
 
-    :param neptune_client: Boto3 Neptunedata client
+    except Exception as e:
+        print(f"Error in simple OpenCypher query: {str(e)}")
+
+
+def execute_open_cypher_query_with_params(client):
+    """
+    Executes an OpenCypher query using parameters.
     """
     try:
-        print("Executing OpenCypher EXPLAIN query...")
+        print("\nRunning OpenCypher query with parameters...")
+        parameters = {'code': 'ANC'}
+        resp = client.execute_open_cypher_query(
+            openCypherQuery="MATCH (n {code: $code}) RETURN n",
+            parameters=json.dumps(parameters)
+        )
+        print("Results:")
+        print(resp['results'])
+
+    except Exception as e:
+        print(f"Error in parameterized OpenCypher query: {str(e)}")
 
-        response = neptune_client.execute_open_cypher_explain_query(
+def execute_open_cypher_explain_query(client):
+    """
+    Runs an OpenCypher EXPLAIN query in debug mode.
+    """
+    try:
+        print("\nRunning OpenCypher EXPLAIN query (debug mode)...")
+        resp = client.execute_open_cypher_explain_query(
             openCypherQuery="MATCH (n {code: 'ANC'}) RETURN n",
             explainMode="debug"
         )
-
-        results = response.get("results")
-        if results:
-            # `results` might be bytes or string, decode if necessary
-            if isinstance(results, bytes):
-                print("Explain Results:")
-                print(results.decode("utf-8"))
-            else:
-                print("Explain Results:")
-                print(results)
-        else:
+        results = resp.get('results')
+        if results is None:
             print("No explain results returned.")
+        else:
+            try:
+                print("Explain Results:")
+                print(results.read().decode('UTF-8'))
+            except Exception as e:
+                print(f"Error in OpenCypher EXPLAIN query: {str(e)}")
+
     except ClientError as e:
         print(f"Neptune error: {e.response['Error']['Message']}")
     except BotoCoreError as e: