[CLIENT-4702] Test API doc code examples for aerospike.exception, aerospike.GeoJSON, aerospike.predicates, and aerospike.Query

doc/aerospike.rst

@@ -255,8 +255,84 @@ The following example shows the three modes of serialization:
 2. Class-level user functions
 3. Instance-level user functions
 
-.. include:: examples/serializer.py
-    :code: python
+.. testcode::
+
+    import aerospike
+    import marshal
+    import json
+
+    # Serializers and deserializers
+    # Both local and global serializers use json library
+    # Functions print which one is being used
+
+    def classSerializer(obj):
+        print("Using class serializer")
+        return json.dumps(obj)
+
+    def classDeserializer(bytes):
+        print("Using class deserializer")
+        return json.loads(bytes)
+
+    def localSerializer(obj):
+        print("Using local serializer")
+        return json.dumps(obj)
+
+    def localDeserializer(bytes):
+        print("Using local deserializer")
+        return json.loads(bytes)
+
+    # First client has class-level serializer set in aerospike module
+    aerospike.set_serializer(classSerializer)
+    aerospike.set_deserializer(classDeserializer)
+    config = {
+        'hosts': [('127.0.0.1', 3000)]
+    }
+    client = aerospike.client(config)
+
+    # Second client has instance-level serializer set in client config
+    config['serialization'] = (localSerializer, localDeserializer)
+    client2 = aerospike.client(config)
+
+    # Keys: foo1, foo2, foo3
+    keys = [('test', 'demo', f'foo{i}') for i in range(1, 4)]
+    # Tuple is an unsupported type
+    tupleBin = {'bin': (1, 2, 3)}
+
+    # Use the default, built-in serialization (cPickle)
+    client.put(keys[0], tupleBin)
+    (_, _, bins) = client.get(keys[0])
+    print(bins)
+
+    # Expected output:
+    # {'bin': (1, 2, 3)}
+
+    # First client uses class-level, user-defined serialization
+    # No instance-level serializer was declared
+    client.put(keys[1], tupleBin, serializer=aerospike.SERIALIZER_USER)
+    (_, _, bins) = client.get(keys[1])
+    # Notice that json-encoding a tuple produces a list
+    print(bins)
+
+    # Expected output:
+    # Using class serializer
+    # Using class deserializer
+    # {'bin': [1, 2, 3]}
+
+    # Second client uses instance-level, user-defined serialization
+    # Instance-level serializer overrides class-level serializer
+    client2.put(keys[2], tupleBin, serializer=aerospike.SERIALIZER_USER)
+    (_, _, bins) = client2.get(keys[2])
+    print(bins)
+
+    # Expected output:
+    # Using local serializer
+    # Using local deserializer
+    # {'bin': [1, 2, 3]}
+
+    # Cleanup
+    client.batch_remove(keys)
+    client.close()
+    client2.close()
 
 Records ``foo1`` and ``foo2`` should have different encodings from each other since they use different serializers.
 (record ``foo3`` uses the same encoding as ``foo2``)
@@ -301,8 +377,42 @@ By default:
 
 The following example shows several different methods to configuring logging for the Aerospike Python Client:
 
-.. include:: examples/log.py
-    :code: python
+.. testcode::
+
+    # Enable the logging at application start, before connecting to the server.
+    import aerospike
+
+    ## SETTING THE LOG HANDLER ##
+
+    # Clears saved log handler and disable logging
+    aerospike.set_log_handler(None)
+
+    # Set default log handler to print to the console
+    aerospike.set_log_handler()
+
+    def log_callback(level, func, path, line, msg):
+        print("[{}] {}".format(func, msg))
+
+    # Set log handler to custom callback function (defined above)
+    aerospike.set_log_handler(log_callback)
+
+
+    ## SETTING THE LOG LEVEL ##
+
+    # disables log handling
+    aerospike.set_log_level(aerospike.LOG_LEVEL_OFF)
+
+    # Enables log handling and sets level to LOG_LEVEL_TRACE
+    aerospike.set_log_level(aerospike.LOG_LEVEL_TRACE)
+
+    # Create a client and connect it to the cluster
+    # This line will print use log_callback to print logs with a log level of TRACE
+    config = {
+        "hosts": [
+            ("127.0.0.1", 3000)
+        ]
+    }
+    client = aerospike.client(config)
 
 .. py:function:: set_log_handler(log_handler: Optional[Callable[[int, str, str, int, str], None]])
 

doc/aerospike_helpers.expressions.rst

@@ -36,8 +36,64 @@ the command will filter the results.
 
 Example:
 
-.. include:: examples/expressions/top.py
-  :code: python
+.. testcode::
+
+  import aerospike
+  from aerospike_helpers import expressions as exp
+  import pprint
+
+  # Connect to database
+  config = {"hosts": [("127.0.0.1", 3000)]}
+  client = aerospike.client(config)
+
+  # Write player records to database
+  keys = [("test", "demo", i) for i in range(1, 5)]
+  records = [
+              {'user': "Chief"  , 'scores': [6, 12, 4, 21], 'kd': 1.2},
+              {'user': "Arbiter", 'scores': [5, 10, 5, 8] , 'kd': 1.0},
+              {'user': "Johnson", 'scores': [8, 17, 20, 5], 'kd': 0.9},
+              {'user': "Regret" , 'scores': [4, 2, 3, 5]  , 'kd': 0.3}
+          ]
+  for key, record in zip(keys, records):
+      client.put(key, record)
+
+  # Example #1: Get players with a K/D ratio >= 1.0
+
+  kdGreaterThan1 = exp.GE(exp.FloatBin("kd"), 1.0).compile()
+  policy = {"expressions": kdGreaterThan1}
+  brs = client.batch_read(keys, policy=policy)
+
+  # Pretty print records' bins
+  for br in brs.batch_records:
+      # error code for FILTERED_OUT = 27
+      pprint.pprint(br.record[2] if br.result != 27 else None)
+  # {'user': 'Chief', 'scores': [6, 12, 4, 21], 'kd': 1.2}
+  # {'user': 'Arbiter', 'scores': [5, 10, 5, 8], 'kd': 1.0}
+  # None
+  # None
+
+  # Example #2: Get player with scores higher than 20
+  # By nesting expressions, we can create complicated filters
+
+  # Get top score
+  getTopScore = exp.ListGetByRank(
+                  None,
+                  aerospike.LIST_RETURN_VALUE,
+                  exp.ResultType.INTEGER,
+                  -1,
+                  exp.ListBin("scores")
+                  )
+  # ...then compare it
+  scoreHigherThan20 = exp.GE(getTopScore, 20).compile()
+  policy = {"expressions": scoreHigherThan20}
+  brs = client.batch_read(keys, policy=policy)
+
+  for br in brs.batch_records:
+      pprint.pprint(br.record[2] if br.result != 27 else None)
+  # {'user': 'Chief', 'scores': [6, 12, 4, 21], 'kd': 1.2}
+  # None
+  # {'user': 'Johnson', 'scores': [8, 17, 20, 5], 'kd': 0.9}
+  # None
 
 Currently, Aerospike expressions are supported for:
   * Record commands