From a76ecd4ef0bd7fa2dbe2e02d5b5721b39ead18c0 Mon Sep 17 00:00:00 2001 From: Elias Dorneles Date: Thu, 8 Oct 2015 22:18:14 -0300 Subject: [PATCH 01/16] remove test_exporters from py3 ignores --- tests/py3-ignores.txt | 1 - 1 file changed, 1 deletion(-) diff --git a/tests/py3-ignores.txt b/tests/py3-ignores.txt index f189a4c86..570287d9d 100644 --- a/tests/py3-ignores.txt +++ b/tests/py3-ignores.txt @@ -1,4 +1,3 @@ -tests/test_exporters.py tests/test_linkextractors_deprecated.py tests/test_mail.py tests/test_pipeline_files.py From b6ef1f19fd768243407206a882d689764624b42c Mon Sep 17 00:00:00 2001 From: Elias Dorneles Date: Fri, 9 Oct 2015 00:19:05 -0300 Subject: [PATCH 02/16] make BaseItemExporter export unicode, pushed down previous behavior for classes that need it --- scrapy/exporters.py | 15 +++++++------ tests/test_exporters.py | 48 ++++++++++++++++++++++++++++++++++++++--- 2 files changed, 53 insertions(+), 10 deletions(-) diff --git a/scrapy/exporters.py b/scrapy/exporters.py index 7e1d01a0a..6f679480d 100644 --- a/scrapy/exporters.py +++ b/scrapy/exporters.py @@ -38,7 +38,7 @@ class BaseItemExporter(object): raise NotImplementedError def serialize_field(self, field, name, value): - serializer = field.get('serializer', self._to_str_if_unicode) + serializer = field.get('serializer', lambda x: x) return serializer(value) def start_exporting(self): @@ -47,9 +47,6 @@ class BaseItemExporter(object): def finish_exporting(self): pass - def _to_str_if_unicode(self, value): - return value.encode(self.encoding) if isinstance(value, unicode) else value - def _get_serialized_fields(self, item, default_value=None, include_empty=None): """Return the fields to export as an iterable of tuples (name, serialized_value) @@ -89,7 +86,7 @@ class JsonLinesItemExporter(BaseItemExporter): self.file.write(self.encoder.encode(itemdict) + '\n') -class JsonItemExporter(JsonLinesItemExporter): +class JsonItemExporter(BaseItemExporter): def __init__(self, file, **kwargs): self._configure(kwargs, dont_fail=True) @@ -170,13 +167,17 @@ class CsvItemExporter(BaseItemExporter): self._headers_not_written = True self._join_multivalued = join_multivalued + def serialize_field(self, field, name, value): + serializer = field.get('serializer', self._to_str_if_unicode) + return serializer(value) + def _to_str_if_unicode(self, value): if isinstance(value, (list, tuple)): try: value = self._join_multivalued.join(value) except TypeError: # list in value may not contain strings pass - return super(CsvItemExporter, self)._to_str_if_unicode(value) + return value.encode(self.encoding) if isinstance(value, unicode) else value def export_item(self, item): if self._headers_not_written: @@ -251,7 +252,7 @@ class PythonItemExporter(BaseItemExporter): return dict(self._serialize_dict(value)) if hasattr(value, '__iter__'): return [self._serialize_value(v) for v in value] - return self._to_str_if_unicode(value) + return value.encode(self.encoding) if isinstance(value, unicode) else value def _serialize_dict(self, value): for key, val in six.iteritems(value): diff --git a/tests/test_exporters.py b/tests/test_exporters.py index b24633959..c84fb978a 100644 --- a/tests/test_exporters.py +++ b/tests/test_exporters.py @@ -23,7 +23,7 @@ class TestItem(Item): class BaseItemExporterTest(unittest.TestCase): def setUp(self): - self.i = TestItem(name=u'John\xa3', age='22') + self.i = TestItem(name=u'John\xa3', age=u'22') self.output = BytesIO() self.ie = self._get_exporter() @@ -55,6 +55,42 @@ class BaseItemExporterTest(unittest.TestCase): self.assertItemExportWorks(dict(self.i)) def test_serialize_field(self): + res = self.ie.serialize_field(self.i.fields['name'], 'name', self.i['name']) + self.assertEqual(res, u'John\xa3') + + res = self.ie.serialize_field(self.i.fields['age'], 'age', self.i['age']) + self.assertEqual(res, u'22') + + def test_fields_to_export(self): + ie = self._get_exporter(fields_to_export=['name']) + self.assertEqual(list(ie._get_serialized_fields(self.i)), [('name', u'John\xa3')]) + + def test_field_custom_serializer(self): + def custom_serializer(value): + return str(int(value) + 2) + + class CustomFieldItem(Item): + name = Field() + age = Field(serializer=custom_serializer) + + i = CustomFieldItem(name=u'John\xa3', age=u'22') + + ie = self._get_exporter() + self.assertEqual(ie.serialize_field(i.fields['name'], 'name', i['name']), u'John\xa3') + self.assertEqual(ie.serialize_field(i.fields['age'], 'age', i['age']), '24') + + +class MidRefactoringBaseItemExporterTest(BaseItemExporterTest): + """Class introduced just to keep old behavior of BaseItemExporterTest for the + test cases that inherit from it while we make changes to exporters one by + one -- a needed refactoring trick because the test cases are quite coupled. + + When we're done with the changes, we'll have ditched this class. + """ + def test_serialize_field(self): + if self.ie.__class__ is BaseItemExporter: + return + res = self.ie.serialize_field(self.i.fields['name'], 'name', self.i['name']) self.assertEqual(res, 'John\xc2\xa3') @@ -62,6 +98,9 @@ class BaseItemExporterTest(unittest.TestCase): self.assertEqual(res, '22') def test_fields_to_export(self): + if self.ie.__class__ is BaseItemExporter: + return + ie = self._get_exporter(fields_to_export=['name']) self.assertEqual(list(ie._get_serialized_fields(self.i)), [('name', 'John\xc2\xa3')]) @@ -71,6 +110,9 @@ class BaseItemExporterTest(unittest.TestCase): self.assertEqual(name, 'John\xa3') def test_field_custom_serializer(self): + if self.ie.__class__ is BaseItemExporter: + return + def custom_serializer(value): return str(int(value) + 2) @@ -85,7 +127,7 @@ class BaseItemExporterTest(unittest.TestCase): self.assertEqual(ie.serialize_field(i.fields['age'], 'age', i['age']), '24') -class PythonItemExporterTest(BaseItemExporterTest): +class PythonItemExporterTest(MidRefactoringBaseItemExporterTest): def _get_exporter(self, **kwargs): return PythonItemExporter(**kwargs) @@ -152,7 +194,7 @@ class PickleItemExporterTest(BaseItemExporterTest): self.assertEqual(pickle.load(f), i2) -class CsvItemExporterTest(BaseItemExporterTest): +class CsvItemExporterTest(MidRefactoringBaseItemExporterTest): def _get_exporter(self, **kwargs): return CsvItemExporter(self.output, **kwargs) From c76190d491fca9f35b6758bdc06c34d77f5d9be9 Mon Sep 17 00:00:00 2001 From: Elias Dorneles Date: Thu, 21 Jan 2016 18:24:06 -0200 Subject: [PATCH 03/16] PY3: ported json(lines), xml exporters --- scrapy/exporters.py | 39 +++++++++++++++------- tests/test_exporters.py | 72 +++++++++++++++++++++-------------------- 2 files changed, 64 insertions(+), 47 deletions(-) diff --git a/scrapy/exporters.py b/scrapy/exporters.py index 6f679480d..4138f6192 100644 --- a/scrapy/exporters.py +++ b/scrapy/exporters.py @@ -11,7 +11,10 @@ from six.moves import cPickle as pickle from xml.sax.saxutils import XMLGenerator from scrapy.utils.serialize import ScrapyJSONEncoder +from scrapy.utils.python import to_bytes, to_unicode from scrapy.item import BaseItem +import warnings + __all__ = ['BaseItemExporter', 'PprintItemExporter', 'PickleItemExporter', 'CsvItemExporter', 'XmlItemExporter', 'JsonLinesItemExporter', @@ -83,7 +86,7 @@ class JsonLinesItemExporter(BaseItemExporter): def export_item(self, item): itemdict = dict(self._get_serialized_fields(item)) - self.file.write(self.encoder.encode(itemdict) + '\n') + self.file.write(to_bytes(self.encoder.encode(itemdict) + '\n')) class JsonItemExporter(BaseItemExporter): @@ -95,18 +98,18 @@ class JsonItemExporter(BaseItemExporter): self.first_item = True def start_exporting(self): - self.file.write("[") + self.file.write(b"[") def finish_exporting(self): - self.file.write("]") + self.file.write(b"]") def export_item(self, item): if self.first_item: self.first_item = False else: - self.file.write(',\n') + self.file.write(b',\n') itemdict = dict(self._get_serialized_fields(item)) - self.file.write(self.encoder.encode(itemdict)) + self.file.write(to_bytes(self.encoder.encode(itemdict))) class XmlItemExporter(BaseItemExporter): @@ -136,8 +139,9 @@ class XmlItemExporter(BaseItemExporter): if hasattr(serialized_value, 'items'): for subname, value in serialized_value.items(): self._export_xml_field(subname, value) - elif hasattr(serialized_value, '__iter__'): - for value in serialized_value: + elif (hasattr(serialized_value, '__iter__') + and not isinstance(serialized_value, six.string_types)): + for value in serialized_value: self._export_xml_field('value', value) else: self._xg_characters(serialized_value) @@ -150,7 +154,7 @@ class XmlItemExporter(BaseItemExporter): # and Python 3.x will require unicode, so ">= 2.7.4" should be fine. if sys.version_info[:3] >= (2, 7, 4): def _xg_characters(self, serialized_value): - if not isinstance(serialized_value, unicode): + if not isinstance(serialized_value, six.text_type): serialized_value = serialized_value.decode(self.encoding) return self.xg.characters(serialized_value) else: @@ -177,7 +181,7 @@ class CsvItemExporter(BaseItemExporter): value = self._join_multivalued.join(value) except TypeError: # list in value may not contain strings pass - return value.encode(self.encoding) if isinstance(value, unicode) else value + return value.encode(self.encoding) if isinstance(value, six.text_type) else value def export_item(self, item): if self._headers_not_written: @@ -231,7 +235,7 @@ class PprintItemExporter(BaseItemExporter): def export_item(self, item): itemdict = dict(self._get_serialized_fields(item)) - self.file.write(pprint.pformat(itemdict) + '\n') + self.file.write(to_bytes(pprint.pformat(itemdict) + '\n')) class PythonItemExporter(BaseItemExporter): @@ -240,6 +244,13 @@ class PythonItemExporter(BaseItemExporter): json, msgpack, binc, etc) can be used on top of it. Its main goal is to seamless support what BaseItemExporter does plus nested items. """ + def _configure(self, options, dont_fail=False): + self.binary = options.pop('binary', True) + super(PythonItemExporter, self)._configure(options, dont_fail) + if self.binary: + warnings.warn( + "PythonItemExporter will drop support for binary export in the future", + PendingDeprecationWarning) def serialize_field(self, field, name, value): serializer = field.get('serializer', self._serialize_value) @@ -250,9 +261,13 @@ class PythonItemExporter(BaseItemExporter): return self.export_item(value) if isinstance(value, dict): return dict(self._serialize_dict(value)) - if hasattr(value, '__iter__'): + if hasattr(value, '__iter__') \ + and not isinstance(value, six.string_types): return [self._serialize_value(v) for v in value] - return value.encode(self.encoding) if isinstance(value, unicode) else value + if self.binary: + return to_bytes(value, encoding=self.encoding) + else: + return to_unicode(value, encoding=self.encoding) def _serialize_dict(self, value): for key, val in six.iteritems(value): diff --git a/tests/test_exporters.py b/tests/test_exporters.py index c84fb978a..05374e617 100644 --- a/tests/test_exporters.py +++ b/tests/test_exporters.py @@ -3,6 +3,7 @@ import re import json import unittest from io import BytesIO +import six from six.moves import cPickle as pickle import lxml.etree @@ -80,7 +81,7 @@ class BaseItemExporterTest(unittest.TestCase): self.assertEqual(ie.serialize_field(i.fields['age'], 'age', i['age']), '24') -class MidRefactoringBaseItemExporterTest(BaseItemExporterTest): +class IntermediateRefactoringBaseItemExporterTest(BaseItemExporterTest): """Class introduced just to keep old behavior of BaseItemExporterTest for the test cases that inherit from it while we make changes to exporters one by one -- a needed refactoring trick because the test cases are quite coupled. @@ -127,9 +128,9 @@ class MidRefactoringBaseItemExporterTest(BaseItemExporterTest): self.assertEqual(ie.serialize_field(i.fields['age'], 'age', i['age']), '24') -class PythonItemExporterTest(MidRefactoringBaseItemExporterTest): +class PythonItemExporterTest(BaseItemExporterTest): def _get_exporter(self, **kwargs): - return PythonItemExporter(**kwargs) + return PythonItemExporter(binary=False, **kwargs) def test_nested_item(self): i1 = TestItem(name=u'Joseph', age='22') @@ -194,7 +195,8 @@ class PickleItemExporterTest(BaseItemExporterTest): self.assertEqual(pickle.load(f), i2) -class CsvItemExporterTest(MidRefactoringBaseItemExporterTest): +@unittest.skipUnless(six.PY2, "TODO") +class CsvItemExporterTest(IntermediateRefactoringBaseItemExporterTest): def _get_exporter(self, **kwargs): return CsvItemExporter(self.output, **kwargs) @@ -294,13 +296,13 @@ class XmlItemExporterTest(BaseItemExporterTest): self.assertXmlEquivalent(fp.getvalue(), expected_value) def _check_output(self): - expected_value = '\n22John\xc2\xa3' + expected_value = u'\n22John\xa3' self.assertXmlEquivalent(self.output.getvalue(), expected_value) def test_multivalued_fields(self): self.assertExportResult( TestItem(name=[u'John\xa3', u'Doe']), - '\nJohn\xc2\xa3Doe' + u'\nJohn\xa3Doe' ) def test_nested_item(self): @@ -309,19 +311,19 @@ class XmlItemExporterTest(BaseItemExporterTest): i3 = TestItem(name=u'buz', age=i2) self.assertExportResult(i3, - '\n' - '' - '' - '' - '' - '22' - 'foo\xc2\xa3hoo' - '' - 'bar' - '' - 'buz' - '' - '' + u'\n' + u'' + u'' + u'' + u'' + u'22' + u'foo\xa3hoo' + u'' + u'bar' + u'' + u'buz' + u'' + u'' ) def test_nested_list_item(self): @@ -330,16 +332,16 @@ class XmlItemExporterTest(BaseItemExporterTest): i3 = TestItem(name=u'buz', age=[i1, i2]) self.assertExportResult(i3, - '\n' - '' - '' - '' - 'foo' - 'barspam' - '' - 'buz' - '' - '' + u'\n' + u'' + u'' + u'' + u'foo' + u'barspam' + u'' + u'buz' + u'' + u'' ) @@ -351,7 +353,7 @@ class JsonLinesItemExporterTest(BaseItemExporterTest): return JsonLinesItemExporter(self.output, **kwargs) def _check_output(self): - exported = json.loads(self.output.getvalue().strip()) + exported = json.loads(to_unicode(self.output.getvalue().strip())) self.assertEqual(exported, dict(self.i)) def test_nested_item(self): @@ -361,7 +363,7 @@ class JsonLinesItemExporterTest(BaseItemExporterTest): self.ie.start_exporting() self.ie.export_item(i3) self.ie.finish_exporting() - exported = json.loads(self.output.getvalue()) + exported = json.loads(to_unicode(self.output.getvalue())) self.assertEqual(exported, self._expected_nested) def test_extra_keywords(self): @@ -379,7 +381,7 @@ class JsonItemExporterTest(JsonLinesItemExporterTest): return JsonItemExporter(self.output, **kwargs) def _check_output(self): - exported = json.loads(self.output.getvalue().strip()) + exported = json.loads(to_unicode(self.output.getvalue().strip())) self.assertEqual(exported, [dict(self.i)]) def assertTwoItemsExported(self, item): @@ -387,7 +389,7 @@ class JsonItemExporterTest(JsonLinesItemExporterTest): self.ie.export_item(item) self.ie.export_item(item) self.ie.finish_exporting() - exported = json.loads(self.output.getvalue()) + exported = json.loads(to_unicode(self.output.getvalue())) self.assertEqual(exported, [dict(item), dict(item)]) def test_two_items(self): @@ -403,7 +405,7 @@ class JsonItemExporterTest(JsonLinesItemExporterTest): self.ie.start_exporting() self.ie.export_item(i3) self.ie.finish_exporting() - exported = json.loads(self.output.getvalue()) + exported = json.loads(to_unicode(self.output.getvalue())) expected = {'name': u'Jesus', 'age': {'name': 'Maria', 'age': dict(i1)}} self.assertEqual(exported, [expected]) @@ -414,7 +416,7 @@ class JsonItemExporterTest(JsonLinesItemExporterTest): self.ie.start_exporting() self.ie.export_item(i3) self.ie.finish_exporting() - exported = json.loads(self.output.getvalue()) + exported = json.loads(to_unicode(self.output.getvalue())) expected = {'name': u'Jesus', 'age': {'name': 'Maria', 'age': i1}} self.assertEqual(exported, [expected]) From fed7c8b4fca3bb2722eebca97b298b0316ebfbc2 Mon Sep 17 00:00:00 2001 From: Elias Dorneles Date: Thu, 21 Jan 2016 18:39:59 -0200 Subject: [PATCH 04/16] fix: use is_listlike --- scrapy/exporters.py | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-) diff --git a/scrapy/exporters.py b/scrapy/exporters.py index 4138f6192..ad14f38b3 100644 --- a/scrapy/exporters.py +++ b/scrapy/exporters.py @@ -11,7 +11,7 @@ from six.moves import cPickle as pickle from xml.sax.saxutils import XMLGenerator from scrapy.utils.serialize import ScrapyJSONEncoder -from scrapy.utils.python import to_bytes, to_unicode +from scrapy.utils.python import to_bytes, to_unicode, is_listlike from scrapy.item import BaseItem import warnings @@ -139,8 +139,7 @@ class XmlItemExporter(BaseItemExporter): if hasattr(serialized_value, 'items'): for subname, value in serialized_value.items(): self._export_xml_field(subname, value) - elif (hasattr(serialized_value, '__iter__') - and not isinstance(serialized_value, six.string_types)): + elif is_listlike(serialized_value): for value in serialized_value: self._export_xml_field('value', value) else: @@ -261,8 +260,7 @@ class PythonItemExporter(BaseItemExporter): return self.export_item(value) if isinstance(value, dict): return dict(self._serialize_dict(value)) - if hasattr(value, '__iter__') \ - and not isinstance(value, six.string_types): + if is_listlike(value): return [self._serialize_value(v) for v in value] if self.binary: return to_bytes(value, encoding=self.encoding) From 9f35c286431584e07f9a53b1b2e7b7822a18f7e1 Mon Sep 17 00:00:00 2001 From: Elias Dorneles Date: Thu, 21 Jan 2016 18:43:36 -0200 Subject: [PATCH 05/16] fix indentation --- scrapy/exporters.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/scrapy/exporters.py b/scrapy/exporters.py index ad14f38b3..c029ac473 100644 --- a/scrapy/exporters.py +++ b/scrapy/exporters.py @@ -140,7 +140,7 @@ class XmlItemExporter(BaseItemExporter): for subname, value in serialized_value.items(): self._export_xml_field(subname, value) elif is_listlike(serialized_value): - for value in serialized_value: + for value in serialized_value: self._export_xml_field('value', value) else: self._xg_characters(serialized_value) From b746d85f4ca11f7f0149d06f7a4b58501ad3ee23 Mon Sep 17 00:00:00 2001 From: Elias Dorneles Date: Thu, 21 Jan 2016 21:12:43 -0200 Subject: [PATCH 06/16] PY3 port csv exporter --- scrapy/exporters.py | 17 ++++++----- tests/test_exporters.py | 67 ++++++----------------------------------- 2 files changed, 20 insertions(+), 64 deletions(-) diff --git a/scrapy/exporters.py b/scrapy/exporters.py index c029ac473..8d7ffbc71 100644 --- a/scrapy/exporters.py +++ b/scrapy/exporters.py @@ -3,6 +3,7 @@ Item Exporters are used to export/serialize items into different formats. """ import csv +import io import sys import pprint import marshal @@ -11,7 +12,7 @@ from six.moves import cPickle as pickle from xml.sax.saxutils import XMLGenerator from scrapy.utils.serialize import ScrapyJSONEncoder -from scrapy.utils.python import to_bytes, to_unicode, is_listlike +from scrapy.utils.python import to_bytes, to_unicode, to_native_str, is_listlike from scrapy.item import BaseItem import warnings @@ -166,21 +167,22 @@ class CsvItemExporter(BaseItemExporter): def __init__(self, file, include_headers_line=True, join_multivalued=',', **kwargs): self._configure(kwargs, dont_fail=True) self.include_headers_line = include_headers_line + file = file if six.PY2 else io.TextIOWrapper(file, line_buffering=True) self.csv_writer = csv.writer(file, **kwargs) self._headers_not_written = True self._join_multivalued = join_multivalued def serialize_field(self, field, name, value): - serializer = field.get('serializer', self._to_str_if_unicode) + serializer = field.get('serializer', self._join_if_needed) return serializer(value) - def _to_str_if_unicode(self, value): + def _join_if_needed(self, value): if isinstance(value, (list, tuple)): try: - value = self._join_multivalued.join(value) + return self._join_multivalued.join(value) except TypeError: # list in value may not contain strings pass - return value.encode(self.encoding) if isinstance(value, six.text_type) else value + return value def export_item(self, item): if self._headers_not_written: @@ -189,7 +191,7 @@ class CsvItemExporter(BaseItemExporter): fields = self._get_serialized_fields(item, default_value='', include_empty=True) - values = [x[1] for x in fields] + values = [to_native_str(x) for _, x in fields] self.csv_writer.writerow(values) def _write_headers_and_set_fields_to_export(self, item): @@ -201,7 +203,8 @@ class CsvItemExporter(BaseItemExporter): else: # use fields declared in Item self.fields_to_export = list(item.fields.keys()) - self.csv_writer.writerow(self.fields_to_export) + row = [to_native_str(s) for s in self.fields_to_export] + self.csv_writer.writerow(row) class PickleItemExporter(BaseItemExporter): diff --git a/tests/test_exporters.py b/tests/test_exporters.py index 05374e617..39e996062 100644 --- a/tests/test_exporters.py +++ b/tests/test_exporters.py @@ -3,7 +3,6 @@ import re import json import unittest from io import BytesIO -import six from six.moves import cPickle as pickle import lxml.etree @@ -81,53 +80,6 @@ class BaseItemExporterTest(unittest.TestCase): self.assertEqual(ie.serialize_field(i.fields['age'], 'age', i['age']), '24') -class IntermediateRefactoringBaseItemExporterTest(BaseItemExporterTest): - """Class introduced just to keep old behavior of BaseItemExporterTest for the - test cases that inherit from it while we make changes to exporters one by - one -- a needed refactoring trick because the test cases are quite coupled. - - When we're done with the changes, we'll have ditched this class. - """ - def test_serialize_field(self): - if self.ie.__class__ is BaseItemExporter: - return - - res = self.ie.serialize_field(self.i.fields['name'], 'name', self.i['name']) - self.assertEqual(res, 'John\xc2\xa3') - - res = self.ie.serialize_field(self.i.fields['age'], 'age', self.i['age']) - self.assertEqual(res, '22') - - def test_fields_to_export(self): - if self.ie.__class__ is BaseItemExporter: - return - - ie = self._get_exporter(fields_to_export=['name']) - self.assertEqual(list(ie._get_serialized_fields(self.i)), [('name', 'John\xc2\xa3')]) - - ie = self._get_exporter(fields_to_export=['name'], encoding='latin-1') - name = list(ie._get_serialized_fields(self.i))[0][1] - assert isinstance(name, str) - self.assertEqual(name, 'John\xa3') - - def test_field_custom_serializer(self): - if self.ie.__class__ is BaseItemExporter: - return - - def custom_serializer(value): - return str(int(value) + 2) - - class CustomFieldItem(Item): - name = Field() - age = Field(serializer=custom_serializer) - - i = CustomFieldItem(name=u'John\xa3', age='22') - - ie = self._get_exporter() - self.assertEqual(ie.serialize_field(i.fields['name'], 'name', i['name']), 'John\xc2\xa3') - self.assertEqual(ie.serialize_field(i.fields['age'], 'age', i['age']), '24') - - class PythonItemExporterTest(BaseItemExporterTest): def _get_exporter(self, **kwargs): return PythonItemExporter(binary=False, **kwargs) @@ -195,19 +147,19 @@ class PickleItemExporterTest(BaseItemExporterTest): self.assertEqual(pickle.load(f), i2) -@unittest.skipUnless(six.PY2, "TODO") -class CsvItemExporterTest(IntermediateRefactoringBaseItemExporterTest): - +class CsvItemExporterTest(BaseItemExporterTest): def _get_exporter(self, **kwargs): return CsvItemExporter(self.output, **kwargs) def assertCsvEqual(self, first, second, msg=None): + first = to_unicode(first) + second = to_unicode(second) csvsplit = lambda csv: [sorted(re.split(r'(,|\s+)', line)) for line in csv.splitlines(True)] return self.assertEqual(csvsplit(first), csvsplit(second), msg) def _check_output(self): - self.assertCsvEqual(self.output.getvalue(), 'age,name\r\n22,John\xc2\xa3\r\n') + self.assertCsvEqual(to_unicode(self.output.getvalue()), u'age,name\r\n22,John\xa3\r\n') def assertExportResult(self, item, expected, **kwargs): fp = BytesIO() @@ -221,13 +173,13 @@ class CsvItemExporterTest(IntermediateRefactoringBaseItemExporterTest): self.assertExportResult( item=self.i, fields_to_export=self.i.fields.keys(), - expected='age,name\r\n22,John\xc2\xa3\r\n', + expected=b'age,name\r\n22,John\xc2\xa3\r\n', ) def test_header_export_all_dict(self): self.assertExportResult( item=dict(self.i), - expected='age,name\r\n22,John\xc2\xa3\r\n', + expected=b'age,name\r\n22,John\xc2\xa3\r\n', ) def test_header_export_single_field(self): @@ -235,7 +187,7 @@ class CsvItemExporterTest(IntermediateRefactoringBaseItemExporterTest): self.assertExportResult( item=item, fields_to_export=['age'], - expected='age\r\n22\r\n', + expected=b'age\r\n22\r\n', ) def test_header_export_two_items(self): @@ -246,14 +198,15 @@ class CsvItemExporterTest(IntermediateRefactoringBaseItemExporterTest): ie.export_item(item) ie.export_item(item) ie.finish_exporting() - self.assertCsvEqual(output.getvalue(), 'age,name\r\n22,John\xc2\xa3\r\n22,John\xc2\xa3\r\n') + self.assertCsvEqual(output.getvalue(), + b'age,name\r\n22,John\xc2\xa3\r\n22,John\xc2\xa3\r\n') def test_header_no_header_line(self): for item in [self.i, dict(self.i)]: self.assertExportResult( item=item, include_headers_line=False, - expected='22,John\xc2\xa3\r\n', + expected=b'22,John\xc2\xa3\r\n', ) def test_join_multivalue(self): From 2514973242e35831fd90493b3db17227c3c0195e Mon Sep 17 00:00:00 2001 From: Elias Dorneles Date: Thu, 21 Jan 2016 21:22:12 -0200 Subject: [PATCH 07/16] re-enable skipped feed export tests --- tests/test_feedexport.py | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/tests/test_feedexport.py b/tests/test_feedexport.py index d6c96ca74..8e1cadc74 100644 --- a/tests/test_feedexport.py +++ b/tests/test_feedexport.py @@ -22,6 +22,7 @@ from scrapy.extensions.feedexport import ( S3FeedStorage, StdoutFeedStorage ) from scrapy.utils.test import assert_aws_environ +from scrapy.utils.python import to_native_str class FileFeedStorageTest(unittest.TestCase): @@ -120,8 +121,6 @@ class StdoutFeedStorageTest(unittest.TestCase): class FeedExportTest(unittest.TestCase): - skip = not six.PY2 - class MyItem(scrapy.Item): foo = scrapy.Field() egg = scrapy.Field() @@ -170,7 +169,7 @@ class FeedExportTest(unittest.TestCase): settings.update({'FEED_FORMAT': 'csv'}) data = yield self.exported_data(items, settings) - reader = csv.DictReader(data.splitlines()) + reader = csv.DictReader(to_native_str(data).splitlines()) got_rows = list(reader) if ordered: self.assertEqual(reader.fieldnames, header) @@ -184,7 +183,7 @@ class FeedExportTest(unittest.TestCase): settings = settings or {} settings.update({'FEED_FORMAT': 'jl'}) data = yield self.exported_data(items, settings) - parsed = [json.loads(line) for line in data.splitlines()] + parsed = [json.loads(to_native_str(line)) for line in data.splitlines()] rows = [{k: v for k, v in row.items() if v} for row in rows] self.assertEqual(rows, parsed) From e938752973b4fc53e0fa0c0bc68a431613b987e4 Mon Sep 17 00:00:00 2001 From: Elias Dorneles Date: Thu, 21 Jan 2016 21:51:59 -0200 Subject: [PATCH 08/16] add test for PythonItemExporter binary mode --- scrapy/exporters.py | 6 +++++- tests/test_exporters.py | 7 +++++++ 2 files changed, 12 insertions(+), 1 deletion(-) diff --git a/scrapy/exporters.py b/scrapy/exporters.py index 8d7ffbc71..118df34a7 100644 --- a/scrapy/exporters.py +++ b/scrapy/exporters.py @@ -272,7 +272,11 @@ class PythonItemExporter(BaseItemExporter): def _serialize_dict(self, value): for key, val in six.iteritems(value): + key = to_bytes(key) if self.binary else key yield key, self._serialize_value(val) def export_item(self, item): - return dict(self._get_serialized_fields(item)) + result = dict(self._get_serialized_fields(item)) + if self.binary: + result = dict(self._serialize_dict(result)) + return result diff --git a/tests/test_exporters.py b/tests/test_exporters.py index 39e996062..9e57745dc 100644 --- a/tests/test_exporters.py +++ b/tests/test_exporters.py @@ -2,6 +2,7 @@ from __future__ import absolute_import import re import json import unittest +import warnings from io import BytesIO from six.moves import cPickle as pickle @@ -115,6 +116,12 @@ class PythonItemExporterTest(BaseItemExporterTest): self.assertEqual(type(exported['age'][0]), dict) self.assertEqual(type(exported['age'][0]['age'][0]), dict) + def test_export_binary(self): + exporter = PythonItemExporter(binary=True) + value = TestItem(name=u'John\xa3', age=u'22') + expected = {b'name': b'John\xc2\xa3', b'age': b'22'} + self.assertEqual(expected, exporter.export_item(value)) + class PprintItemExporterTest(BaseItemExporterTest): From d0955fd08320f8402303bb4424e7dfab384068f4 Mon Sep 17 00:00:00 2001 From: Elias Dorneles Date: Fri, 22 Jan 2016 10:07:55 -0200 Subject: [PATCH 09/16] add back test for latin-1 encoding --- tests/test_exporters.py | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/tests/test_exporters.py b/tests/test_exporters.py index 9e57745dc..070624830 100644 --- a/tests/test_exporters.py +++ b/tests/test_exporters.py @@ -2,11 +2,11 @@ from __future__ import absolute_import import re import json import unittest -import warnings from io import BytesIO from six.moves import cPickle as pickle import lxml.etree +import six from scrapy.item import Item, Field from scrapy.utils.python import to_unicode @@ -66,6 +66,11 @@ class BaseItemExporterTest(unittest.TestCase): ie = self._get_exporter(fields_to_export=['name']) self.assertEqual(list(ie._get_serialized_fields(self.i)), [('name', u'John\xa3')]) + ie = self._get_exporter(fields_to_export=['name'], encoding='latin-1') + _, name = list(ie._get_serialized_fields(self.i))[0] + assert isinstance(name, six.text_type) + self.assertEqual(name, u'John\xa3') + def test_field_custom_serializer(self): def custom_serializer(value): return str(int(value) + 2) From c75f1fe46a8a2a3c471eeef2c023754ee5e6c2f1 Mon Sep 17 00:00:00 2001 From: Elias Dorneles Date: Sat, 23 Jan 2016 16:09:57 -0200 Subject: [PATCH 10/16] restore bytes instead of text, for easier reviewing --- tests/test_exporters.py | 50 ++++++++++++++++++++--------------------- 1 file changed, 25 insertions(+), 25 deletions(-) diff --git a/tests/test_exporters.py b/tests/test_exporters.py index 070624830..00352f61e 100644 --- a/tests/test_exporters.py +++ b/tests/test_exporters.py @@ -261,13 +261,13 @@ class XmlItemExporterTest(BaseItemExporterTest): self.assertXmlEquivalent(fp.getvalue(), expected_value) def _check_output(self): - expected_value = u'\n22John\xa3' + expected_value = b'\n22John\xc2\xa3' self.assertXmlEquivalent(self.output.getvalue(), expected_value) def test_multivalued_fields(self): self.assertExportResult( TestItem(name=[u'John\xa3', u'Doe']), - u'\nJohn\xa3Doe' + b'\nJohn\xc2\xa3Doe' ) def test_nested_item(self): @@ -276,19 +276,19 @@ class XmlItemExporterTest(BaseItemExporterTest): i3 = TestItem(name=u'buz', age=i2) self.assertExportResult(i3, - u'\n' - u'' - u'' - u'' - u'' - u'22' - u'foo\xa3hoo' - u'' - u'bar' - u'' - u'buz' - u'' - u'' + b'\n' + b'' + b'' + b'' + b'' + b'22' + b'foo\xc2\xa3hoo' + b'' + b'bar' + b'' + b'buz' + b'' + b'' ) def test_nested_list_item(self): @@ -297,16 +297,16 @@ class XmlItemExporterTest(BaseItemExporterTest): i3 = TestItem(name=u'buz', age=[i1, i2]) self.assertExportResult(i3, - u'\n' - u'' - u'' - u'' - u'foo' - u'barspam' - u'' - u'buz' - u'' - u'' + b'\n' + b'' + b'' + b'' + b'foo' + b'barspam' + b'' + b'buz' + b'' + b'' ) From 935b1da8c2d1d801f4d7d9ce8f498c1d7a527644 Mon Sep 17 00:00:00 2001 From: Elias Dorneles Date: Sat, 23 Jan 2016 16:13:42 -0200 Subject: [PATCH 11/16] uses ScrapyDeprecationWarning instead of silenced PendingDeprecationWarning --- scrapy/exporters.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/scrapy/exporters.py b/scrapy/exporters.py index 118df34a7..fa6663ed4 100644 --- a/scrapy/exporters.py +++ b/scrapy/exporters.py @@ -14,6 +14,7 @@ from xml.sax.saxutils import XMLGenerator from scrapy.utils.serialize import ScrapyJSONEncoder from scrapy.utils.python import to_bytes, to_unicode, to_native_str, is_listlike from scrapy.item import BaseItem +from scrapy.exceptions import ScrapyDeprecationWarning import warnings @@ -252,7 +253,7 @@ class PythonItemExporter(BaseItemExporter): if self.binary: warnings.warn( "PythonItemExporter will drop support for binary export in the future", - PendingDeprecationWarning) + ScrapyDeprecationWarning) def serialize_field(self, field, name, value): serializer = field.get('serializer', self._serialize_value) From 9fbe6f3e814578f90f206031ae99a344b842e400 Mon Sep 17 00:00:00 2001 From: Elias Dorneles Date: Sat, 23 Jan 2016 17:17:40 -0200 Subject: [PATCH 12/16] added feedexport test for xml output --- tests/test_feedexport.py | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-) diff --git a/tests/test_feedexport.py b/tests/test_feedexport.py index 8e1cadc74..8db9d589e 100644 --- a/tests/test_feedexport.py +++ b/tests/test_feedexport.py @@ -5,7 +5,6 @@ import json from io import BytesIO import tempfile import shutil -import six from six.moves.urllib.parse import urlparse from zope.interface.verify import verifyObject @@ -187,10 +186,22 @@ class FeedExportTest(unittest.TestCase): rows = [{k: v for k, v in row.items() if v} for row in rows] self.assertEqual(rows, parsed) + @defer.inlineCallbacks + def assertExportedXml(self, items, rows, settings=None): + settings = settings or {} + settings.update({'FEED_FORMAT': 'xml'}) + data = yield self.exported_data(items, settings) + rows = [{k: v for k, v in row.items() if v} for row in rows] + import lxml.etree + root = lxml.etree.fromstring(data) + got_rows = [{e.tag: e.text for e in it} for it in root.findall('item')] + self.assertEqual(rows, got_rows) + @defer.inlineCallbacks def assertExported(self, items, header, rows, settings=None, ordered=True): yield self.assertExportedCsv(items, header, rows, settings, ordered) yield self.assertExportedJsonLines(items, rows, settings) + yield self.assertExportedXml(items, rows, settings) @defer.inlineCallbacks def test_export_items(self): From 0c44fac2b54e72202787fda9d221f62a234151d4 Mon Sep 17 00:00:00 2001 From: Elias Dorneles Date: Sun, 24 Jan 2016 19:17:42 -0200 Subject: [PATCH 13/16] added tests for feed export marshal and pickle --- tests/test_feedexport.py | 31 +++++++++++++++++++++++++++++++ 1 file changed, 31 insertions(+) diff --git a/tests/test_feedexport.py b/tests/test_feedexport.py index 8db9d589e..176fd93e3 100644 --- a/tests/test_feedexport.py +++ b/tests/test_feedexport.py @@ -197,11 +197,42 @@ class FeedExportTest(unittest.TestCase): got_rows = [{e.tag: e.text for e in it} for it in root.findall('item')] self.assertEqual(rows, got_rows) + def _load_until_eof(self, data, load_func): + bytes_output = BytesIO(data) + result = [] + while True: + try: + result.append(load_func(bytes_output)) + except EOFError: + break + return result + + @defer.inlineCallbacks + def assertExportedPickle(self, items, rows, settings=None): + settings = settings or {} + settings.update({'FEED_FORMAT': 'pickle'}) + data = yield self.exported_data(items, settings) + expected = [{k: v for k, v in row.items() if v} for row in rows] + import pickle + result = self._load_until_eof(data, load_func=pickle.load) + self.assertEqual(expected, result) + + @defer.inlineCallbacks + def assertExportedMarshal(self, items, rows, settings=None): + settings = settings or {} + settings.update({'FEED_FORMAT': 'marshal'}) + data = yield self.exported_data(items, settings) + expected = [{k: v for k, v in row.items() if v} for row in rows] + import marshal + result = self._load_until_eof(data, load_func=marshal.load) + self.assertEqual(expected, result) + @defer.inlineCallbacks def assertExported(self, items, header, rows, settings=None, ordered=True): yield self.assertExportedCsv(items, header, rows, settings, ordered) yield self.assertExportedJsonLines(items, rows, settings) yield self.assertExportedXml(items, rows, settings) + yield self.assertExportedPickle(items, rows, settings) @defer.inlineCallbacks def test_export_items(self): From 23b3336c1feb3acb603a935f11e442557d6434f4 Mon Sep 17 00:00:00 2001 From: Elias Dorneles Date: Mon, 25 Jan 2016 22:11:04 -0200 Subject: [PATCH 14/16] add test for invalid option --- tests/test_exporters.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/tests/test_exporters.py b/tests/test_exporters.py index 00352f61e..61a0229a4 100644 --- a/tests/test_exporters.py +++ b/tests/test_exporters.py @@ -90,6 +90,10 @@ class PythonItemExporterTest(BaseItemExporterTest): def _get_exporter(self, **kwargs): return PythonItemExporter(binary=False, **kwargs) + def test_invalid_option(self): + with self.assertRaisesRegexp(TypeError, "Unexpected options: invalid_option"): + PythonItemExporter(invalid_option='something') + def test_nested_item(self): i1 = TestItem(name=u'Joseph', age='22') i2 = dict(name=u'Maria', age=i1) From 2dfdde3c79a5be468302a1e825cc5ad77444a8ac Mon Sep 17 00:00:00 2001 From: Elias Dorneles Date: Mon, 25 Jan 2016 22:24:35 -0200 Subject: [PATCH 15/16] fallback to repr when can't convert to native string --- scrapy/exporters.py | 11 +++++++++-- tests/test_exporters.py | 7 +++++++ 2 files changed, 16 insertions(+), 2 deletions(-) diff --git a/scrapy/exporters.py b/scrapy/exporters.py index fa6663ed4..69c180ea4 100644 --- a/scrapy/exporters.py +++ b/scrapy/exporters.py @@ -192,9 +192,16 @@ class CsvItemExporter(BaseItemExporter): fields = self._get_serialized_fields(item, default_value='', include_empty=True) - values = [to_native_str(x) for _, x in fields] + values = list(self._build_row(x for _, x in fields)) self.csv_writer.writerow(values) + def _build_row(self, values): + for s in values: + try: + yield to_native_str(s) + except TypeError: + yield to_native_str(repr(s)) + def _write_headers_and_set_fields_to_export(self, item): if self.include_headers_line: if not self.fields_to_export: @@ -204,7 +211,7 @@ class CsvItemExporter(BaseItemExporter): else: # use fields declared in Item self.fields_to_export = list(item.fields.keys()) - row = [to_native_str(s) for s in self.fields_to_export] + row = list(self._build_row(self.fields_to_export)) self.csv_writer.writerow(row) diff --git a/tests/test_exporters.py b/tests/test_exporters.py index 61a0229a4..8930545a6 100644 --- a/tests/test_exporters.py +++ b/tests/test_exporters.py @@ -237,6 +237,13 @@ class CsvItemExporterTest(BaseItemExporterTest): expected='"Mary,Paul",John\r\n', ) + def test_join_multivalue_not_strings(self): + self.assertExportResult( + item=dict(name='John', friends=[4, 8]), + include_headers_line=False, + expected='"[4, 8]",John\r\n', + ) + class XmlItemExporterTest(BaseItemExporterTest): From d0eacfe0f90263035f98beb8fe6b5a8f182d5a1d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Daniel=20Gra=C3=B1a?= Date: Tue, 26 Jan 2016 00:26:27 -0300 Subject: [PATCH 16/16] Add test case for marshal item exporter --- scrapy/exporters.py | 2 +- tests/test_exporters.py | 16 +++++++++++++++- 2 files changed, 16 insertions(+), 2 deletions(-) diff --git a/scrapy/exporters.py b/scrapy/exporters.py index 69c180ea4..145468dbe 100644 --- a/scrapy/exporters.py +++ b/scrapy/exporters.py @@ -158,7 +158,7 @@ class XmlItemExporter(BaseItemExporter): if not isinstance(serialized_value, six.text_type): serialized_value = serialized_value.decode(self.encoding) return self.xg.characters(serialized_value) - else: + else: # pragma: no cover def _xg_characters(self, serialized_value): return self.xg.characters(serialized_value) diff --git a/tests/test_exporters.py b/tests/test_exporters.py index 8930545a6..1633e1039 100644 --- a/tests/test_exporters.py +++ b/tests/test_exporters.py @@ -1,6 +1,8 @@ from __future__ import absolute_import import re import json +import marshal +import tempfile import unittest from io import BytesIO from six.moves import cPickle as pickle @@ -12,7 +14,8 @@ from scrapy.item import Item, Field from scrapy.utils.python import to_unicode from scrapy.exporters import ( BaseItemExporter, PprintItemExporter, PickleItemExporter, CsvItemExporter, - XmlItemExporter, JsonLinesItemExporter, JsonItemExporter, PythonItemExporter + XmlItemExporter, JsonLinesItemExporter, JsonItemExporter, + PythonItemExporter, MarshalItemExporter ) @@ -163,6 +166,17 @@ class PickleItemExporterTest(BaseItemExporterTest): self.assertEqual(pickle.load(f), i2) +class MarshalItemExporterTest(BaseItemExporterTest): + + def _get_exporter(self, **kwargs): + self.output = tempfile.TemporaryFile() + return MarshalItemExporter(self.output, **kwargs) + + def _check_output(self): + self.output.seek(0) + self._assert_expected_item(marshal.load(self.output)) + + class CsvItemExporterTest(BaseItemExporterTest): def _get_exporter(self, **kwargs): return CsvItemExporter(self.output, **kwargs)