rsclib 0.65__py3-none-any.whl → 0.67__py3-none-any.whl

rsclib/hexdump.py

@@ -73,19 +73,29 @@ def unhexdump (iterable, file = None):
             continue
         if end:
             raise ValueError ("Unknown hexdump format")
-        x = line.split ('  ', 2)
+        x = line.split ('  ', 1)
         if len (x) == 1:
             h = x [0]
         else:
             h = x [1]
-            assert len (x [0]) <= 8
+            assert len (x [0]) <= 10
         # Probably last line with only an address
         if ' ' not in h and len (x) == 1 and len (h) > 2:
             end = True
             continue
-        h = h.strip ().split (' ')
+        # Determine format: split the thing and throw away last element
+        # if that is longer than 2.
+        h = h.strip ().split ()
         if len (h [0]) > 2:
             h = h [1:]
+        if len (h) > 16:
+            h = h [:16]
+        if len (h [-1]) != 2:
+            h = h [:-1]
+        assert len (h [0])  == 2
+        assert len (h [-1]) == 2
+        assert len (h) <= 16
+
         if sys.version_info [0] < 3:
             method = lambda x: b''.join (chr (c) for c in x)
         else:

rsclib/iter_recipes.py

@@ -182,3 +182,20 @@ except ImportError :
             for j in range (i+1, r) :
                 indices [j] = indices [j-1] + 1
             yield tuple (pool [i] for i in indices)
+
+try :
+    from itertools import batched
+except ImportError :
+    def batched (x, n):
+        b = []
+        x = iter (x)
+        while True:
+            for k in range (n):
+                try:
+                    b.append (next (x))
+                except StopIteration:
+                    if b:
+                        yield b
+                    return
+            yield b
+            b = []

rsclib/{Rational.py → rational.py}

@@ -1,6 +1,5 @@
 #!/usr/bin/python
-# -*- coding: iso-8859-1 -*-
-# Copyright (C) 2007-17 Dr. Ralf Schlatterbeck Open Source Consulting.
+# Copyright (C) 2007-24 Dr. Ralf Schlatterbeck Open Source Consulting.
 # Reichergasse 131, A-3411 Weidling.
 # Web: http://www.runtux.com Email: office@runtux.com
 # All rights reserved
@@ -152,10 +151,7 @@ class Rational (autosuper) :
             other = self.__class__ (other)
         p = self.p * other.q
         q = self.q * other.p
-        if q < 0 :
-            p = -p
-            q = -q
-        return self.__class__ (p, q)
+        return p // q
     # end def __floordiv__
 
     def __rfloordiv__ (self, other) :
@@ -164,6 +160,23 @@ class Rational (autosuper) :
         return other // self
     # end def __rfloordiv__
 
