[GNUnet-SVN] [gnunet-python] branch master updated (529fb05 -> b285c08)

[gnunet]

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

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

    from 529fb05  datatime.datetime seems like a typo. Make pythonize return 
datetime.datetime
     new 77db157  trailing whitespace
     new b285c08  PEP

The 2 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails.  The revisions
listed as "add" were already present in the repository and have only
been added to this reference.


Summary of changes:
 examples/example-dht.py |  17 ++---
 examples/example-gns.py |  16 ++---
 gnunet/_dbus_utils.py   |   2 +-
 gnunet/dht.py           | 183 ++++++++++++++++++++++++------------------------
 4 files changed, 111 insertions(+), 107 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/_dbus_utils.py b/gnunet/_dbus_utils.py
index 4621002..809ff26 100644
--- a/gnunet/_dbus_utils.py
+++ b/gnunet/_dbus_utils.py
@@ -41,7 +41,7 @@ def dbusize(arg, pretty):
             return dbus.Array(arg._data[:], variant_level=1, signature="y")
 
         # if type(arg) is gnsrecord.Data:
-        # return dbus.Struct([arg._recordtype, 
+        # return dbus.Struct([arg._recordtype,
 
     if isinstance(arg, datetime.datetime):
         if pretty:
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