pyfwf 1.0.0__py3-none-any.whl

pyfwf/__init__.py

@@ -0,0 +1,25 @@
+"""
+The MIT License (MIT)
+
+Copyright 2015 Umbrella Tech.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+"""
+
+
+__author__ = 'Kelson da Costa Medeiros <kelsoncm@gmail.com>'

pyfwf/columns.py

@@ -0,0 +1,216 @@
+"""
+The MIT License (MIT)
+
+Copyright 2015 Umbrella Tech.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+"""
+
+
+__author__ = 'Kelson da Costa Medeiros <kelsoncm@gmail.com>'
+
+
+import re
+from datetime import datetime, date, time
+from .hydrating import Hydrator
+
+
+class AbstractColumn(Hydrator):
+    to_str_assertion_types = None
+    to_str_assertion_class = None
+    to_str_none_pad = None
+    to_str_pad_template = None
+    hydrating_args = ['name', 'size', 'description']
+
+    def __init__(self, _name: str, size: int, description: str=None):
+        super(AbstractColumn, self).__init__()
+        assert isinstance(_name, str), 'O campo name deve ser uma string'
+        assert _name and _name.rstrip(), 'O campo column_name deve ser uma string válida e não branca'
+        assert isinstance(size, int), 'O campo size deve ser um inteiro'
+        assert size > 0, 'O campo size deve ser maior que 0'
+        if description is None:
+            description = _name
+        else:
+            assert isinstance(description, str), 'O campo description deve ser uma string'
+
+        self.name = _name
+        self.size = size
+        self.description = description
+        self.start = None
+
+    @property
+    def end(self):
+        assert isinstance(self.start, int), 'O campo start deve ser um inteiro'
+        assert self.start > 0, 'O campo start deve ser maior que 0'
+        return self.start + self.size - 1
+
+    def to_value(self, slice):
+        assert isinstance(slice, str), 'Informe uma string para converter corretamente'
+        assert len(slice) == self.size, "A string deve ter exatamente o tamanho do campo '%s' (%s)" % \
+                                        (self.name, self.size)
+        return slice
+
+    def _validate_to_str_size(self, value):
+        assert len(value) == self.size, "O valor a ser serializado para o campo '%s' não pode ser diferente de %d " \
+                                         % (self.name, self.size)
+        return value
+
+    def to_str_assertion(self, value):
+        return isinstance(value, self.to_str_assertion_class)
+
+    def to_str(self, value: str):
+        assert value is None or self.to_str_assertion(value), \
+            "O campo '%s' só aceita '%s' or 'None'" % (self.name, self.to_str_assertion_types)
+
+        if value is None:
+            return self.to_str_none_pad * self.size
+        else:
+            return self._validate_to_str_size((self.to_str_pad_template % self.size).format(value))
+
+
+class CharColumn(AbstractColumn):
+
+    to_str_assertion_types = 'str'
+    to_str_assertion_class = str
+    to_str_none_pad = ' '
+    to_str_pad_template = '{0: <%d}'
+
+    def to_value(self, slice: str):
+        return super(CharColumn, self).to_value(slice).strip()
+
+
+class RightCharColumn(CharColumn):
+    to_str_pad_template = "{0: >%d}"
+
+
+class PositiveIntegerColumn(AbstractColumn):
+    to_str_assertion_types = 'positive int'
+    to_str_assertion_class = int
+    to_str_none_pad = '0'
+    to_str_pad_template = "{0:0%dd}"
+
+    def to_str_assertion(self, value):
+        return isinstance(value, int) and not isinstance(value, bool) and value >= 0
+
+    def to_value(self, slice: str):
+        _value = int(super(PositiveIntegerColumn, self).to_value(slice))
+        assert _value >= 0, \
+            "Informe uma string para converter corretamente, '%s' não é um '%s'" % (slice, self.to_str_assertion_types)
+        return _value
+
+
+class PositiveDecimalColumn(PositiveIntegerColumn):
+    to_str_assertion_types = 'positive decimal'
+    to_str_assertion_class = float
+    hydrating_args = ['name', 'size', 'decimals', 'description']
+
+    def __init__(self, _name: str, size: int,  decimals: int=2, description: str=None):
+        super(PositiveDecimalColumn, self).__init__(_name, size, description)
+        assert isinstance(decimals, int), 'Os decimais devem ser um inteiro'
+        assert decimals > 0, 'Os decimais devem ser maior que 0'
+        assert size > decimals, 'Os decimais devem ser menores que o size'
+        self.decimals = decimals
+
+    def to_value(self, slice: str):
+        return super(PositiveDecimalColumn, self).to_value(slice) / pow(10, self.decimals)
+
+    def to_str_assertion(self, value):
+        return isinstance(value, float) and not isinstance(value, bool) and value >= 0.0
+
+    def to_str(self, value: str):
+        assert value is None or self.to_str_assertion(value), \
+            "O campo '%s' só aceita '%s' or 'None'" % (self.name, self.to_str_assertion_types)
+
+        if value is None:
+            return self.to_str_none_pad * self.size
+        else:
+            _value = int(value * pow(10, self.decimals))
+            return self._validate_to_str_size((self.to_str_pad_template % self.size).format(_value))
+
+
+class DateTimeColumn(AbstractColumn):
+    to_str_assertion_types = 'datetime'
+    to_str_assertion_class = datetime
+    to_str_none_pad = '0'
+    format_num_elements = 5
+    hydrating_args = ['name', 'format', 'description']
+
+    def __init__(self, _name: str, _format: str='%d%m%Y%H%M', description: str=None):
+        assert isinstance(_name, str), \
+            'O campo name deve ser uma string'
+        assert _name and _name.strip(), \
+            'O campo column_name deve ser uma string válida e não branca'
+        assert isinstance(_format, str), \
+            "O argumento '_format' do campo '%s' deve ser uma string" % _name
+        assert _format and _format.strip(), \
+            "O argumento '_format' do campo '%s' deve ser uma string válida e não branca" % _name
+        assert len([x for x in re.finditer(re.compile('(%[a-z,A-Z])'), _format)]) == self.format_num_elements, \
+            "O argumento '_format' (%s) do campo '%s' deve ter um formato de data/hora válido" % (_format, _name)
+
+        _size = len(datetime(2001, 12, 31, 13, 59).strftime(_format))
+
+        self.to_str_pad_templating = ''
+        super(DateTimeColumn, self).__init__(_name, _size, description)
+
+        self.format = _format
+
+    def to_value(self, slice: str):
+        _value = super(DateTimeColumn, self).to_value(slice)
+        try:
+            if _value == self.to_str_none_pad * self.size:
+                return None
+            else:
+                return datetime.strptime(_value, self.format)
+        except ValueError:
+            raise ValueError("O valor '%s' do campo '%s' é inválido para o formato '%s'" %
+                             (_value, self.name, self.format))
+
+    def to_str(self, value: datetime):
+        assert value is None or self.to_str_assertion(value), \
+            "O campo '%s' só aceita '%s' or 'None'" % (self.name, self.to_str_assertion_types)
+
+        if value is None:
+            return self.to_str_none_pad * self.size
+        else:
+            return self._validate_to_str_size(value.strftime(self.format))
+
+
+class DateColumn(DateTimeColumn):
+    to_str_assertion_types = 'date'
+    to_str_assertion_class = date
+    format_num_elements = 3
+
+    def __init__(self, _name: str, _format: str='%d%m%Y', description: str=None):
+        super(DateColumn, self).__init__(_name, _format, description)
+
+    def to_value(self, slice: str):
+        result = super(DateColumn, self).to_value(slice)
+        return result.date() if result is not None else None
+
+
+class TimeColumn(DateTimeColumn):
+    to_str_assertion_types = 'time'
+    to_str_assertion_class = time
+    format_num_elements = 2
+
+    def __init__(self, _name: str, _format: str='%H%M', description: str=None):
+        super(TimeColumn, self).__init__(_name, _format, description)
+
+    def to_value(self, slice: str):
+        result = super(TimeColumn, self).to_value(slice)
+        return result.time() if result is not None else None

