Fix a bunch of PyCharm warnings, and add some missing tests.

Author: donkirkby

.gitignore

@@ -1,3 +1,4 @@
+/.idea/dictionaries
 /.idea/misc.xml
 /.idea/workspace.xml
 

pyvdrm/asi2.py

@@ -1,23 +1,25 @@
-'''
+"""
 ASI2 Parser definition
-'''
+"""
 
 from functools import reduce, total_ordering
 from pyparsing import (Literal, nums, Word, Forward, Optional, Regex,
                        infixNotation, delimitedList, opAssoc)
 from pyvdrm.drm import AsiExpr, AsiBinaryExpr, AsiUnaryExpr, DRMParser
 from pyvdrm.vcf import MutationSet
 
+
 def maybe_foldl(func, noneable):
-    '''Safely fold a function over a potentially empty list of
-    potentially null values'''
+    """Safely fold a function over a potentially empty list of
+    potentially null values"""
     if noneable is None:
         return None
     clean = [x for x in noneable if x is not None]
-    if clean == []:
+    if not clean:
         return None
     return reduce(func, clean)
 
+
 def maybe_map(func, noneable):
     if noneable is None:
         return None
@@ -29,14 +31,14 @@ def maybe_map(func, noneable):
         if result is None:
             continue
         r_list.append(result)
-    if r_list == []:
+    if not r_list:
         return None
     return r_list
 
 
 @total_ordering
 class Score(object):
-    '''Encapsulate a score and the residues that support it'''
+    """Encapsulate a score and the residues that support it"""
 
     residues = set([])
     score = None
@@ -68,32 +70,32 @@ def __bool__(self):
 
 
 class Negate(AsiUnaryExpr):
-    '''Unary negation of boolean child'''
+    """Unary negation of boolean child"""
     def __call__(self, mutations):
         arg = self.children(mutations)
         return Score(not arg.score, arg.residues)
 
 
 class AndExpr(AsiExpr):
-    '''Fold boolean AND on children'''
+    """Fold boolean AND on children"""
 
     def __call__(self, mutations):
         scores = map(lambda f: f(mutations), self.children[0])
         scores = [Score(False, []) if s is None else s for s in scores]
-        if scores == []:
+        if not scores:
             raise ValueError
 
         residues = set([])
         for s in scores:
-            if s.score == False:
+            if not s.score:
                 return Score(False, [])
             residues = residues | s.residues
 
         return Score(True, residues)
 
 
 class OrExpr(AsiBinaryExpr):
-    '''Boolean OR on children (binary only)'''
+    """Boolean OR on children (binary only)"""
 
     def __call__(self, mutations):
         arg1, arg2 = self.children
@@ -111,9 +113,10 @@ def __call__(self, mutations):
 
 
 class EqualityExpr(AsiExpr):
-    '''ASI2 inequality expressions'''
+    """ASI2 inequality expressions"""
 
     def __init__(self, label, pos, children):
+        super().__init__(label, pos, children)
         self.operation, limit = children
         self.limit = int(limit)
 
@@ -132,10 +135,9 @@ def __repr__(self):
 
 
 class ScoreExpr(AsiExpr):
-    '''Score expressions propagate DRM scores'''
+    """Score expressions propagate DRM scores"""
 
     def __call__(self, mutations):
-        operation, score = (None, None)
         if len(self.children) == 3:
             operation, minus, score = self.children
             if minus != '-':
@@ -162,23 +164,23 @@ def __repr__(self):
 
 
 class ScoreList(AsiExpr):
-    '''Lists of scores are either summed or maxed'''
+    """Lists of scores are either summed or maxed"""
 
     def __call__(self, mutations):
         operation, *rest = self.children
         if operation == 'MAX':
             return maybe_foldl(max, [f(mutations) for f in rest])
 
         # the default operation is sum
-        return maybe_foldl(lambda x,y: x+y, [f(mutations) for f in self.children])
+        return maybe_foldl(lambda x, y: x+y, [f(mutations) for f in self.children])
 
 
 class SelectFrom(AsiExpr):
-    '''Return True if some number of mutations match'''
+    """Return True if some number of mutations match"""
 
     def typecheck(self, tokens):
-#        if type(tokens[0]) != EqualityExpr:
-#            raise TypeError
+        # if type(tokens[0]) != EqualityExpr:
+        #     raise TypeError()
         pass
 
     def __call__(self, mutations):
@@ -190,27 +192,27 @@ def __call__(self, mutations):
 
         if operation(passing):
             return Score(True, maybe_foldl(
-                lambda x,y: x.residues.union(y.residues), scored))
+                lambda x, y: x.residues.union(y.residues), scored))
         else:
             return None
 
 
 class AsiScoreCond(AsiExpr):
-    '''Score condition'''
+    """Score condition"""
 
     label = "ScoreCond"
 
     def __call__(self, args):
-        '''Score conditions evaluate a list of expressions and sum scores'''
-        return maybe_foldl(lambda x,y: x+y, map(lambda x: x(args), self.children))
+        """Score conditions evaluate a list of expressions and sum scores"""
+        return maybe_foldl(lambda x, y: x+y, map(lambda x: x(args), self.children))
 
 
 class AsiMutations(object):
-    '''List of mutations given an ambiguous pattern'''
+    """List of mutations given an ambiguous pattern"""
 
     def __init__(self, pos, label, args):
-        '''Initialize set of mutations from a potentially ambiguous residue
-        '''
+        """Initialize set of mutations from a potentially ambiguous residue
+        """
         if pos and label:
             pass
         self.mutations = MutationSet.from_string(''.join(args))
@@ -226,7 +228,7 @@ def __call__(self, env):
 
 
 class ASI2(DRMParser):
-    '''ASI2 Syntax definition'''
+    """ASI2 Syntax definition"""
 
     def parser(self, rule):
 
@@ -241,7 +243,7 @@ def parser(self, rule):
 
         and_ = Literal('AND').suppress()
         or_ = Literal('OR').suppress()
-        #min_ = Literal('MIN')
+        # min_ = Literal('MIN')
 
         notmorethan = Literal('NOTMORETHAN')
         l_par = Literal('(').suppress()
@@ -256,8 +258,8 @@ def parser(self, rule):
         not_.setParseAction(Negate)
 
         residue = mutation | not_
-#            integer + l_par + not_ + Regex(r'[A-Z]+') + r_par
-            # roll this next rule into the mutation object
+        # integer + l_par + not_ + Regex(r'[A-Z]+') + r_par
+        # roll this next rule into the mutation object
 
         # Syntax of ASI expressions
         excludestatement = except_ + residue
@@ -286,11 +288,11 @@ def parser(self, rule):
         scoreitem = booleancondition + mapper + Optional(Literal('-')) + integer
         scoreitem.setParseAction(ScoreExpr)
         scorelist = max_ + l_par + delimitedList(scoreitem) + r_par |\
-                    delimitedList(scoreitem)
+            delimitedList(scoreitem)
         scorelist.setParseAction(ScoreList)
 
         scorecondition = Literal('SCORE FROM').suppress() +\
-                l_par + delimitedList(scorelist) + r_par
+            l_par + delimitedList(scorelist) + r_par
 
         scorecondition.setParseAction(AsiScoreCond)
 

pyvdrm/drm.py

@@ -1,25 +1,26 @@
-'''Asi2 specification
-'''
+"""Asi2 specification
+"""
 
 from abc import ABCMeta, abstractmethod
 
+
 class AsiParseError(Exception):
     pass
 
 
 class DRMParser(metaclass=ABCMeta):
-    '''abstract class for DRM rule parsers/evaluators'''
+    """abstract class for DRM rule parsers/evaluators"""
 
     def __init__(self, rule):
-        '''drug resistance mutation callers are initialized with rule strings,
+        """drug resistance mutation callers are initialized with rule strings,
             the initialized parser has a callable decision tree object
