Gh-380: Update user guide querying section

docs/change-notes/migrating-from-v1-to-v2/deprecations.md

@@ -464,7 +464,7 @@ Now set in `serialiser`:
                     .library(myGraphLibrary)
                     .view(myView)
                     .addHook(customHook)
-                    .build()) 
+                    .build())
             .addSchema(mySchema) // (1)!
             .storeProperties(storeProperties) // (2)!
             .build();

docs/reference/operations-guide/misc.md

@@ -29,7 +29,7 @@ Gets data from an endpoint. [Javadoc](https://gchq.github.io/Gaffer/uk/gov/gchq/
     ```
 
 === "JSON"
-    
+
     ``` json
     {
     "class" : "GetFromEndpoint",
@@ -38,10 +38,10 @@ Gets data from an endpoint. [Javadoc](https://gchq.github.io/Gaffer/uk/gov/gchq/
     ```
 
 === "Python"
-    
+
     ``` python
-    g.GetFromEndpoint( 
-    endpoint="https://mydata.io:8443/mydata" 
+    g.GetFromEndpoint(
+    endpoint="https://mydata.io:8443/mydata"
     )
     ```
 
@@ -68,7 +68,7 @@ This operation requires Store configuration to be set before it can be used. See
     ```
 
 === "JSON"
-    
+
     ``` json
     {
     "class" : "ScoreOperationChain",
@@ -89,34 +89,34 @@ This operation requires Store configuration to be set before it can be used. See
     ```
 
 === "Python"
-    
+
     ``` python
-    g.ScoreOperationChain( 
-    operation_chain=g.OperationChain( 
-        operations=[ 
-        g.GetElements(), 
-        g.NamedOperation( 
-            operation_name="namedOp" 
-        ), 
-        g.Limit( 
-            result_limit=3, 
-            truncate=True 
-        ) 
-        ] 
-    ) 
+    g.ScoreOperationChain(
+    operation_chain=g.OperationChain(
+        operations=[
+        g.GetElements(),
+        g.NamedOperation(
+            operation_name="namedOp"
+        ),
+        g.Limit(
+            result_limit=3,
+            truncate=True
+        )
+        ]
+    )
     )
     ```
 
 Results:
 
 === "Java"
-    
+
     ``` java
     5
     ```
 
 === "JSON"
-    
+
     ``` json
     5
     ```
@@ -140,7 +140,7 @@ Here we have added a NamedOperation to the NamedOperationCache, with a custom sc
     ```
 
 === "JSON"
-    
+
     ``` json
     {
     "class" : "ScoreOperationChain",
@@ -164,38 +164,38 @@ Here we have added a NamedOperation to the NamedOperationCache, with a custom sc
     ```
 
 === "Python"
-    
+
     ``` python
-    g.ScoreOperationChain( 
-    operation_chain=g.OperationChain( 
-        operations=[ 
-        g.NamedOperation( 
-            input=[ 
-            g.EntitySeed( 
-                vertex=1 
-            ) 
-            ], 
-            operation_name="1-hop" 
-        ), 
-        g.Limit( 
-            result_limit=3, 
-            truncate=True 
-        ) 
-        ] 
-    ) 
+    g.ScoreOperationChain(
+    operation_chain=g.OperationChain(
+        operations=[
+        g.NamedOperation(
+            input=[
+            g.EntitySeed(
+                vertex=1
+            )
+            ],
+            operation_name="1-hop"
+        ),
+        g.Limit(
+            result_limit=3,
+            truncate=True
+        )
+        ]
+    )
     )
     ```
 
 Results:
 
 === "Java"
-    
+
     ``` java
     5
     ```
 
 === "JSON"
-    
+
     ``` json
     5
     ```

docs/user-guide/apis/java-api.md

@@ -0,0 +1,59 @@
+# Using the Java API
+
+As Gaffer is written in Java there is native support to allow use of all its
+public classes. Using Gaffer via the Java interface does differ from the rest
+API and `gafferpy` but is fully featured with extensive
+[Javadocs](https://gchq.github.io/Gaffer/overview-summary.html). However, You
+will of course need to be familiar with writing and running Java code in order
+to utilise this form of the API.
+
+## Querying a Graph
+
+Using Java to Query a graph unlike the other APIs requires a reference to a
+`Graph` object that essentially represents a graph.
+
+With the other APIs you would connect directly to a running instance via the
+rest interface; however, to do this with Java you would need to configure a
+`Graph` object with a proxy store.
+
+!!! example ""
+    The following example uses the `ProxyStore.Builder()` to configure a `Graph`
+    to connect to the required address (in this case
+    `http://localhost:8080/rest/latest`).
+
+    ```java
+    Graph graph = new Graph.Builder()
+        .store(new ProxyStore.Builder()
+                .graphId(uniqueNameOfYourGraph)
+                .host("localhost")
+                .port(8080)
+                .contextRoot("rest/latest")
+                .build())
+        .build();
+    ```
+
+Once the connection to a graph is made you can run queries and operations on
+it using the available classes and builders.
+
+!!! example ""
+    The following operation chain gets all the elements in the graph then will
+    count them and store the result in a `Long`.
+
+    ```java
+    OperationChain<Long> countAllElements = new OperationChain.Builder()
+        .first(new GetAllElements())
+        .then(new Count<>())
+        .build();
+
+    Long result = graph.execute(countAllElements, user);
+    ```
+
+If you're interested in learning more about the `Graph` class please see the
+[developers guide](../../development-guide/project-structure/components/graph.md)
+on the subject.
+
+!!! note
+    One other thing to note about the Java API is that the `execute()` method
+    requires you to have a `User`. This is part of the available fine grain
+    security Gaffer provides see the [admin guide](../../administration-guide/security/security-guide.md)
+    for more information.

docs/user-guide/apis/python-api.md

@@ -0,0 +1,75 @@
+# Using the Python API
+
+This section covers an overview of the python API extension for Gaffer to
+demonstrate how to get up and running to perform queries from Python code on an
+existing running graph.
+
+!!! tip
+    Please see the handy introduction on [what is python](../gaffer-basics/what-is-python.md)
+    if you are new to the language.
+
+## What is the Python Extension?
+
+Commonly referred to as `gafferpy` this is an API to gaffer that provides
+similar querying capabilities to the rest API but from Python. Fundamentally it
+wraps the rest API to use the same JSON under the hood this means you should be
+able to access almost any features or end points available in the main rest API.
+
+## Installation
+
+Currently there isn't a release of `gafferpy` on pypi or other pip repository;
+however, the source code can still be cloned from the [git repository](https://github.com/gchq/gaffer-tools/tree/develop/python-shell)
+and installed via pip. Please see the readme in the `gafferpy` repository for
+full instructions.
+
+## How to Query a Graph
+
+To get started with `gafferpy` you will need to import the module and connect to
+an existing graph, the connection should be the same address as where the rest
+API is running.
+
+```python
+from gafferpy import gaffer
+from gafferpy import gaffer_connector
+g_connector = gaffer_connector.GafferConnector("http://localhost:8080/rest/latest")
+```
+
+Once connected you can access and run the same endpoints and operations as you
+would via the usual rest API but via their python classes. The endpoints are
+accessed via the `GafferConnector` to allow you executing Operation chains to
+perform queries on the graph.
+
+!!! note
+    There may be of the features of the full rest API not be present in
+    `gafferpy` as always check the [reference guide](../../reference/intro.md)
+    first.
+
+!!! example ""
+    A simple Operation can be called via the `execute_operation()` function. As
+    an example, the following will get all the elements in a graph:
+
+    ```python
+    elements = g_connector.execute_operation(
+        operation =  gaffer.GetAllElements()
+    )
+    ```
+
+!!! example ""
+    An Operation chain can be ran using the `execute_operation_chain()` function.
+    As an example, the following will get all the elements in a graph then
+    count them.
+
+    ```python
+    count = g_connector.execute_operation_chain(
+        operation_chain = gaffer.OperationChain(
+            operations=[
+                gaffer.GetAllElements(),
+                gaffer.Count()
+            ]
+        )
+    )
+    ```
+
+Along with running Operations you can of course optionally apply some filtering
+provided by a `View`. There are more detail on both [filtering](../query/gaffer-syntax/filtering.md)
+and [operations](../query/gaffer-syntax/operations.md) on their respective pages.