[GNUnet-SVN] [gnunet-python] 02/02: PEP

[gnunet]

This is an automated email from the git hooks/post-receive script.

ng0 pushed a commit to branch master
in repository gnunet-python.

commit b285c08b871c4b28fcf46a7437ab2713f78b2891
Author: ng0 <address@hidden>
AuthorDate: Fri Dec 1 21:10:30 2017 +0000

    PEP
---
 examples/example-dht.py |  17 ++---
 examples/example-gns.py |  16 ++---
 gnunet/dht.py           | 183 ++++++++++++++++++++++++------------------------
 3 files changed, 110 insertions(+), 106 deletions(-)

diff --git a/examples/example-dht.py b/examples/example-dht.py
index 64dd1cb..76f345b 100755
--- a/examples/example-dht.py
+++ b/examples/example-dht.py
@@ -7,18 +7,19 @@ key = 
gnunet.HashCode("RMKN0U1JNA3PVCL148D6JI0STVG94A8A65INOK849CF1RT6BGF26AMMT1
 
 gnunet.dht.put(key, 1, "test", b"hello")
 
+
 def result_callback(block_type, key, data, expiry, get_path, put_path):
-  print("Got result from DHT")
-  print("  block_type == %s" % repr(block_type))
-  print("  key        == %s" % repr(key))
-  print("  expiry     == %s" % repr(expiry))
-  print("  get_path   == %s" % repr(get_path))
-  print("  put_path   == %s" % repr(put_path))
-  print("  data       == %s" % repr(data))
+    print("Got result from DHT")
+    print("  block_type == %s" % repr(block_type))
+    print("  key        == %s" % repr(key))
+    print("  expiry     == %s" % repr(expiry))
+    print("  get_path   == %s" % repr(get_path))
+    print("  put_path   == %s" % repr(put_path))
+    print("  data       == %s" % repr(data))
+
 
 req = gnunet.dht.get_start(result_callback, "test", key, 1, record_route=True)
 req.filter_known_results([])
 req.stop()
 
 time.sleep(1)
-
diff --git a/examples/example-gns.py b/examples/example-gns.py
index 4b3ea10..efbea27 100755
--- a/examples/example-gns.py
+++ b/examples/example-gns.py
@@ -2,14 +2,14 @@
 
 import gnunet.gns
 
+
 results = gnunet.gns.lookup("www.gnu", 
"JK55QA8JLAL64MBO8UM209KE93M9JBBO7M2UB8M3M03FKRFSUOMG", "A", True)
 
 for r in results:
-  print("Got result from gns")
-  print("  record_type     == %s" % repr(r.record_type))
-  print("  data            == %s" % repr(r.data))
-  print("  expiration_time == %s" % repr(r.expiration_time))
-  print("  private         == %s" % repr(r.private))
-  print("  pending         == %s" % repr(r.pending))
-  print("  shadow          == %s" % repr(r.shadow))
-
+    print("Got result from gns")
+    print("  record_type     == %s" % repr(r.record_type))
+    print("  data            == %s" % repr(r.data))
+    print("  expiration_time == %s" % repr(r.expiration_time))
+    print("  private         == %s" % repr(r.private))
+    print("  pending         == %s" % repr(r.pending))
+    print("  shadow          == %s" % repr(r.shadow))
diff --git a/gnunet/dht.py b/gnunet/dht.py
index 849f07a..8f310a9 100644
--- a/gnunet/dht.py
+++ b/gnunet/dht.py
@@ -10,109 +10,112 @@ import gnunet.block as block
 get_requests = {}
 requests_lock = threading.Lock()
 
+
 class GetResult(threading.Thread):
-  def __init__(self, expiry, key, get_path, put_path, block_type, data, path):
-    threading.Thread.__init__(self)
-    self.expiry = expiry
-    self.key = key
-    self.get_path = get_path
-    self.put_path = put_path
-    self.block_type = block_type
-    self.data = data
-    self.path = path
-    self.daemon = True
-    self.start()
-
-  def run(self):
-    request = None
-    with requests_lock:
-      request = get_requests[self.path]
-
-    if request:
-      if request.record_route:
-        request.callback(self.block_type, self.key, self.data, self.expiry, 
get_path=self.get_path, put_path=self.put_path)
-      else:
-        request.callback(self.block_type, self.key, self.data, self.expiry)
+    def __init__(self, expiry, key, get_path, put_path, block_type, data, 
path):
+        threading.Thread.__init__(self)
+        self.expiry = expiry
+        self.key = key
+        self.get_path = get_path
+        self.put_path = put_path
+        self.block_type = block_type
+        self.data = data
+        self.path = path
+        self.daemon = True
+        self.start()
+
+    def run(self):
+        request = None
+        with requests_lock:
+            request = get_requests[self.path]
+
+        if request:
+            if request.record_route:
+                request.callback(self.block_type, self.key, self.data, 
self.expiry, get_path=self.get_path, put_path=self.put_path)
+            else:
+                request.callback(self.block_type, self.key, self.data, 
self.expiry)
+
 
 def _result(expiry, key, get_path, put_path, block_type, data, path):
-  expiry = pythonize(expiry, datetime.datetime)
-  key = HashCode(key)
-  get_path = list(get_path)
-  put_path = list(put_path)
-  block_type = str(block_type)
-  data = bytearray(data)
-  GetResult(expiry, key, get_path, put_path, block_type, data, path)
+    expiry = pythonize(expiry, datetime.datetime)
+    key = HashCode(key)
+    get_path = list(get_path)
+    put_path = list(put_path)
+    block_type = str(block_type)
+    data = bytearray(data)
+    GetResult(expiry, key, get_path, put_path, block_type, data, path)
 
 sysbus.add_signal_receiver(_result, "result", "gnu.gnunet.dht.get", 
"gnu.gnunet.dht", path_keyword="path")
 
+
 class GetRequest:
-  def __init__(self, path, callback, record_route):
-    self._path = path
-    self.callback = callback
-    self.record_route = record_route
+    def __init__(self, path, callback, record_route):
+        self._path = path
+        self.callback = callback
+        self.record_route = record_route
+
+    def filter_known_results(self, keys):
+        keys = dbus.Array([dbusize(HashCode(key)) for key in list(keys)], 
signature="v")
+        try:
+            sysbus.get_object("gnu.gnunet.dht", 
self._path).filter_known_results(keys, dbus_interface="gnu.gnunet.dht.get")
+        except dbus.DBusException as e:
+            handle_exception(e, "dht", "gnu.gnunet.dht")
+
+    def stop(self):
+        try:
+            sysbus.get_object("gnu.gnunet.dht", 
self._path).stop(dbus_interface="gnu.gnunet.dht.get")
+        except dbus.DBusException as e:
+            handle_exception(e, "dht", "gnu.gnunet.dht")
 
-  def filter_known_results(self, keys):
-    keys = dbus.Array([dbusize(HashCode(key)) for key in list(keys)], 
signature="v")
-    try:
-      sysbus.get_object("gnu.gnunet.dht", 
self._path).filter_known_results(keys, dbus_interface="gnu.gnunet.dht.get")
-    except dbus.DBusException as e:
-      handle_exception(e, "dht", "gnu.gnunet.dht")
 
-  def stop(self):
+def put(key, desired_replication_level, block_type, data, expiry=None, 
demultiplex_everywhere=False, record_route=False, bart=False):
+    key = dbusize(HashCode(key), True)
+    desired_replication_level = dbus.UInt32(desired_replication_level)
+    if block_type not in block.types:
+        raise ValueError("'block_type' must be one of %s" % block.types)
+    block_type = dbus.String(block_type, variant_level=1)
+    if expiry is not None:
+        if not isinstance(expiry, datetime.datetime):
+            raise TypeError("'expiry' must be a datetime.datetime")
+        expiry = dbusize(expiry)
+    else:
+        expiry = dbus.String("end of time", variant_level=1)
+    options = dbus.Array([], variant_level=1, signature="s")
+    if demultiplex_everywhere:
+        options += ["demultiplex_everywhere"]
+    if record_route:
+        options += ["record_route"]
+    if bart:
+        options += ["bart"]
+    data = dbus.Array(bytearray(data), signature="y")
+
     try:
-      sysbus.get_object("gnu.gnunet.dht", 
self._path).stop(dbus_interface="gnu.gnunet.dht.get")
+        sysbus.get_object("gnu.gnunet.dht", "/").put(key, 
desired_replication_level, options, block_type, data, expiry)
     except dbus.DBusException as e:
-      handle_exception(e, "dht", "gnu.gnunet.dht")
+        handle_exception(e, "dht", "gnu.gnunet.dht")
 
-def put(key, desired_replication_level, block_type, data, expiry=None, 
demultiplex_everywhere=False, record_route=False, bart=False):
-  key = dbusize(HashCode(key), True)
-  desired_replication_level = dbus.UInt32(desired_replication_level)
-  if block_type not in block.types:
-    raise ValueError("'block_type' must be one of %s" % block.types)
-  block_type = dbus.String(block_type, variant_level=1)
-  if expiry is not None:
-    if not isinstance(expiry, datetime.datetime):
-      raise TypeError("'expiry' must be a datetime.datetime")
-    expiry = dbusize(expiry)
-  else:
-    expiry = dbus.String("end of time", variant_level=1)
-  options = dbus.Array([], variant_level=1, signature="s")
-  if demultiplex_everywhere:
-    options += ["demultiplex_everywhere"]
-  if record_route:
-    options += ["record_route"]
-  if bart:
-    options += ["bart"]
-  data = dbus.Array(bytearray(data), signature="y")
-
-  try:
-    sysbus.get_object("gnu.gnunet.dht", "/").put(key, 
desired_replication_level, options, block_type, data, expiry)
-  except dbus.DBusException as e:
-    handle_exception(e, "dht", "gnu.gnunet.dht")
 
 def get_start(callback, block_type, key, desired_replication_level, 
demultiplex_everywhere=False, record_route=False, bart=False):
-  if block_type not in block.types:
-    raise ValueError("'block_type' must be one of %s" % block.types)
-  block_type = dbus.String(block_type, variant_level=1)
-  key = dbusize(HashCode(key), True)
-  desired_replication_level = dbus.UInt32(desired_replication_level)
-  options = dbus.Array([], variant_level=1, signature="s")
-  if demultiplex_everywhere:
-    options += ["demultiplex_everywhere"]
-  if record_route:
-    options += ["record_route"]
-  if bart:
-    options += ["bart"]
+    if block_type not in block.types:
+        raise ValueError("'block_type' must be one of %s" % block.types)
+    block_type = dbus.String(block_type, variant_level=1)
+    key = dbusize(HashCode(key), True)
+    desired_replication_level = dbus.UInt32(desired_replication_level)
+    options = dbus.Array([], variant_level=1, signature="s")
+    if demultiplex_everywhere:
+        options += ["demultiplex_everywhere"]
+    if record_route:
+        options += ["record_route"]
+    if bart:
+        options += ["bart"]
   
-  ret = None
-  try:
-    with requests_lock:
-      path = sysbus.get_object("gnu.gnunet.dht", "/").get_start(block_type, 
key, desired_replication_level, options)
-      ret = GetRequest(path, callback, record_route)
-      get_requests[path] = ret
-  except dbus.DBusException as e:
-    handle_exception(e, "dht", "gnu.gnunet.dht")
-
-  return ret
-
+    ret = None
+    try:
+        with requests_lock:
+            path = sysbus.get_object("gnu.gnunet.dht", 
"/").get_start(block_type, key, desired_replication_level, options)
+            ret = GetRequest(path, callback, record_route)
+            get_requests[path] = ret
+    except dbus.DBusException as e:
+        handle_exception(e, "dht", "gnu.gnunet.dht")
 
+    return ret

-- 
To stop receiving notification emails like this one, please contact
address@hidden