-        '''
+        """
         self.rule = rule
         self.dtree, *rest = self.parser(rule)
 
     @abstractmethod
     def parser(self, rule_string):
-        '''The parser returns a decision tree based on the rule string'''
+        """The parser returns a decision tree based on the rule string"""
         pass
 
     def __call__(self, mutations):
@@ -33,13 +34,13 @@ def __repr__(self):
 
 
 class AsiExpr(object):
-    '''A callable ASI2 expression'''
+    """A callable ASI2 expression"""
 
     children = []
     label = None
 
-    def __init__(self, label, pos, tokens):
-        '''By default we assume the head of the arg list is the operation'''
+    def __init__(self, _label, _pos, tokens):
+        """By default we assume the head of the arg list is the operation"""
 
         self.typecheck(tokens.asList())
         self.children = tokens
@@ -48,22 +49,23 @@ def __init__(self, label, pos, tokens):
             self.label = str(type(self))
 
     def typecheck(self, tokens):
-        '''Override typecheck method to define runtime errors'''
+        """Override typecheck method to define runtime errors"""
         pass
 
     def __call__(self, args):
-        '''Evaluate child tokens with args'''
+        """Evaluate child tokens with args"""
         return self.children(args)
 
     def __repr__(self):
-        '''Pretty print syntax tree'''
+        """Pretty print syntax tree"""
         return str(type(self))
 
 
 class AsiBinaryExpr(AsiExpr):
-    '''Subclass with syntactic sugar for boolean ops'''
+    """Subclass with syntactic sugar for boolean ops"""
 
     def __init__(self, label, pos, tokens):
+        super().__init__(label, pos, tokens)
         self.children = tokens[0]
 
     def typecheck(self, tokens):
@@ -76,7 +78,7 @@ def __repr__(self):
 
 
 class AsiUnaryExpr(AsiExpr):
-    '''Subclass for atoms and unary ops'''
+    """Subclass for atoms and unary ops"""
 
     def typecheck(self, tokens):
         if isinstance(tokens[0], list):