Esempio n. 1
0
    patterns = ['^P2D_(\d{4})_(\d{4})_(\d{4})(\d{2})(\d{2}).(\d)']
    encoding = "iso-8859-15"
    delimiter = ';'

    def __init__(self, strict=False):
        self.adapter = P2Adapter(strict=strict)
        self.schema = P1Schema(strict=strict)
        self.fields = []
        self.headers = []
        for f in sorted(
                self.schema.fields,
                key=lambda f: self.schema.fields[f].metadata['position']):
            field = self.schema.fields[f]
            self.fields.append((f, field.metadata))
            self.headers.append(f)

    def parse_line(self, line):
        slinia = tuple(
            unicode(line.decode(self.encoding)).split(self.delimiter))
        slinia = map(lambda s: s.strip(), slinia)
        parsed = {'p1': {}, 'orig': line}
        data = build_dict(self.headers, slinia)
        result, errors = self.adapter.load(data)
        if errors:
            logger.error(errors)
        parsed['p1'] = result
        return parsed, errors


register(P2D)
Esempio n. 2
0
    ]
    encoding = "iso-8859-15"
    delimiter = ';'

    def __init__(self, strict=False):
        self.adapter = P1Adapter(strict=strict)
        self.schema = P1Schema(strict=strict)
        self.fields = []
        self.headers = []
        for f in sorted(
                self.schema.fields,
                key=lambda f: self.schema.fields[f].metadata['position']):
            field = self.schema.fields[f]
            self.fields.append((f, field.metadata))
            self.headers.append(f)

    def parse_line(self, line):
        slinia = tuple(
            unicode(line.decode(self.encoding)).split(self.delimiter))
        slinia = map(lambda s: s.strip(), slinia)
        parsed = {'p1': {}, 'orig': line}
        data = build_dict(self.headers, slinia)
        result, errors = self.adapter.load(data)
        if errors:
            logger.error(errors)
        parsed['p1'] = result
        return parsed, errors


register(P1)
Esempio n. 3
0
class B5d(Parser):

    patterns = ['^B5D_(\d+)_(\d{4})_(\d{4})(\d{2})(\d{2})']
    encoding = "iso-8859-15"
    delimiter = ';'

    def __init__(self, strict=False):
        self.adapter = B5dAdapter(strict=strict)
        self.schema = CchGenNetaBetaSchema(strict=strict)
        self.fields = []
        self.headers = []
        for f in sorted(self.schema.fields, key=lambda f: self.schema.fields[f].metadata['position']):
            field = self.schema.fields[f]
            self.fields.append((f, field.metadata))
            self.headers.append(f)

    def parse_line(self, line):
        slinia = tuple(unicode(line.decode(self.encoding)).split(self.delimiter))
        slinia = map(lambda s: s.strip(), slinia)
        parsed = {'cchfact': {}, 'orig': line}
        data = build_dict(self.headers, slinia)
        result, errors = self.adapter.load(data)
        if errors:
            logger.error(errors)
        parsed['cchfact'] = result
        return parsed, errors


register(B5d)
Esempio n. 4
0
    patterns = ['^A5D_(\d+)_(\d{4})_(\d{4})(\d{2})(\d{2})']
    encoding = "iso-8859-15"
    delimiter = ';'

    def __init__(self, strict=False):
        self.adapter = A5dAdapter(strict=strict)
        self.schema = CchAutoconsSchema(strict=strict)
        self.fields = []
        self.headers = []
        for f in sorted(
                self.schema.fields,
                key=lambda f: self.schema.fields[f].metadata['position']):
            field = self.schema.fields[f]
            self.fields.append((f, field.metadata))
            self.headers.append(f)

    def parse_line(self, line):
        slinia = tuple(
            unicode(line.decode(self.encoding)).split(self.delimiter))
        slinia = map(lambda s: s.strip(), slinia)
        parsed = {'cchfact': {}, 'orig': line}
        data = build_dict(self.headers, slinia)
        result, errors = self.adapter.load(data)
        if errors:
            logger.error(errors)
        parsed['cchfact'] = result
        return parsed, errors


register(A5d)
Esempio n. 5
0
class P1D(Parser):

    patterns = ['^P1D_(\d{4})_(\d{4})_(\d{4})(\d{2})(\d{2}).(\d)']
    encoding = "iso-8859-15"
    delimiter = ';'

    def __init__(self, strict=False):
        self.adapter = P1Adapter(strict=strict)
        self.schema = P1Schema(strict=strict)
        self.fields = []
        self.headers = []
        for f in sorted(self.schema.fields,
                key=lambda f: self.schema.fields[f].metadata['position']):
            field = self.schema.fields[f]
            self.fields.append((f, field.metadata))
            self.headers.append(f)

    def parse_line(self, line):
        slinia = tuple(unicode(line.decode(self.encoding)).split(self.delimiter))
        slinia = map(lambda s: s.strip(), slinia)
        parsed = {'p1': {}, 'orig': line}
        data = build_dict(self.headers, slinia)
        result, errors = self.adapter.load(data)
        if errors:
            logger.error(errors)
        parsed['p1'] = result
        return parsed, errors


