[#3] codacy corrections

Author: d-w-moore

irods/__init__.py

@@ -7,6 +7,8 @@
 
 def client_logging(flag=True,handler=None):
     """
+    Example of use:
+
     import irods
     # Enable / Disable general client logging
     irods.client_logging(True[,handler]) -> handler

irods/data_object.py

@@ -3,16 +3,14 @@
 import sys
 import logging
 import six
-import json
 import os
 import ast
 
-import xml.etree.ElementTree as ET
 from irods.models import DataObject
 from irods.meta import iRODSMetaCollection
 import irods.keywords as kw
 from irods.api_number import api_number
-from irods.message import (StringStringMap, FileOpenRequest, JSON_Message, iRODSMessage)
+from irods.message import (JSON_Message, iRODSMessage)
 
 logger = logging.getLogger(__name__)
 
@@ -111,7 +109,17 @@ def replicate(self, resource=None, **options):
 
 class iRODSDataObjectFileRaw(io.RawIOBase):
 
+    """The raw object supporting file-like operations (read/write/seek) for the
+       iRODSDataObject."""
+
     def __init__(self, conn, descriptor, finalize_on_close = True, **options):
+        """
+        Constructor needs a connection and an iRODS data object descriptor. If the
+        finalize_on_close flag evaluates False, close() will invoke the REPLICA_CLOSE
+        API instead of closing and finalizing the object (useful for parallel
+        transfers using multiple threads).
+        """
+        super(iRODSDataObjectFileRaw,self).__init__()
         self.conn = conn
         self.desc = descriptor
         self.options = options
@@ -128,7 +136,7 @@ def replica_access_info(self):
             result = self.conn.recv()
         except Exception as e:
             logger.warning('''Couldn't receive or process response to GET_FILE_DESCRIPTOR_INFO_APN -- '''
-                           '''caught: {0!r}'''.format(e))
+                           '''caught: %r''',e)
             raise
         dobj_info = result.get_json_encoded_struct()
         replica_token = dobj_info.get("replica_token","")
@@ -142,14 +150,13 @@ def _close_replica(self):
                                        "send_notification": False,
                                        "update_size": False,
                                        "update_status": False,
-                                       "send_notification": False,
                                        "compute_checksum": False },
                                      server_version = self.conn.server_version )
         self.conn.send( iRODSMessage('RODS_API_REQ', msg = message_body,
                                      int_info=api_number['REPLICA_CLOSE_APN']) )
         try:
             self.conn.recv().int_info
-        except Exception as e:
+        except Exception:
             logger.warning ('** ERROR on closing replica **')
             raise
         return True

irods/manager/data_object_manager.py

@@ -111,7 +111,7 @@ def put(self, local_path, irods_path, return_data_object = False, num_threads =
         with open(local_path, 'rb') as f, self.open(obj, 'w', **options) as o:
 
             if self.should_parallelize_transfer (num_threads, f):
-                f.close();
+                f.close()
                 if not self.parallel_put( local_path, (obj,o), num_threads = num_threads,
                                           target_resource_name = options.get(kw.RESC_NAME_KW,'') or
                                                                  options.get(kw.DEST_RESC_NAME_KW,'')):
@@ -205,9 +205,9 @@ def create(self, path, resource=None, force=False, **options):
         return self.get(path)
 
 
-    def open_with_FileRaw(self, *arg, **kw):
+    def open_with_FileRaw(self, *arg, **kw_options):
         holder = []
-        handle = self.open(*arg,_raw_fd_holder=holder,**kw)
+        handle = self.open(*arg,_raw_fd_holder=holder,**kw_options)
         return (handle, holder[-1])
 
     def open(self, path, mode, create = True, finalize_on_close = True, **options):

irods/message/__init__.py

@@ -1,4 +1,5 @@
-import base64
+"""Define objects related to communication with iRODS server API endpoints."""
+
 import struct
 import logging
 import socket
@@ -252,7 +253,9 @@ class AuthPluginOut(Message):
 # define InxIvalPair_PI "int iiLen; int *inx(iiLen); int *ivalue(iiLen);"
 
 class JSON_Binary_Request(BinBytesBuf):
+
     """A message body whose payload is BinBytesBuf containing JSON."""
+
     def __init__(self,msg_struct):
         """Initialize with a Python data structure that will be converted to JSON."""
         super(JSON_Binary_Request,self).__init__()
@@ -261,16 +264,19 @@ def __init__(self,msg_struct):
         self.buflen = len(string)
 
 class BytesBuf(Message):
+
+    """A generic structure carrying text content"""
+
     _name = 'BytesBuf_PI'
     buflen = IntegerProperty()
     buf = StringProperty()
     def __init__(self,string,*v,**kw):
-      super(BytesBuf,self).__init__(*v,**kw)
-      _buf = StringProperty.escape_xml_string( string )
-      self.buf = string
-      self.buflen = len(self.buf)
+        super(BytesBuf,self).__init__(*v,**kw)
+        self.buf = string
+        self.buflen = len(self.buf)
 
 class JSON_XMLFramed_Request(BytesBuf):
+
     """A message body whose payload is a BytesBuf containing JSON."""
     def __init__(self, msg_struct):
         """Initialize with a Python data structure that will be converted to JSON."""
@@ -408,7 +414,10 @@ class FileOpenRequest(Message):
     KeyValPair_PI = SubmessageProperty(StringStringMap)
 
 class DataObjChksumRequest(FileOpenRequest):
+    """Report and/or generate a data object's checksum."""
+
     def __init__(self,path,**chksumOptions):
+        """Construct the request using the path of a data object."""
         super(DataObjChksumRequest,self).__init__()
         for attr,prop in vars(FileOpenRequest).items():
             if isinstance(prop, (IntegerProperty,LongProperty)):

irods/parallel.py

@@ -3,7 +3,6 @@
 
 import os
 import ssl
-import json
 import time
 import sys
 import logging
@@ -13,14 +12,9 @@
 import multiprocessing
 import six
 
-import irods
-import irods.data_object
-from irods.data_object import iRODSDataObjectFileRaw, iRODSDataObject
+from irods.data_object import iRODSDataObject
 from irods.exception import DataObjectDoesNotExist
-from irods.message import ( StringStringMap, FileOpenRequest, iRODSMessage )
-from irods.api_number import api_number
 import irods.keywords as kw
-from collections import OrderedDict
 from six.moves.queue import Queue,Full,Empty
 
 
@@ -44,6 +38,7 @@ def __init__(self, n):
             self.barrier = threading.Semaphore(0)
         def wait(self):
             """Per-thread wait function.
+
             As in Python3.2 threading, returns 0 <= wait_serial_int < n
             """
             self.mutex.acquire()
@@ -58,6 +53,7 @@ def wait(self):
 @contextlib.contextmanager
 def enableLogging(handlerType,args,level_ = logging.INFO):
     """Context manager for temporarily enabling a logger. For debug or test.
+
     Usage Example -
     with irods.parallel.enableLogging(logging.FileHandler,('/tmp/logfile.txt',)):
         # parallel put/get code here
@@ -98,6 +94,10 @@ def set_transfer_done_callback( self, callback ):
         self.done_callback = callback
 
     def __init__(self, futuresList, callback = None, progress_Queue = None, total = None, keep_ = ()):
+        """AsyncNotify initialization (used internally to the io.parallel library).
+           The casual user will only be concerned with the callback parameter, called when all threads
+           of the parallel PUT or GET have been terminated and the data object closed.
+        """
         self._futures = set(futuresList)
         self._futures_done = dict()
         self.keep = dict(keep_)
@@ -173,15 +173,21 @@ def futures_done(self): return dict(self._futures_done)
 
 
 class Oper(object):
-
     """A custom enum-type class with utility methods.  """
 
     GET = 0
     PUT = 1
     NONBLOCKING = 2
 
-    def __int__(self): return self._opr
-    def __init__(self, rhs): self._opr = int(rhs)
+    def __int__(self):
+        """Return the stored flags as an integer bitmask. """
+        return self._opr
+
+    def __init__(self, rhs):
+        """Initialize with a bit mask of flags ie. whether Operation PUT or GET, 
+        and whether NONBLOCKING."""
+        self._opr = int(rhs)
+
     def isPut(self): return 0 != (self._opr & self.PUT)
     def isGet(self): return not self.isPut()
     def isNonBlocking(self): return 0 != (self._opr & self.NONBLOCKING)
@@ -290,7 +296,6 @@ def _io_multipart_threaded(operation_ , dataObj_and_IO, replica_token, hier_str,
                            total_size, num_threads = 0, **extra_options):
     """Called by _io_main.
     Carve up (0,total_size) range into `num_threads` parts and initiate a transfer thread for each one."""
-
     (D, Io) = dataObj_and_IO
     Operation = Oper( operation_ )
 

irods/test/data_obj_test.py

@@ -22,7 +22,7 @@
 import irods.keywords as kw
 from irods.manager import data_object_manager
 from datetime import datetime
-from tempfile import NamedTemporaryFile, mkdtemp
+from tempfile import NamedTemporaryFile
 from irods.test.helpers import (unique_name, my_function_name)
 import irods.parallel
 

irods/test/extended_test.py

@@ -30,8 +30,7 @@ def tearDown(self):
 
     @classmethod
     def tearDownClass(cls):
-        '''Remove test data
-        '''
+        """Remove test data."""
         # once only (after all tests), delete large collection
         print ("Deleting the large collection...", file = sys.stderr)
         with helpers.make_session() as sess:

irods/test/force_create.py

@@ -19,7 +19,7 @@ def tearDown(self):
     # This test should pass whether or not federation is configured:
     def test_force_create(self):
         if self.sess.server_version > (4, 2, 8):
-                        self.skipTest('force flag unneeded for create in iRODS > 4.2.8')
+            self.skipTest('force flag unneeded for create in iRODS > 4.2.8')
         session = self.sess
         FILE = '/{session.zone}/home/{session.username}/a.txt'.format(**locals())
         try:

irods/test/helpers.py

@@ -19,14 +19,15 @@
 
 
 def my_function_name():
-    '''Returns the name of the calling function or method'''
+    """Returns the name of the calling function or method"""
     return inspect.getframeinfo(inspect.currentframe().f_back).function
 
 _thrlocal = threading.local()
 
 def unique_name(*seed_tuple):
     '''For deterministic pseudo-random identifiers based on function/method name
        to prevent e.g.  ICAT collisions within and between tests.  Example use:
+
            def f(session):
              seq_num = 1
              a_name = unique_name( my_function_name(), seq_num # [, *optional_further_args]
@@ -44,7 +45,6 @@ def f(session):
 IRODS_SHARED_REG_RESC_VAULT = os.path.join(IRODS_SHARED_DIR,'reg_resc')
 
 IRODS_REG_RESC = 'MyRegResc'
-Reg_Resc_Name = ''
 
 def irods_shared_tmp_dir():
     pth = IRODS_SHARED_TMP_DIR

irods/test/query_test.py

@@ -23,7 +23,7 @@
 from irods.meta import iRODSMeta
 from irods.rule import Rule
 from irods import MAX_SQL_ROWS
-from irods.test.helpers import (irods_shared_reg_resc_vault, get_register_resource)
+from irods.test.helpers import irods_shared_reg_resc_vault
 import irods.test.helpers as helpers
 from six.moves import range as py3_range
 import irods.keywords as kw

run_python_tests.sh

@@ -6,8 +6,8 @@ cd repo/irods/test
 export PYTHONUNBUFFERED="Y"
 
 if [ -z "${TESTS_TO_RUN}" ] ; then
-    python${PY_N} runner.py 2>&1 | tee ${LOG_OUTPUT_DIR}/prc_test_logs.txt
+    python"${PY_N}" runner.py 2>&1 | tee "${LOG_OUTPUT_DIR}"/prc_test_logs.txt
 else 
-    python${PY_N} -m unittest -v ${TESTS_TO_RUN} 2>&1 | tee ${LOG_OUTPUT_DIR}/prc_test_logs.txt
+    python"${PY_N}" -m unittest -v ${TESTS_TO_RUN} 2>&1 | tee "${LOG_OUTPUT_DIR}"/prc_test_logs.txt
 fi