pyfwf/descriptors.py

@@ -0,0 +1,111 @@
+"""
+The MIT License (MIT)
+
+Copyright 2015 Umbrella Tech.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+"""
+
+
+__author__ = 'Kelson da Costa Medeiros <kelsoncm@gmail.com>'
+
+
+from io import StringIO
+import importlib
+from typing import List, Dict
+from .columns import AbstractColumn
+from .hydrating import Hydrator
+
+
+class RowDescriptor(Hydrator):
+
+    def __init__(self, columns: List[AbstractColumn]):
+        super(RowDescriptor, self).__init__()
+        assert isinstance(columns, list), 'columns deve ser uma List'
+        assert columns != [], 'columns deve ter ao menos 1 elemento'
+        self.columns = columns
+        last = None
+        for column in columns:
+            column.start = last.end + 1 if last is not None else 1
+            last = column
+        self.validate_positions()
+
+    @property
+    def line_size(self):
+        return self.columns[len(self.columns)-1].end
+
+    def validate_positions(self):
+        prev = None
+        for col in self.columns:
+            if prev is None:
+                assert col.start == 1, 'A coluna %s deve começar com 1' % col.name
+            else:
+                assert prev.end + 1 == col.start, 'A coluna %s (starts in %d) deve começar imediatamente após ' \
+                                                  'a coluna %s (ends in %d)' % \
+                                                  (col.name, col.start, prev.name, prev.end)
+            prev = col
+
+    def get_values(self, row):
+        return {col.name: col.to_value(row[col.start-1:col.end]) for col in self.columns}
+
+
+class HeaderRowDescriptor(RowDescriptor):
+    pass
+
+
+class FooterRowDescriptor(RowDescriptor):
+    pass
+
+
+class DetailRowDescriptor(RowDescriptor):
+    pass
+
+
+class FileDescriptor(Hydrator):
+    def __init__(self,
+                 details: List[DetailRowDescriptor],
+                 header: HeaderRowDescriptor=None,
+                 footer: FooterRowDescriptor=None):
+        super(FileDescriptor, self).__init__()
+
+        assert isinstance(details, list), \
+            'details deve ser uma List'
+        assert len(details) > 0, \
+            'details deve ser uma List com ao menos 1 DetailRowDescriptor'
+        for detail in details:
+            assert isinstance(detail, DetailRowDescriptor), \
+                'details deve ser uma List de DetailRowDescriptor'
+        assert isinstance(header, HeaderRowDescriptor) or header is None, \
+            'header deve ser um HeaderRowDescriptor'
+        assert isinstance(footer, FooterRowDescriptor) or footer is None, \
+            'footer_descriptor deve ser um FooterRowDescriptor'
+
+        self.header = header
+        self.footer = footer
+        self.details = details
+        self.validate_sizes()
+        self.line_size = self.details[0].line_size
+
+    def validate_sizes(self):
+        h = self.header.line_size if self.header else 0
+        f = self.footer.line_size if self.footer else 0
+        d = self.details[0].line_size
+        ln = [x.line_size for x in self.details]
+        s = sum(ln)
+        assert (s == d * len(self.details)) and (d == h or h == 0) and (d == f or f == 0), \
+            'O tamanho das linhas header (%d), footer (%d) e das details (%s) devem ser iguais' % (h, f, ln)