+    def __truediv__ (self, other) :
+        if not isinstance (other, self.__class__) :
+            other = self.__class__ (other)
+        p = self.p * other.q
+        q = self.q * other.p
+        if q < 0 :
+            p = -p
+            q = -q
+        return self.__class__ (p, q)
+    # end def __truediv__
+
+    def __rtruediv__ (self, other) :
+        if not isinstance (other, self.__class__) :
+            other = self.__class__ (other)
+        return other / self
+    # end def __rtruediv__
+
     def __int__ (self) :
         return int (self.p // self.q)
     # end def __int__
@@ -193,10 +206,6 @@ class Rational (autosuper) :
         return self + other
     # end def __radd__
 
-    def __rdiv__ (self, other) :
-        return self.__class__ (other) // self
-    # end def __rdiv__
-
     def __repr__ (self) :
         if self.q == 1 :
             return "%d" % self.p

rsclib/stateparser.py

@@ -1,5 +1,5 @@
 #!/usr/bin/python3
-# Copyright (C) 2007-21 Dr. Ralf Schlatterbeck Open Source Consulting.
+# Copyright (C) 2007-24 Dr. Ralf Schlatterbeck Open Source Consulting.
 # Reichergasse 131, A-3411 Weidling.
 # Web: http://www.runtux.com Email: office@runtux.com
 # All rights reserved
@@ -25,21 +25,21 @@ import re
 import sys
 from rsclib.autosuper    import autosuper
 from rsclib.base_pickler import Base_Pickler
-from rsclib.pycompat     import string_types
+from rsclib.pycompat     import string_types, text_type
 
 pattern_type = type (re.compile (''))
 
-class Parse_Error (ValueError) : pass
+class Parse_Error (ValueError): pass
 
-class Debug (autosuper) :
-    def debug (self, level, * msg) :
-        if self.verbose >= level :
-            print (' '.join (unicode (x) for x in msg), file = sys.stderr)
+class Debug (autosuper):
+    def debug (self, level, * msg):
+        if self.debug_level >= level:
+            print (' '.join (text_type (x) for x in msg), file = sys.stderr)
             sys.stderr.flush ()
     # end def debug
 # end class Debug
 
-class Transition (Debug) :
+class Transition (Debug):
     """ Represents one line in a state-change diagram. If matched,
         applies the defined action (if any) and returns new state.
 
@@ -50,23 +50,23 @@ class Transition (Debug) :
         Action methods get the matched line, and in case of a regex the
         matched groups as parameter.
     """
-    def __init__ (self, pattern, state, new_state, action, **kw) :
-        self.pattern   = pattern
-        self.state     = state
-        self.new_state = new_state
-        self.verbose   = kw.get ('verbose', 0)
-        self.act_name  = action
-        if action :
+    def __init__ (self, pattern, state, new_state, action, **kw):
+        self.pattern     = pattern
+        self.state       = state
+        self.new_state   = new_state
+        self.debug_level = kw.get ('debug_level', 0)
+        self.act_name    = action
+        if action:
             action = getattr (self.state.parser, action)
-        self.action    = action
+        self.action      = action
         self.__super.__init__ (**kw)
     # end def __init__
 
-    def _transition (self, match = None) :
+    def _transition (self, match = None):
         new    = None
         pstate = self.state.parser.state
         line   = self.state.parser.line
-        if self.action :
+        if self.action:
             new = self.action (self.state, self.new_state, match)
         new    = new or self.new_state
         self.debug \
@@ -77,15 +77,15 @@ class Transition (Debug) :
         return new
     # end def _transition
 
-    def match (self) :
+    def match (self):
         line = self.state.parser.line
-        if self.pattern is None or line == self.pattern :
+        if self.pattern is None or line == self.pattern:
             self.debug \
                 (2, "match: %s (act = %s)" % (self.pattern, self.act_name))
             return self._transition ()
-        if isinstance (self.pattern, pattern_type) :
+        if isinstance (self.pattern, pattern_type):
             m = self.pattern.search (line)
-            if m :
+            if m:
                 self.debug (2, "match: <regex> (act = %s)" % self.act_name)
                 return self._transition (m)
         self.debug \
@@ -98,34 +98,34 @@ class Transition (Debug) :
 
 # end class Transition
 
-class State (Debug) :
+class State (Debug):
     """ Represents a single state of the parser """
 
-    def __init__ (self, parser, name, **kw) :
+    def __init__ (self, parser, name, **kw):
         self.name        = name
         self.parser      = parser
         self.transitions = []
-        self.verbose     = kw.get ('verbose', 0)
+        self.debug_level = kw.get ('debug_level', 0)
         self.__super.__init__ (**kw)
     # end def __init__
 
-    def append (self, transition) :
+    def append (self, transition):
         self.transitions.append (transition)
     # end def append
 
-    def match (self) :
-        for t in self.transitions :
+    def match (self):
+        for t in self.transitions:
             state = t.match ()
-            if state :
+            if state:
                 return state
-        else :
+        else:
             raise Parse_Error \
                 ("%s: %s" % (self.parser.lineno, self.parser.line))
     # end def match
 
 # end class State
 
-class Parser (Debug, Base_Pickler) :
+class Parser (Debug, Base_Pickler):
     """ Simple state-machine parser.
         To use, define a subclass with the necessary actions. An action
         method gets the line matched and an optional match object.
@@ -134,55 +134,55 @@ class Parser (Debug, Base_Pickler) :
     pickle_exceptions = dict.fromkeys (('stack', 'state', 'states'))
     encoding          = 'latin1'
 
-    def __init__ (self, matrix = None, **kw) :
-        self.verbose = kw.get ('verbose', 0)
-        self.state   = None
-        self.states  = {}
+    def __init__ (self, matrix = None, **kw):
+        self.debug_level = kw.get ('debug_level', 0)
+        self.state       = None
+        self.states      = {}
         matrix = matrix or self.matrix
         self.__super.__init__ (**kw)
-        for line in matrix :
+        for line in matrix:
             self.add_transition (* line)
         self.stack   = []
     # end def __init__
 
-    def add_transition (self, statename, pattern, newname, action) :
-        if statename not in self.states :
+    def add_transition (self, statename, pattern, newname, action):
+        if statename not in self.states:
             self.states [statename] = \
-                State (self, statename, verbose = self.verbose)
+                State (self, statename, debug_level = self.debug_level)
         state = self.states [statename]
         new   = None
-        if newname :
-            if newname not in self.states :
+        if newname:
+            if newname not in self.states:
                 self.states [newname] = \
-                    State (self, newname, verbose = self.verbose)
+                    State (self, newname, debug_level = self.debug_level)
             new = self.states [newname]
-        if not self.state :
+        if not self.state:
             self.state = state
         t = Transition \
-            (pattern, state, new, action, verbose = self.verbose)
+            (pattern, state, new, action, debug_level = self.debug_level)
         state.append (t)
     # end def add_transition
 
-    def parse (self, file) :
-        for n, line in enumerate (file) :
-            if self.encoding :
+    def parse (self, file):
+        for n, line in enumerate (file):
+            if self.encoding:
                 line = line.decode (self.encoding)
             self.line   = line.rstrip ()
             self.lineno = n + 1
-            try :
+            try:
                 self.state  = self.state.match ()
-            except Exception as cause :
+            except Exception as cause:
                 #raise Parse_Error (self.lineno, cause)
                 raise
     # end def parse
 
-    def push (self, state, new_state = None, match = None) :
+    def push (self, state, new_state = None, match = None):
         self.stack.append (state)
         stack = [s.name for s in self.stack]
         self.debug (3, "push: %s, stack: %s" % (new_state.name, stack))
     # end def push
     
-    def pop (self, state = None, new_state = None, match = None) :
+    def pop (self, state = None, new_state = None, match = None):
         self.debug \
             ( 3
             , "before pop: %s" % self.state.name
@@ -201,7 +201,7 @@ class Parser (Debug, Base_Pickler) :
         return state
     # end def pop
 
-    def endpop (self, state = None, new_state = None, match = None) :
+    def endpop (self, state = None, new_state = None, match = None):
         """ Pop stack *after* handling the current line
         """
         return self.stack.pop ()