From 5f6339c93d12f773f340b2fe7b853589be8fbb20 Mon Sep 17 00:00:00 2001 From: Michael Lavers Date: Wed, 30 Nov 2022 17:41:21 -0800 Subject: [PATCH] Make Python 3.x Compatible --- bryl/__init__.py | 390 ++++++++++++++++++++++------------------------- setup.cfg | 5 + setup.py | 56 +++---- tests.py | 14 +- 4 files changed, 218 insertions(+), 247 deletions(-) create mode 100644 setup.cfg diff --git a/bryl/__init__.py b/bryl/__init__.py index 3c408ad..20f7322 100644 --- a/bryl/__init__.py +++ b/bryl/__init__.py @@ -45,45 +45,41 @@ class MyRecord(bryl.Record): """ __all__ = [ - 'ctx', - 'Field', - 'Numeric', - 'Alphanumeric', - 'Date', - 'Datetime', - 'Time', - 'Record', - 'Reader', + "ctx", + "Field", + "Numeric", + "Alphanumeric", + "Date", + "Datetime", + "Time", + "Record", + "Reader", ] -__version__ = '0.1.0' +__version__ = "0.2.0" import collections import copy import datetime import inspect +import io import itertools import os import re import string -import StringIO import threading class Context(threading.local): - class _Frame(dict): - def __getattr__(self, key): if key in self: return self[key] raise AttributeError( - '"{0}" object has no attribute "{1}"' - .format(type(self).__name__, key) + '"{0}" object has no attribute "{1}"'.format(type(self).__name__, key) ) class _Close(object): - def __init__(self, func): self.func = func @@ -94,12 +90,11 @@ def __exit__(self, type, value, traceback): self.func() def __init__(self, **defaults): - self.stack = [self._Frame( - alpha_filter=False, - alpha_truncate=False, - alpha_upper=False, - **defaults - )] + self.stack = [ + self._Frame( + alpha_filter=False, alpha_truncate=False, alpha_upper=False, **defaults + ) + ] def push(self, **kwargs): self.stack.append(self._Frame(**kwargs)) @@ -117,8 +112,7 @@ def __getattr__(self, key): if key in frame: return frame[key] raise AttributeError( - '"{0}" object has no attribute "{1}"' - .format(type(self).__name__, key) + '"{0}" object has no attribute "{1}"'.format(type(self).__name__, key) ) @@ -126,52 +120,47 @@ def __getattr__(self, key): class Field(object): - - LEFT = 'left' - RIGHT = 'right' + LEFT = "left" + RIGHT = "right" _order = itertools.count() - pad = '' - + pad = "" align = None - offset = None - default = None - pattern = None ctx = ctx - error_type = ValueError copy = [ - 'length', - 'required', - 'pad', - 'align', - ('order', '_order'), - 'name', - ('constant', '_constant'), - ('enum', '_enum'), - 'offset', - 'default', + "length", + "required", + "pad", + "align", + ("order", "_order"), + "name", + ("constant", "_constant"), + ("enum", "_enum"), + "offset", + "default", ] - def __init__(self, - length, - required=True, - pad=None, - align=None, - order=None, - name=None, - constant=None, - enum=None, - default=None, - offset=None, - ): - self._order = self._order.next() if order is None else order + def __init__( + self, + length, + required=True, + pad=None, + align=None, + order=None, + name=None, + constant=None, + enum=None, + default=None, + offset=None, + ): + self._order = next(self._order) if order is None else order self.name = name self.length = length self.required = required and (default is None) @@ -192,7 +181,7 @@ def __init__(self, self._enum = enum self.enum = None if self._enum: - for k, v in self._enum.iteritems(): + for k, v in self._enum.items(): setattr(self, k, v) self.enum = self._enum.values() self.offset = offset @@ -200,8 +189,7 @@ def __init__(self, def reserved(self): if type(self).default is None: raise TypeError( - '{0} does not have a default and so cannot be reserved' - .format(self) + "{0} does not have a default and so cannot be reserved".format(self) ) other = copy.copy(self) other._constant = type(self).default @@ -213,8 +201,8 @@ def constant(self, value): error = self.validate(value) if error: raise self.error_type( - 'Invalid {0}.constant({1}) - {2}'.format(self, value, error) - ) + "Invalid {0}.constant({1}) - {2}".format(self, value, error) + ) other._constant = value other.default = other._constant return other @@ -228,8 +216,7 @@ def __get__(self, record, record_type=None): if self.default is not None: return self.default raise LookupError( - '{0}.{1} value is missing' - .format(type(record).__name__, self.name) + "{0}.{1} value is missing".format(type(record).__name__, self.name) ) value = record[self.name] if value is None: @@ -240,32 +227,32 @@ def __set__(self, record, value): new_value = self.map(record, value) if self._constant is not None: if self._constant != value: - raise TypeError( - '{0} is constant and cannot be modified'.format(self) - ) + raise TypeError("{0} is constant and cannot be modified".format(self)) return record[self.name] = new_value def __copy__(self): kwargs = {} for k in self.copy: - if isinstance(k, basestring): + if isinstance(k, str): k = (k, k) dst, src = k kwargs[dst] = getattr(self, src) return type(self)(**kwargs) def __repr__(self, *args, **kwargs): - attrs = ', '.join([ - '{0}={1}'.format(k, repr(getattr(self, k))) - for k in ['name', 'length', 'required', 'default', 'pad', 'align'] - ]) - return '{0}({1})'.format(type(self).__name__, attrs) + attrs = ", ".join( + [ + "{0}={1}".format(k, repr(getattr(self, k))) + for k in ["name", "length", "required", "default", "pad", "align"] + ] + ) + return "{0}({1})".format(type(self).__name__, attrs) @property def value(self): if self._constant is None: - raise TypeError('Non-constant fields do not have a value') + raise TypeError("Non-constant fields do not have a value") return self._constant def fill(self, record, value): @@ -274,7 +261,7 @@ def fill(self, record, value): return record[self.name] = new_value - def map(self, record, value): + def map(self, record, value): # noqa: C901 if value is not None: try: value = self.sanitize(value) @@ -295,8 +282,9 @@ def map(self, record, value): pass if error: raise self.error_type( - 'Invalid {0}.{1} value {2} for - {3}' - .format(type(record).__name__, self.name, value, error) + "Invalid {0}.{1} value {2} for - {3}".format( + type(record).__name__, self.name, value, error + ) ) return value @@ -312,20 +300,17 @@ def error(self, value, description): def pack(self, value): error = self.validate(value) if error: - if isinstance(value, str): - value = value.decode('utf-8') raise self.error_type( - u'Invalid {0} value {1} for - {2}'.format(self, value, error) + "Invalid {0} value {1} for - {2}".format(self, value, error) ) value = self.dump(value) + value = str(value) if self.align == self.LEFT: - value = value + self.pad * (self.length - len(value)) + value = value + str(self.pad) * (self.length - len(value)) elif self.align == self.RIGHT: - value = (self.pad * (self.length - len(value))) + value + value = (str(self.pad) * (self.length - len(value))) + value else: value = self.pad * (self.length - len(value)) + value - if isinstance(value, unicode): - value = value.encode('ascii') return value def dump(self, value): @@ -333,8 +318,8 @@ def dump(self, value): def unpack(self, raw): if len(raw) < self.length: - raise self.error_type('Length must be >= {0}'.format(self.length)) - raw = raw[:self.length] + raise self.error_type("Length must be >= {0}".format(self.length)) + raw = raw[: self.length] if self.align == self.LEFT: value = raw.rstrip(self.pad) elif self.align == self.RIGHT: @@ -344,16 +329,16 @@ def unpack(self, raw): if self.pattern and not re.match(self.pattern, value): raise self.error_type( '"{0}" does not match pattern "{1}"'.format(value, self.pattern) - ) + ) try: value = self.load(value) - except self.error_type, ex: + except self.error_type as ex: value = ex if isinstance(value, Exception): - raise self.error_type('{0} - {1}'.format(self, self.error(raw, value))) + raise self.error_type("{0} - {1}".format(self, self.error(raw, value))) error = self.validate(value) if error: - raise self.error_type('{0} {1} - {2}'.format(self, value, error)) + raise self.error_type("{0} {1} - {2}".format(self, value, error)) return value def load(self, value): @@ -361,7 +346,7 @@ def load(self, value): def probe(self, io): if self.offset is None: - raise TypeError('{0}.offset is None'.format(self)) + raise TypeError("{0}.offset is None".format(self)) restore = io.tell() try: io.seek(self.offset, os.SEEK_CUR) @@ -375,76 +360,77 @@ def probe(self, io): class Numeric(Field): - pad = '0' + pad = "0" align = Field.RIGHT default = 0 min_value = 0 max_value = None copy = Field.copy + [ - 'min_value', - 'min_value', - ] + "min_value", + "min_value", + ] - def __init__(self, *args, **kwargs): - self.min_value = kwargs.pop('min_value', self.min_value) - self.max_value = kwargs.pop('max_value', self.max_value) + def __init__(self, *args, **kwargs): + self.min_value = kwargs.pop("min_value", self.min_value) + self.max_value = kwargs.pop("max_value", self.max_value) super(Numeric, self).__init__(*args, **kwargs) def load(self, raw): - if not raw or raw.strip() is '': - raw = '0' + if not raw or raw.strip() == "": + raw = "0" return int(raw) def dump(self, value): return str(value) def validate(self, value): - if isinstance(value, basestring) and re.match('\d+', value): + if isinstance(value, str) and re.match(r"\d+", value): value = int(value) - if not isinstance(value, (int, long)): - return self.error(value, 'must be a whole number') + if not isinstance(value, int): + return self.error(value, "must be a whole number") if self.enum and value not in self.enum: - return self.error(value, 'must be one of {0}, got "{1}"'.format( - self.enum, value)) + return self.error( + value, 'must be one of {0}, got "{1}"'.format(self.enum, value) + ) if len(str(value)) > self.length: - return self.error(value, 'must have length <= {0}'.format(self.length)) + return self.error(value, "must have length <= {0}".format(self.length)) if self.min_value is not None and self.min_value > value: - return self.error(value, 'must be >= {0}'.format(self.min_value)) + return self.error(value, "must be >= {0}".format(self.min_value)) if self.max_value is not None and self.max_value < value: - return self.error(value, 'must be <= {0}'.format(self.min_value)) + return self.error(value, "must be <= {0}".format(self.min_value)) if self._constant is not None and value != self._constant: - return self.error(value, 'must be constant {0}'.format(repr(self._constant))) + return self.error( + value, "must be constant {0}".format(repr(self._constant)) + ) class Alphanumeric(Field): - pad = ' ' + pad = " " align = Field.LEFT alphabet = string.printable - default = '' + default = "" def sanitize(self, value): v = value if self.ctx.alpha_filter: - v = ''.join(c for c in value if c in self.alphabet) + v = "".join(c for c in value if c in self.alphabet) if self.ctx.alpha_truncate: if len(v) > self.length: - v = v[:self.length] + v = v[: self.length] if self.ctx.alpha_upper: v = v.upper() return v def validate(self, value): - if not isinstance(value, basestring): - return self.error(value, 'must be a string') + if not isinstance(value, str): + return self.error(value, "must be a string") if self.enum and value not in self.enum: return self.error( value, 'must be one of {0}, got "{1}"'.format(self.enum, value) ) if len(value) > self.length: - return self.error( - value, 'must have length <= {0}'.format(self.length) - ) + return self.error(value, "must have length <= {0}".format(self.length)) for i, c in enumerate(value): if c not in self.alphabet: if c not in string.printable: @@ -459,34 +445,31 @@ class Datetime(Field): default = None format_re = re.compile( - 'Y{4}|Y{2}|D{3}|D{2}|M{2}|' # day - 'h{2}|H{2}|m{2}|s{2}|X{2}|Z{3}|p{2}' # time + "Y{4}|Y{2}|D{3}|D{2}|M{2}|" "h{2}|H{2}|m{2}|s{2}|X{2}|Z{3}|p{2}" # day # time ) format_spec = { # day - 'YYYY': '%Y', - 'YY': '%y', - 'DDD': '%j', - 'DD': '%d', - 'MM': '%m', - 'JJJ': '%j', - + "YYYY": "%Y", + "YY": "%y", + "DDD": "%j", + "DD": "%d", + "MM": "%m", + "JJJ": "%j", # time - 'hh': '%H', # 24 hr - 'HH': '%I', # 12 hr - 'mm': '%M', - 'ss': '%S', - 'pp': '%p', # http://stackoverflow.com/a/1759485 - 'ZZZ': '%Z', # http://stackoverflow.com/a/14763274 - } + "hh": "%H", # 24 hr + "HH": "%I", # 12 hr + "mm": "%M", + "ss": "%S", + "pp": "%p", # http://stackoverflow.com/a/1759485 + "ZZZ": "%Z", # http://stackoverflow.com/a/14763274 + } - copy = [k for k in Field.copy if k != 'length'] + ['format'] + copy = [k for k in Field.copy if k != "length"] + ["format"] - time_zones = { - } + time_zones = {} - def __init__(self, format, *args, **kwargs): + def __init__(self, format, *args, **kwargs): self.format = format super(Datetime, self).__init__(len(self.format), *args, **kwargs) self._str_format, self._tz = self._to_str_format(format) @@ -498,38 +481,36 @@ def _to_str_format(cls, format): prev = 0 for m in cls.format_re.finditer(format): if prev != m.start(): - parts.append(format[prev:m.start()]) + parts.append(format[prev : m.start()]) prev = m.end() value = m.group() - if value == 'ZZZ': + if value == "ZZZ": tz = m.start(), m.end() - m.start() continue spec = cls.format_spec[value] parts.append(spec) if prev != len(format): parts.append(format[prev:]) - return ''.join(parts), tz + return "".join(parts), tz @classmethod def _extract_tz(cls, raw, spec): offset, length = spec - tz = raw[offset:offset + length] - raw = raw[:offset] + raw[offset + length:] + tz = raw[offset : offset + length] + raw = raw[:offset] + raw[offset + length :] return raw, tz @classmethod def _insert_tz(cls, raw, tz, spec): offset, length = spec if len(tz) != length: - raise ValueError( - 'Timezone "{0}" length != {1}'.format(tz, length) - ) + raise ValueError('Timezone "{0}" length != {1}'.format(tz, length)) raw = raw[:offset] + tz + raw[offset:] return raw def validate(self, value): if not isinstance(value, datetime.datetime): - return self.error(value, 'must be a datetime') + return self.error(value, "must be a datetime") def load(self, raw): tz = None @@ -537,8 +518,9 @@ def load(self, raw): raw, tz = self._extract_tz(raw, self._tz) if tz not in self.time_zones: raise ValueError( - 'Unsupported time-zone "{0}", expected one of {1}' - .format(tz, self.time_zones.keys()) + 'Unsupported time-zone "{0}", expected one of {1}'.format( + tz, self.time_zones.keys() + ) ) tz = self.time_zones[tz] value = datetime.datetime.strptime(raw, self._str_format) @@ -555,13 +537,11 @@ def dump(self, value): class Date(Datetime): - format_re = re.compile( - 'Y{4}|Y{2}|D{3}|D{2}|M{2}|J{3}' # day - ) + format_re = re.compile("Y{4}|Y{2}|D{3}|D{2}|M{2}|J{3}") # day def validate(self, value): if not isinstance(value, datetime.date): - return self.error(value, 'must be a date') + return self.error(value, "must be a date") def load(self, raw): return datetime.datetime.strptime(raw, self._str_format).date() @@ -572,20 +552,17 @@ def dump(self, value): class Time(Datetime): - format_re = re.compile( - 'h{2}|H{2}|m{2}|s{2}|X{2}|Z{3}|p{2}' # time - ) + format_re = re.compile("h{2}|H{2}|m{2}|s{2}|X{2}|Z{3}|p{2}") # time def validate(self, value): if not isinstance(value, datetime.time): - return self.error(value, 'must be a time') + return self.error(value, "must be a time") def load(self, raw): return super(Time, self).load(raw).time() class RecordMeta(type): - def __new__(mcs, name, bases, dikt): cls = type.__new__(mcs, name, bases, dikt) @@ -595,7 +572,7 @@ def __new__(mcs, name, bases, dikt): attr.name = name # cache fields - is_field = lambda x: ( + is_field = lambda x: ( # noqa: E731 inspect.isdatadescriptor(x) and isinstance(x, Field) ) cls.fields = [ @@ -604,8 +581,9 @@ def __new__(mcs, name, bases, dikt): ] for field in cls.fields: for base in bases: - if (not hasattr(base, field.name) or - not isinstance(getattr(base, field.name), Field)): + if not hasattr(base, field.name) or not isinstance( + getattr(base, field.name), Field + ): continue field._order = getattr(base, field.name)._order cls.fields = sorted(cls.fields, key=lambda x: x._order) @@ -620,35 +598,35 @@ def __new__(mcs, name, bases, dikt): cls.length = sum(field.length for field in cls.fields) # cache default field values - cls._defaults = dict([ - (field.name, field.default) - for field in cls.fields if field.default is not None - ]) + cls._defaults = dict( + [ + (field.name, field.default) + for field in cls.fields + if field.default is not None + ] + ) return cls -class Record(dict): - - __metaclass__ = RecordMeta - +class Record(dict, metaclass=RecordMeta): field_type = Field def __init__(self, **kwargs): values = copy.copy(self._defaults) values.update(kwargs) - for k, v in values.iteritems(): + for k, v in values.items(): field = getattr(type(self), k, None) if not field or not isinstance(field, self.field_type): raise ValueError( - '{0} does not have field {1}'.format(type(self).__name__, k) + "{0} does not have field {1}".format(type(self).__name__, k) ) field.fill(self, v) @classmethod def probe(cls, io): - if isinstance(io, basestring): - io = StringIO.StringIO(io) + if isinstance(io, str): + io = io.StringIO(io) restore = io.tell() try: try: @@ -664,15 +642,14 @@ def load(cls, raw): for f in cls.fields: value = f.unpack(raw) values[f.name] = value - raw = raw[f.length:] + raw = raw[f.length :] return cls(**values) def dump(self): - return ''.join([f.pack(f.__get__(self)) for f in self.fields]) + return "".join([f.pack(f.__get__(self)) for f in self.fields]) class Malformed(ValueError): - def __init__(self, file_name, offset, reason): super(Malformed, self).__init__( "{0} @ {1} - {2}".format(file_name, offset, reason) @@ -706,13 +683,13 @@ def as_record_type(reader, data, offset): """ self.fo = fo - self.name = getattr(self.fo, 'name', '') + self.name = getattr(self.fo, "name", "") self.as_record_type = as_record_type or self.as_record_type if self.as_record_type is None: - raise TypeError('Must define as_record_type=') + raise TypeError("Must define as_record_type=") self.retry = None - def next_record(self, expected_type=None, default='raise'): + def next_record(self, expected_type=None, default="raise"): raise NotImplementedError def malformed(self, offset, reason): @@ -742,12 +719,13 @@ def as_record_type(reader, data, offset): """ - def __init__(self, - fo, - as_record_type=None, - include_terminal=False, - expected_terminal=None, - ): + def __init__( + self, + fo, + as_record_type=None, + include_terminal=False, + expected_terminal=None, + ): super(LineReader, self).__init__(fo, as_record_type) self.line_no = 1 self.include_terminal = include_terminal @@ -755,25 +733,25 @@ def __init__(self, # Reader - def next_record(self, expected_type=None, default='raise'): + def next_record(self, expected_type=None, default="raise"): line, line_no = self.next_line() if line is None: - if default == 'raise': - self.malformed(line_no, 'unexpected EOF') + if default == "raise": + self.malformed(line_no, "unexpected EOF") return default try: record = self.as_record(line, line_no) - except Malformed, ex: + except Malformed: self.retry = line, line_no raise - except self.record_type.field_type.error_type, ex: + except self.record_type.field_type.error_type as ex: self.retry = line, line_no self.malformed(line_no, str(ex)) if not isinstance(record, (expected_type or self.record_type)): self.retry = line, line_no - if default == 'raise': + if default == "raise": self.malformed( - line_no, 'unexpected record type {0}'.format(type(record)) + line_no, "unexpected record type {0}".format(type(record)) ) return return record @@ -786,16 +764,16 @@ def next(self): raise StopIteration() try: record = self.as_record(line, line_no) - except self.record_type.field_type.error_type, ex: + except self.record_type.field_type.error_type as ex: raise self.malformed(line_no, str(ex)) if not self.include_terminal: return record - record_terminal = line[type(record).length:] - if (self.expected_terminal is not None and - record_terminal != self.expected_terminal): - self.malformed( - line_no, 'unexpected EOL "{0}"'.format(record_terminal) - ) + record_terminal = line[type(record).length :] + if ( + self.expected_terminal is not None + and record_terminal != self.expected_terminal + ): + self.malformed(line_no, 'unexpected EOL "{0}"'.format(record_terminal)) return record, record_terminal # internals @@ -851,26 +829,26 @@ def __init__(self, fo, as_record_type=None, record_size=None): # Reader - def next_record(self, expected_type=None, default='raise'): + def next_record(self, expected_type=None, default="raise"): block, block_offset = self.next_block() if block is None: - if default == 'raise': - self.malformed(block_offset, 'unexpected EOF') + if default == "raise": + self.malformed(block_offset, "unexpected EOF") return default try: record = self.as_record(block, block_offset) - except Malformed, ex: + except Malformed: self.retry = block, block_offset raise - except self.record_type.field_type.error_type, ex: + except self.record_type.field_type.error_type as ex: self.retry = block, block_offset self.malformed(block_offset, str(ex)) if not isinstance(record, (expected_type or self.record_type)): self.retry = block, block_offset - if default == 'raise': + if default == "raise": self.malformed( block_offset, - 'unexpected record type {0}'.format(type(record)), + "unexpected record type {0}".format(type(record)), ) return return record @@ -883,7 +861,7 @@ def next(self): raise StopIteration() try: record = self.as_record(block, block_offset) - except self.record_type.field_type.error_type, ex: + except self.record_type.field_type.error_type as ex: raise self.malformed(block_offset, str(ex)) return record diff --git a/setup.cfg b/setup.cfg new file mode 100644 index 0000000..9bda358 --- /dev/null +++ b/setup.cfg @@ -0,0 +1,5 @@ +[flake8] +ignore = D203,E203,W503 +exclude = .git,__pycache__,build,dist,venv +max-complexity = 10 +max-line-length = 120 diff --git a/setup.py b/setup.py index ef6cdea..fccc120 100644 --- a/setup.py +++ b/setup.py @@ -3,10 +3,9 @@ class PyTest(setuptools.command.test.test): - def finalize_options(self): setuptools.command.test.test.finalize_options(self) - self.test_args = ['tests.py'] + self.test_args = ["tests.py"] self.test_suite = True def run_tests(self): @@ -15,52 +14,47 @@ def run_tests(self): pytest.main(self.test_args) -install_requires = [ -] +install_requires = [] extras_require = { - 'tests': [ - 'pytest >=2.5.2,<3', - 'pytest-cov >=1.7,<2', + "tests": [ + "pytest >=2.5.2,<3", + "pytest-cov >=1.7,<2", ], } -packages = setuptools.find_packages( - '.', exclude=('tests', 'tests.*') -) +packages = setuptools.find_packages(".", exclude=("tests", "tests.*")) setuptools.setup( - name='bryl', + name="bryl", version=( - re - .compile(r".*__version__ = '(.*?)'", re.S) - .match(open('bryl/__init__.py').read()) + re.compile(r".*__version__ = '(.*?)'", re.S) + .match(open("bryl/__init__.py").read()) .group(1) ), - url='https://github.com/balanced/bryl/', - license=open('LICENSE').read(), - author='Balanced', - author_email='dev+bryl@balancedpayments.com', - description='.', - long_description=open('README.rst').read(), + url="https://github.com/balanced/bryl/", + license=open("LICENSE").read(), + author="Balanced", + author_email="dev+bryl@balancedpayments.com", + description=".", + long_description=open("README.rst").read(), packages=packages, - package_data={'': ['LICENSE']}, + package_data={"": ["LICENSE"]}, include_package_data=True, install_requires=install_requires, extras_require=extras_require, - tests_require=extras_require['tests'], + tests_require=extras_require["tests"], cmdclass={ - 'test': PyTest, + "test": PyTest, }, classifiers=[ - 'Intended Audience :: Developers', - 'Development Status :: 4 - Beta', - 'Natural Language :: English', - 'Topic :: Software Development :: Libraries :: Python Modules', - 'License :: OSI Approved :: ISC License (ISCL)', - 'Programming Language :: Python', - 'Programming Language :: Python :: 2.6', - 'Programming Language :: Python :: 2.7', + "Intended Audience :: Developers", + "Development Status :: 4 - Beta", + "Natural Language :: English", + "Topic :: Software Development :: Libraries :: Python Modules", + "License :: OSI Approved :: ISC License (ISCL)", + "Programming Language :: Python", + "Programming Language :: Python :: 3", ], ) diff --git a/tests.py b/tests.py index b7b3966..0438898 100644 --- a/tests.py +++ b/tests.py @@ -4,28 +4,22 @@ def test_reserved(): - class Record(bryl.Record): a = bryl.Alphanumeric(length=10) b = bryl.Alphanumeric(length=15).reserved() - c = bryl.Alphanumeric(length=10, default='abc123') - + c = bryl.Alphanumeric(length=10, default="abc123") # cant't set - r1 = Record(a='hiya') + r1 = Record(a="hiya") with pytest.raises(TypeError): - r1.b = 'nonono' + r1.b = "nonono" # but will read raw = r1.dump() - mangle = ( - raw[:Record.b.offset] + - 'fuzzy'.ljust(Record.b.length) + - raw[Record.c.offset:] - ) + mangle = raw[: Record.b.offset] + "fuzzy".ljust(Record.b.length) + raw[Record.c.offset :] r2 = Record.load(mangle) # and are the same