pyfwf/hydrating.py

@@ -0,0 +1,100 @@
+"""
+The MIT License (MIT)
+
+Copyright 2015 Umbrella Tech.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+"""
+
+
+__author__ = 'Kelson da Costa Medeiros <kelsoncm@gmail.com>'
+
+__all__ = ['hydrate_object', 'dehydrate_object', 'Hydrator']
+
+import importlib
+from typing import Dict, List
+
+
+def get_full_class_name(instance_or_class):
+    if isinstance(instance_or_class, type):
+        return instance_or_class.__module__ + "." + instance_or_class.__qualname__
+    else:
+        return instance_or_class.__module__ + "." + instance_or_class.__class__.__qualname__
+
+
+def create_class(full_class_name, *args, **kwargs):
+    module_name, class_name = full_class_name.rsplit(".", 1)
+    MyClass = getattr(importlib.import_module(module_name), class_name)
+    return MyClass(*args, **kwargs)
+
+
+def assert_element_isinstance(name, lst, cls):
+    if name in lst:
+        assert isinstance(lst[name], cls), '%s has informed, but is not a %s' % (name, cls)
+
+
+def assert_isinstance(name, value, cls):
+    assert isinstance(value, cls), '%s is not a %s' % (name, cls)
+
+
+def hydrate_object(representation: Dict):
+    assert_isinstance('representation', representation, Dict)
+    assert '_hydrate_as' in representation, '_hydrate_as is required'
+    assert_element_isinstance('_hydrate_as', representation, str)
+    assert_element_isinstance('args', representation, List)
+    assert_element_isinstance('kwargs', representation, Dict)
+    assert_element_isinstance('attributes', representation, Dict)
+
+    def hydrate_if_hydratable(o):
+        return hydrate_object(o) if isinstance(o, Dict) and '_hydrate_as' in o else o
+
+    hydrate_as = representation['_hydrate_as']
+    args = [hydrate_if_hydratable(arg)
+            for arg in (representation['args'] if 'args' in representation else [])]
+    kwargs = {k: hydrate_if_hydratable(v)
+              for k, v in (representation['kwargs'] if 'kwargs' in representation else {}).items()}
+    attributes = representation['attributes'] if 'attributes' in representation else {}
+
+    instance = create_class(hydrate_as, *args, **kwargs)
+    for attr_name in attributes.keys():
+        setattr(instance, attr_name, attributes[attr_name])
+    return instance
+
+
+def dehydrate_object(obj):
+    def dehydrate_if_hydratable(o):
+        return dehydrate_object(o) if isinstance(o, Hydrator) else o
+
+    result = {"_hydrate_as": get_full_class_name(obj)}
+    if hasattr(obj, 'hydrating_args'):
+        result["args"] = [dehydrate_if_hydratable(getattr(obj, name)) for name in obj.hydrating_args]
+    if hasattr(obj, 'hydrating_kwargs'):
+        result["kwargs"] = {name: dehydrate_if_hydratable(getattr(obj, name)) for name in obj.hydrating_kwargs}
+    if hasattr(obj, 'hydrating_attributes'):
+        result["attributes"] = {name: dehydrate_if_hydratable(getattr(obj, name)) for name in obj.hydrating_attributes}
+    return result
+
+
+class Hydrator(object):
+
+    def dehydrate(self):
+        return dehydrate_object(self)
+
+    @classmethod
+    def hydrate(cls, representation: Dict):
+        return hydrate_object(representation)