register(P1D)
Esempio n. 6
0
    pattern = '^P5D_(\d+)_0762_(\d{4})(\d{2})(\d{2})'
    encoding = "iso-8859-15"
    delimiter = ';'

    def __init__(self, strict=False):
        self.adapter = P5dAdapter(strict=strict)
        self.schema = CchValSchema(strict=strict)
        self.fields = []
        self.headers = []
        for f in sorted(
                self.schema.fields,
                key=lambda f: self.schema.fields[f].metadata['position']):
            field = self.schema.fields[f]
            self.fields.append((f, field.metadata))
            self.headers.append(f)

    def parse_line(self, line):
        slinia = tuple(
            unicode(line.decode(self.encoding)).split(self.delimiter))
        slinia = map(lambda s: s.strip(), slinia)
        parsed = {'cchval': {}, 'orig': line}
        data = build_dict(self.headers, slinia)
        result, errors = self.adapter.load(data)
        if errors:
            logger.error(errors)
        parsed['cchval'] = result
        return parsed, errors


register(P5d)
Esempio n. 7
0
    patterns = ['^F5D_(\d+)_(\d{4})_(\d{4})(\d{2})(\d{2})']
    encoding = "iso-8859-15"
    delimiter = ';'

    def __init__(self, strict=False):
        self.adapter = F5dAdapter(strict=strict)
        self.schema = CchFactSchema(strict=strict)
        self.fields = []
        self.headers = []
        for f in sorted(
                self.schema.fields,
                key=lambda f: self.schema.fields[f].metadata['position']):
            field = self.schema.fields[f]
            self.fields.append((f, field.metadata))
            self.headers.append(f)

    def parse_line(self, line):
        slinia = tuple(
            unicode(line.decode(self.encoding)).split(self.delimiter))
        slinia = map(lambda s: s.strip(), slinia)
        parsed = {'cchfact': {}, 'orig': line}
        data = build_dict(self.headers, slinia)
        result, errors = self.adapter.load(data)
        if errors:
            logger.error(errors)
        parsed['cchfact'] = result
        return parsed, errors


register(F5d)
Esempio n. 8
0
    ]
    encoding = "iso-8859-15"
    delimiter = ';'

    def __init__(self, strict=False):
        self.adapter = P2Adapter(strict=strict)
        self.schema = P1Schema(strict=strict)
        self.fields = []
        self.headers = []
        for f in sorted(
                self.schema.fields,
                key=lambda f: self.schema.fields[f].metadata['position']):
            field = self.schema.fields[f]
            self.fields.append((f, field.metadata))
            self.headers.append(f)

    def parse_line(self, line):
        slinia = tuple(
            unicode(line.decode(self.encoding)).split(self.delimiter))
        slinia = map(lambda s: s.strip(), slinia)
        parsed = {'p1': {}, 'orig': line}
        data = build_dict(self.headers, slinia)
        result, errors = self.adapter.load(data)
        if errors:
            logger.error(errors)
        parsed['p1'] = result
        return parsed, errors


register(P2)
Esempio n. 9
0
    encoding = "iso-8859-15"
    delimiter = ';'

    def __init__(self, strict=False):
        self.adapter = F1Adapter(strict=strict)
        self.schema = F1Schema(strict=strict)
        self.fields = []
        self.headers = []
        for f in sorted(
                self.schema.fields,
                key=lambda f: self.schema.fields[f].metadata['position']):
            field = self.schema.fields[f]
            self.fields.append((f, field.metadata))
            self.headers.append(f)

    def parse_line(self, line):
        slinia = tuple(
            unicode(line.decode(self.encoding)).split(self.delimiter))
        slinia = map(lambda s: s.strip(), slinia)
        parsed = {'f1': {}, 'orig': line}
        data = build_dict(self.headers, slinia)
        result, errors = self.adapter.load(data)
        if errors:

            logger.error(errors)
        parsed['f1'] = result
        return parsed, errors


register(F1)
Esempio n. 10
0
class F5d(Parser):

    pattern = '^F5D_(\d+)_0762_(\d{4})(\d{2})(\d{2})'
    encoding = "iso-8859-15"
    delimiter = ';'

    def __init__(self, strict=False):
        self.adapter =F5dAdapter(strict=strict)
        self.schema = CchFactSchema(strict=strict)
        self.fields = []
        self.headers = []
        for f in sorted(self.schema.fields,
                key=lambda f: self.schema.fields[f].metadata['position']):
            field = self.schema.fields[f]
            self.fields.append((f, field.metadata))
            self.headers.append(f)

    def parse_line(self, line):
        slinia = tuple(unicode(line.decode(self.encoding)).split(self.delimiter))
        slinia = map(lambda s: s.strip(), slinia)
        parsed = {'cchfact': {}, 'orig': line}
        data = build_dict(self.headers, slinia)
        result, errors = self.adapter.load(data)
        if errors:
            logger.error(errors)
        parsed['cchfact'] = result
        return parsed, errors


register(F5d)
Esempio n. 11
0
class P5d(Parser):

    pattern = "^P5D_(\d+)_0762_(\d{4})(\d{2})(\d{2})"
    encoding = "iso-8859-15"
    delimiter = ";"

    def __init__(self, strict=False):
        self.adapter = P5dAdapter(strict=strict)
        self.schema = CchValSchema(strict=strict)
        self.fields = []
        self.headers = []
        for f in sorted(self.schema.fields, key=lambda f: self.schema.fields[f].metadata["position"]):
            field = self.schema.fields[f]
            self.fields.append((f, field.metadata))
            self.headers.append(f)

    def parse_line(self, line):
        slinia = tuple(unicode(line.decode(self.encoding)).split(self.delimiter))
        slinia = map(lambda s: s.strip(), slinia)
        parsed = {"cchval": {}, "orig": line}
        data = build_dict(self.headers, slinia)
        result, errors = self.adapter.load(data)
        if errors:
            logger.error(errors)
        parsed["cchval"] = result
        return parsed, errors


register(P5d)