pyfwf/readers.py

@@ -0,0 +1,86 @@
+"""
+The MIT License (MIT)
+
+Copyright 2015 Umbrella Tech.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+"""
+
+
+__author__ = 'Kelson da Costa Medeiros <kelsoncm@gmail.com>'
+
+
+from typing import Iterable, List
+from io import StringIO, TextIOWrapper
+from .descriptors import FileDescriptor
+from collections import abc
+
+
+__all__ = ['Reader']
+
+
+class Reader:
+
+    def __init__(self, _iterable: Iterable[str], file_descriptor: FileDescriptor, newline: str="\n\r"):
+        assert isinstance(_iterable, abc.Iterable), \
+            'O argumento _iterable tem que ser um Iterator'
+        assert isinstance(file_descriptor, FileDescriptor), \
+            'O argumento file_descriptor tem que ser um FileDescriptor'
+        assert isinstance(newline, str) and newline in ["\n", "\r", "\n\r"], \
+            'O argumento newline tem que ser uma str e conter "\\n", "\\r" ou "\\n\\r"'
+
+        self.iterable = _iterable
+        self.file_descriptor = file_descriptor
+        self.line_num = 0
+        self.newline = newline
+        self.lines_count = 0
+
+        if isinstance(self.iterable, StringIO):
+            self.filesize = len(self.iterable.getvalue())
+        elif isinstance(self.iterable, TextIOWrapper):
+            self.filesize = len(self.iterable.read())
+        elif isinstance(self.iterable, str):
+            self.filesize = len(self.iterable)
+            self.iterable = StringIO(self.iterable)
+        elif isinstance(self.iterable, List):
+            self.iterable = iter(_iterable)
+            self.lines_count = len(_iterable)
+            self.filesize = sum([len(r) for r in _iterable])
+        else:
+            raise TypeError('Unsupported Iterable')
+
+        assert float(self.filesize) % float(self.file_descriptor.line_size + len(self.newline)) == 0, \
+            "Algumas linha não tem o tamanho correto (%d) ou não tem a quebra de linha adequada (%s), " \
+            "total de bytes %d e total de linhas %f" % \
+            (self.file_descriptor.line_size, self.newline.replace("\n", "\\n").replace("\r", "\\r"),
+             self.filesize, float(self.filesize) / float(self.file_descriptor.line_size + len(self.newline)))
+        self.lines_count = self.filesize / (self.file_descriptor.line_size + len(self.newline))
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        row = next(self.iterable)
+        self.line_num += 1
+        lc = row[:-len(self.newline)]
+        if self.file_descriptor.header and self.line_num == 1:
+            return self.file_descriptor.header.get_values(lc)
+        elif self.file_descriptor.footer and self.lines_count and self.lines_count == self.line_num:
+            return self.file_descriptor.footer.get_values(lc)
+        else:
+            return self.file_descriptor.details[0].get_values(lc)

pyfwf/renders.py

@@ -0,0 +1,69 @@
+"""
+The MIT License (MIT)
+
+Copyright 2015 Umbrella Tech.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+"""
+
+
+__author__ = 'Kelson da Costa Medeiros <kelsoncm@gmail.com>'
+
+
+from io import StringIO
+import importlib
+from typing import List, Dict
+from .columns import AbstractColumn
+from .descriptors import FileDescriptor
+
+
+def render_as_markdown(file_descriptor: FileDescriptor, out: StringIO):
+    def table_header(title, max_colname_size, max_coltype_size):
+        out.write(("# {title}\n\n" 
+                   "|    # | {name:<%d} | Size | Start |  End | {type:<%d} | Description\n" 
+                   "| ---- | {sep:-<%d} | ---- | ----- | ---- | {sep:-<%d} | -----------\n" %
+                   (max_colname_size, max_coltype_size, max_colname_size, max_coltype_size)).
+                  format(title=title, name='Column', type='Type', sep='-'))
+
+    def table_body(cols, max_colname_size, max_coltype_size):
+        line = 0
+        template = "| {0:>4d} | {1: <%d} | {2:>4d} | {3:>5d} | {4:>4d} | {5:<%d} | {6}\n" \
+                   % (max_colname_size, max_coltype_size)
+        for col in cols:
+            line += 1
+            out.write(template.format(line, col.name, col.size, col.start, col.end, col.__class__.__name__,
+                                      col.description))
+
+    def table(title, cols, trailling=True):
+        max_colname_size = max([len(col.name) for col in cols])
+        max_coltype_size = max([len(col.__class__.__name__) for col in cols])
+        table_header(title, max_colname_size, max_coltype_size)
+        table_body(cols, max_colname_size, max_coltype_size)
+        if trailling:
+            out.write("\n\n")
+
+    if file_descriptor.header:
+        table("HEADER", file_descriptor.header.columns)
+
+    detail_num = 1
+    for detail in file_descriptor.details:
+        table("DETAILS %s" % detail_num, detail.columns)
+        detail_num += 1
+
+    if file_descriptor.footer:
+        table("FOOTER", file_descriptor.footer.columns, False)

pyfwf-1.0.0.dist-info/METADATA

@@ -0,0 +1,121 @@
+Metadata-Version: 2.4
+Name: pyfwf
+Version: 1.0.0
+Summary: Python library to manipulate fixed width file (FWF)
+Author: kelsoncm
+License: The MIT License (MIT)
+        
+        Copyright (c) 2016 kelsoncm
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+        
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-cov>=5.0; extra == "dev"
+Requires-Dist: responses>=0.25; extra == "dev"
+Requires-Dist: black>=24.0; extra == "dev"
+Requires-Dist: ruff>=0.4; extra == "dev"
+Requires-Dist: pre-commit>=3.7; extra == "dev"
+Requires-Dist: python-dotenv>=1.0; extra == "dev"
+Dynamic: license-file
+
+# Python FWF
+
+[![PyPI Version](https://img.shields.io/pypi/v/python-fwf)](https://pypi.org/project/python-fwf/)
+[![Python CI and PyPI Deploy](https://github.com/kelsoncm/python-fwf/actions/workflows/publish.yml/badge.svg)](https://github.com/kelsoncm/python-fwf/actions/workflows/publish.yml)
+[![Python Versions](https://img.shields.io/pypi/pyversions/python-fwf.svg)](https://pypi.org/project/python-fwf/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Tests](https://github.com/kelsoncm/python-fwf/actions/workflows/test.yml/badge.svg)](https://github.com/kelsoncm/python-fwf/actions/workflows/test.yml)
+[![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit)](https://github.com/pre-commit/pre-commit)
+[![Coverage](https://codecov.io/gh/kelsoncm/python-fwf/branch/main/graph/badge.svg)](https://codecov.io/gh/kelsoncm/python-fwf)
+
+
+Python library for reading and manipulating **fixed-width files (FWF)**.
+
+## Features
+
+- 📖 Read fixed-width format files with custom column definitions
+- 🔧 Support for typed columns (integer, decimal, date, time, etc.)
+- 📋 Header and footer row handling
+- 🎯 Simple and intuitive API
+- ✅ Fully tested (100% coverage)
+
+## Installation
+
+```bash
+pip install pyfwf
+```
+
+## Quick Start
+
+```python
+from pyfwf.columns import CharColumn, PositiveIntegerColumn
+from pyfwf.descriptors import DetailRowDescriptor, FileDescriptor
+from pyfwf.readers import Reader
+
+# Define columns
+detail = DetailRowDescriptor([
+    CharColumn(name='name', pos=1, size=20),
+    PositiveIntegerColumn(name='age', pos=21, size=3),
+])
+
+# Create file descriptor
+fd = FileDescriptor(line_size=23, details=[detail])
+
+# Read file
+with open('data.fwf', 'r') as f:
+    reader = Reader(f, fd)
+    for row in reader:
+        print(row)
+```
+
+## Supported Column Types
+
+- `CharColumn` - Text data
+- `RightCharColumn` - Right-aligned text
+- `PositiveIntegerColumn` - Positive integers
+- `PositiveDecimalColumn` - Decimal numbers
+- `DateColumn` - Date values
+- `TimeColumn` - Time values
+- `DateTimeColumn` - DateTime values
+
+## Documentation
+
+See [docs/](docs/) for detailed documentation and examples.
+
+## License
+
+MIT License © 2015 Umbrella Tech
+
+## Author
+
+Kelson da Costa Medeiros <kelsoncm@gmail.com>

pyfwf-1.0.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+pyfwf/__init__.py,sha256=Wb7sizlpkPQHXq2zf7grp-9YY7Mxram7EoOcR2FEmnk,1148
+pyfwf/columns.py,sha256=gE7oyil_l3NP8KQPLIsgDQkpKCSnP-VIpSsr3jTKjcI,8638
+pyfwf/descriptors.py,sha256=ysVGsnoI-LJGnvsL4OKSIqFp8-lm0LtW-I_CjssXJX0,4185
+pyfwf/hydrating.py,sha256=jjltdWoagfgyYK7U5Q7TKko1H2NMj2Jq-P_hJWQFmfY,4023
+pyfwf/readers.py,sha256=u-Yg4u7ZsHPOz4jx5aH_gUi3SFBtpEHfMt8o_H425Sc,3755
+pyfwf/renders.py,sha256=276NHTihjJtHgEjT4_pvjj502y1JiGuYorsYr1xIvHc,2961
+pyfwf-1.0.0.dist-info/licenses/LICENSE.md,sha256=Ua0hpApaWay1AcvGvjg3fwF8oPX4wS8Qp8s8qN6VOcc,1076
+pyfwf-1.0.0.dist-info/METADATA,sha256=YuuQxjdhMebbGDGcpYgPyiFLvB5K0u3TAdgGt7l_RmM,4607
+pyfwf-1.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+pyfwf-1.0.0.dist-info/top_level.txt,sha256=S1Nj1uO3Wl86B1rCeozK6iBwnp7c4c7IwiUEBQ551pc,6
+pyfwf-1.0.0.dist-info/RECORD,,

pyfwf-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pyfwf-1.0.0.dist-info/licenses/LICENSE.md

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 kelsoncm
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

pyfwf-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pyfwf