Пример #1
0
def platform2pymarc_obj(data=None):
    """
    converts platform bib data into pymarc object
    args:
        data in json format
    return:
        pymarc Record obj
    """
    record = Record(to_unicode=True, force_utf8=True)
    # parse variable fields
    varFields = data.get("varFields")
    for f in varFields:
        if f.get("fieldTag") == "_":
            record.leader = f.get("content")
        # control fields case
        elif f.get("subfields") is None:
            field = Field(
                tag=f.get("marcTag"),
                indicators=[f.get("ind1"), f.get("ind2")],
                data=f.get("content"),
            )
            record.add_field(field)
        else:  # variable fields
            subfields = []
            for d in f.get("subfields"):
                subfields.append(d.get("tag"))
                subfields.append(d.get("content"))
            field = Field(
                tag=f.get("marcTag"),
                indicators=[f.get("ind1"), f.get("ind2")],
                subfields=subfields,
            )
            record.add_field(field)
    return record
Пример #2
0
def test_build_string_list_from_fields():
    """Test build_string_list_from_fields."""
    record = Record()
    record.add_field(
        Field(tag='200',
              indicators=['0', '1'],
              subfields=[
                  'a', 'Cerasi', 'b', 'Claudio et Elena', 'x',
                  "Collections d'art"
              ]))
    data = build_string_list_from_fields(record=record,
                                         tag='200',
                                         subfields={
                                             'a': ', ',
                                             'b': ', ',
                                             'c': ', ',
                                             'd': ', ',
                                             'f': ', ',
                                             'x': ' - '
                                         })
    assert data == ["Cerasi, Claudio et Elena - Collections d'art"]

    record = Record()
    record.add_field(
        Field(tag='210',
              indicators=['0', '1'],
              subfields=[
                  'a', 'Place of public./distr.', 'b',
                  'Address/publisher/dist.', 'c', 'Name of publisher/dist.',
                  'd', 'Date', 'e', 'Place', 'f', 'Address'
              ]))
    data = build_string_list_from_fields(record=record,
                                         tag='210',
                                         subfields={
                                             'a': ', ',
                                             'b': '. ',
                                             'c': ', ',
                                             'd': '; ',
                                             'e': '; ',
                                             'f': '; '
                                         },
                                         tag_grouping=[{
                                             'subtags': 'c',
                                             'start': ' ( ',
                                             'end': ' )',
                                             'delimiter': '',
                                             'subdelimiter': ', '
                                         }, {
                                             'subtags': 'def',
                                             'start': ' ( ',
                                             'end': ' )',
                                             'delimiter': '',
                                             'subdelimiter': '; '
                                         }])
    assert data == [
        'Place of public./distr.'
        '. Address/publisher/dist.'
        ' ( Name of publisher/dist. )'
        ' ( Date; Place; Address )'
    ]
Пример #3
0
 def test_960_items_nonrepeatable_subfields(self):
     b = Record()
     b.add_field(
         Field(tag='960',
               indicators=[' ', ' '],
               subfields=[
                   'i', 'TEST', 'i', 'TEST', 'l', 'TEST', 'l', 'TEST', 'p',
                   '9.99', 'p', '9.99', 'q', 'TEST', 'q', 'TEST', 'o',
                   'TEST', 'o', 'TEST', 't', 'TEST', 't', 'TEST', 'r',
                   'TEST', 'r', 'TEST', 's', 'TEST', 's', 'TEST', 'v',
                   'TEST', 'v', 'TEST', 'n', 'TEST', 'n', 'TEST', 'v',
                   'TEST', 'v', 'TEST'
               ]))
     bibs.write_marc21('specs_test.mrc', b)
     passed, report = local_specs.local_specs_validation(
         'bpl', ['specs_test.mrc'], self.bcl)
     self.assertFalse(passed)
     self.assertIn('"i" subfield is not repeatable.', report)
     self.assertIn('"l" subfield is not repeatable.', report)
     self.assertIn('"p" subfield is not repeatable.', report)
     self.assertIn('"q" subfield is not repeatable.', report)
     self.assertIn('"o" subfield is not repeatable.', report)
     self.assertIn('"t" subfield is not repeatable.', report)
     self.assertIn('"r" subfield is not repeatable.', report)
     self.assertIn('"s" subfield is not repeatable.', report)
     self.assertIn('"v" subfield is not repeatable.', report)
     self.assertIn('"n" subfield is not repeatable.', report)
Пример #4
0
    def decode_record(self, record):
        r"""
        >>> reader = Reader('http://opac.uthsc.edu', 2)
        >>> raw = "\nLEADER 00000cas  2200517 a 4500 \n001    1481253 \n003    OCoLC \n005    19951109120000.0 \n008    750727c19589999fr qrzp   b   0   b0fre d \n010    sn 86012727 \n022    0003-3995 \n030    AGTQAH \n035    0062827|bMULS|aPITT  NO.  0639600000|asa64872000|bFULS \n040    MUL|cMUL|dFUL|dOCL|dCOO|dNYG|dHUL|dSER|dAIP|dNST|dAGL|dDLC\n       |dTUM \n041 0  engfre|bgeritaspa \n042    nsdp \n049    TUMS \n069 1  A32025000 \n210 0  Ann. genet. \n222  0 Annales de genetique \n229 00 Annales de genetique \n229    Ann Genet \n242 00 Annals on genetics \n245 00 Annales de genetique. \n260    Paris :|bExpansion scientifique,|c1958-2004. \n300    v. :|bill. &#59;|c28 cm. \n310    Quarterly \n321    Two no. a year \n362 0  1,1958-47,2004. \n510 1  Excerpta medica \n510 1  Index medicus|x0019-3879 \n510 2  Biological abstracts|x0006-3169 \n510 2  Chemical abstracts|x0009-2258 \n510 2  Life sciences collection \n510 0  Bulletin signaletique \n510 0  Current contents \n546    French and English, with summaries in German, Italian, and\n       Spanish. \n550    Journal of the Societe francaise de genetique. \n650  2 Genetics|vPeriodicals. \n710 2  Societ\xe9 fran\xe7aise de genetique. \n785 00 |tEuropean journal of medical genetics.  \n856 41 |uhttp://library.uthsc.edu/ems/eresource/3581|zFull text \n       at ScienceDirect: 43(1) Jan 2000 - 47(4) Dec 2004 \n936    Unknown|ajuin 1977 \n"
        >>> record = reader.decode_record(raw)
        >>> print record.title
        Annales de genetique
        """
        
        pseudo_marc = record.strip().split('\n')
        raw_fields = []
        if pseudo_marc[0][0:6] == 'LEADER':
            record = Record()
            record.leader = pseudo_marc[0][7:].strip()
        else:
            return None

        for field in pseudo_marc[1:]:
            tag = field[:3]
            data = unescape_entities(field[6:].decode('latin1')).encode('utf8')

            if tag.startswith(' '):
                # Additional field data needs to be prepended with an extra space 
                # for certain fields ...
                #for special_tag in ('55','260'):
                #    data = " %s" % (data,) if tag.startswith(special_tag) else data
                data = " %s" % (data.strip(),)
                raw_fields[-1]['value'] = "%s%s" % (raw_fields[-1]['value'], data)
                raw_fields[-1]['raw'] = "%s%s" % (raw_fields[-1]['raw'], field.strip())
            else:
                data = data if (tag < '010' and tag.isdigit()) else "a%s" % (data,)
                raw_fields.append({
                    'tag': tag, 
                    'indicator1': field[3], 
                    'indicator2': field[4], 
                    'value': data.strip(), 
                    'raw': field.strip()
                })
        
        for raw in raw_fields:
            tag = raw['tag']
            data = raw['value'].strip()
            field = Field(tag=tag, indicators=[raw['indicator1'], raw['indicator2']], data=data)
            if not field.is_control_field():
                for sub in data.split('|'):
                    try:
                        field.add_subfield(sub[0].strip(), sub[1:].strip())
                    except Exception:
                        # Skip blank/empty subfields
                        continue
            record.add_field(field)
            
        record.parse_leader()
        
        # Disregard record if no title present
        if not record.get_fields('245'):
            return None
        else:
            return record
Пример #5
0
 def test_960_items_incorrect_format(self):
     b = Record()
     b.add_field(
         Field(tag='960', indicators=[' ', ' '], subfields=['r', 'z']))
     bibs.write_marc21('specs_test.mrc', b)
     passed, report = local_specs.local_specs_validation(
         'bpl', ['specs_test.mrc'], self.bcl)
     self.assertIn('"r" subfield has incorrect value.', report)
Пример #6
0
 def test_960_items_correct_price_format(self):
     b = Record()
     b.add_field(
         Field(tag='960', indicators=[' ', '1'], subfields=['p', '9.99']))
     bibs.write_marc21('specs_test.mrc', b)
     passed, report = local_specs.local_specs_validation(
         'bpl', ['specs_test.mrc'], self.bcl)
     self.assertNotIn('"p" subfield has incorrect price format.', report)
Пример #7
0
 def test_949_items_stat_code_incorrect(self):
     b = Record()
     b.add_field(
         Field(tag='949', indicators=[' ', '1'], subfields=['t', '600']))
     bibs.write_marc21('specs_test.mrc', b)
     passed, report = local_specs.local_specs_validation(
         'nypl', ['specs_test.mrc'], self.ncl)
     self.assertIn('"t" subfield has incorrect value.', report)
Пример #8
0
 def test_949_items_empty_price_subfield(self):
     b = Record()
     b.add_field(
         Field(tag='949', indicators=[' ', '1'], subfields=['p', '']))
     bibs.write_marc21('specs_test.mrc', b)
     passed, report = local_specs.local_specs_validation(
         'nypl', ['specs_test.mrc'], self.ncl)
     self.assertIn('"p" subfield has incorrect price format.', report)
Пример #9
0
 def test_949_subfield_a_mandatory(self):
     b = Record()
     b.add_field(Field(tag='949', indicators=[' ', ' '], subfields=[]))
     bibs.write_marc21('specs_test.mrc', b)
     passed, report = local_specs.local_specs_validation(
         'nypl', ['specs_test.mrc'], self.ncl)
     self.assertFalse(passed)
     self.assertIn('"a" subfield is mandatory.', report)
Пример #10
0
    def test_bib_with_vendor_910_tag(self):
        bib = Record()
        bib.add_field(
            Field(tag="910", indicators=[" ", " "], subfields=["a", "foo"]))
        patches.bib_patches("nypl", "research", "acq", "Amalivre", bib)

        tags_910 = bib.get_fields("910")
        self.assertEqual(len(tags_910), 1)
        self.assertEqual(str(bib["910"]), "=910  \\\\$aRL")
Пример #11
0
 def test_949_items_barcode_not_digits(self):
     b = Record()
     b.add_field(
         Field(tag='949', indicators=[' ', '1'], subfields=['i', 'TEST']))
     bibs.write_marc21('specs_test.mrc', b)
     passed, report = local_specs.local_specs_validation(
         'nypl', ['specs_test.mrc'], self.ncl)
     self.assertFalse(passed)
     self.assertIn('"i" subfield has incorrect barcode.', report)
Пример #12
0
 def test_091_no_subfield_a(self):
     b = Record()
     b.add_field(
         Field(tag='099', indicators=[' ', ' '], subfields=['p', 'TEST']))
     bibs.write_marc21('specs_test.mrc', b)
     passed, report = local_specs.local_specs_validation(
         'bpl', ['specs_test.mrc'], self.bcl)
     self.assertFalse(passed)
     self.assertIn('"a" subfield is mandatory.', report)
Пример #13
0
 def test_947_incorrect_subfield_a_value(self):
     b = Record()
     b.add_field(
         Field(tag='947', indicators=[' ', ' '], subfields=['a', 'TEST']))
     bibs.write_marc21('specs_test.mrc', b)
     passed, report = local_specs.local_specs_validation(
         'bpl', ['specs_test.mrc'], self.bcl)
     self.assertFalse(passed)
     self.assertIn('"a" subfield has incorrect value', report)
Пример #14
0
 def test_960_items_mandatory(self):
     b = Record()
     b.add_field(
         Field(tag='960', indicators=[' ', '1'], subfields=['a', 'TEST']))
     bibs.write_marc21('specs_test.mrc', b)
     passed, report = local_specs.local_specs_validation(
         'bpl', ['specs_test.mrc'], self.bcl)
     self.assertFalse(passed)
     self.assertIn('"960  " mandatory tag not found.', report)
Пример #15
0
 def test_960_items_incorrect_location(self):
     b = Record()
     b.add_field(
         Field(tag='960', indicators=[' ', ' '], subfields=['l', 'mma0l']))
     bibs.write_marc21('specs_test.mrc', b)
     passed, report = local_specs.local_specs_validation(
         'bpl', ['specs_test.mrc'], self.bcl)
     self.assertFalse(passed)
     self.assertIn('"l" subfield has incorrect location code.', report)
Пример #16
0
 def test_949_subfield_a_incorrect_value(self):
     b = Record()
     b.add_field(
         Field(tag='949', indicators=[' ', ' '],
               subfields=['a', 'b2=a;']))  # missing * in the begining
     bibs.write_marc21('specs_test.mrc', b)
     passed, report = local_specs.local_specs_validation(
         'nypl', ['specs_test.mrc'], self.ncl)
     self.assertFalse(passed)
     self.assertIn('"a" subfield has incorrect value', report)
Пример #17
0
 def test_960_items_good_barcode(self):
     b = Record()
     b.add_field(
         Field(tag='960',
               indicators=[' ', '1'],
               subfields=['i', '34444987954328']))
     bibs.write_marc21('specs_test.mrc', b)
     passed, report = local_specs.local_specs_validation(
         'bpl', ['specs_test.mrc'], self.bcl)
     self.assertNotIn('"i" subfield has incorrect barcode.', report)
Пример #18
0
    def test_unicode(self):
        record = Record()
        record.add_field(Field(245, ['1', '0'], ['a', unichr(0x1234)]))
        writer = MARCWriter(open('test/foo', 'w'))
        writer.write(record)
        writer.close()

        reader = MARCReader(open('test/foo'))
        record = reader.next()
        self.assertEqual(record['245']['a'], unichr(0x1234))
Пример #19
0
 def test_949_items_repeatable(self):
     b = Record()
     b.add_field(
         Field(tag='949', indicators=[' ', '1'], subfields=['a', 'TEST']))
     b.add_field(
         Field(tag='949', indicators=[' ', '1'], subfields=['a', 'TEST2']))
     bibs.write_marc21('specs_test.mrc', b)
     passed, report = local_specs.local_specs_validation(
         'nypl', ['specs_test.mrc'], self.ncl)
     self.assertFalse(passed)
     self.assertNotIn('"949 1" is not repeatable.', report)
Пример #20
0
 def test_091_not_repeatable(self):
     b = Record()
     b.add_field(
         Field(tag='099', indicators=[' ', ' '], subfields=['a', 'TEST']))
     b.add_field(
         Field(tag='0099', indicators=[' ', ' '], subfields=['a', 'TEST2']))
     bibs.write_marc21('specs_test.mrc', b)
     passed, report = local_specs.local_specs_validation(
         'bpl', ['specs_test.mrc'], self.bcl)
     self.assertFalse(passed)
     self.assertIn('"099  " is not repeatable', report)
Пример #21
0
 def test_947_nonrepeatable_subfield_a(self):
     b = Record()
     b.add_field(
         Field(tag='947',
               indicators=[' ', ' '],
               subfields=['a', 'TEST', 'a', 'TEST1']))
     bibs.write_marc21('specs_test.mrc', b)
     passed, report = local_specs.local_specs_validation(
         'bpl', ['specs_test.mrc'], self.bcl)
     self.assertFalse(passed)
     self.assertIn('"a" subfield is not repeatable.', report)
Пример #22
0
 def test_960_repeatable_diff_indicators(self):
     b = Record()
     b.add_field(
         Field(tag='960', indicators=[' ', ' '], subfields=['a', 'TEST']))
     b.add_field(
         Field(tag='960', indicators=[' ', '1'], subfields=['a', 'TEST']))
     bibs.write_marc21('specs_test.mrc', b)
     passed, report = local_specs.local_specs_validation(
         'bpl', ['specs_test.mrc'], self.bcl)
     self.assertFalse(passed)
     self.assertNotIn('"960 1" is not repeatable', report)
Пример #23
0
class TestFindMatches(unittest.TestCase):
    def setUp(self):
        self.bib1 = Record()
        self.bib1.add_field(
            Field(
                tag='245',
                indicators=['0', '0'],
                subfields=[
                    'a', 'Test '
                ]))
        self.bib1.add_field(
            Field(
                tag='901',
                indicators=[' ', ' '],
                subfields=[
                    'a', 'abcd'
                ]))
        self.bib1.add_field(
            Field(
                tag='001',
                data='1234'
            ))

        self.bib2 = Record()
        self.bib2.add_field(
            Field(
                tag='245',
                indicators=['0', '0'],
                subfields=[
                    'a', 'Test '
                ]))
        self.bib2.add_field(
            Field(
                tag='901',
                indicators=[' ', ' '],
                subfields=[
                    'a', 'abcd'
                ]))

    def test_2_matches(self):
        conditions = [('901', 'a', 'abcd'), ('001', None, '1234')]
        self.assertEqual(
            vendors.find_matches(self.bib1, conditions), 2)

    def test_only_1_match(self):
        conditions = [('901', 'a', 'abcd'), ('001', None, '12345')]
        self.assertEqual(
            vendors.find_matches(self.bib1, conditions), 1)

    def test_bib_missing_tag(self):
        conditions = [('901', 'a', 'abcd'), ('001', None, '1234')]
        self.assertEqual(
            vendors.find_matches(self.bib2, conditions), 1)
def record_sorted(record: Record) -> Record:
    result = Record()
    result.leader = record.leader
    for i in range(1000):
        field_name = str(i)
        while len(field_name) < 3:
            field_name = "0" + field_name
        # 先寻出旧数据中所有的字段名下字段
        old_fields = record.get_fields(field_name)
        for field in old_fields:
            result.add_field(field)
    return result
Пример #25
0
    def test_writing_unicode(self):
        record = Record()
        record.add_field(Field(245, ['1', '0'], ['a', unichr(0x1234)]))
        record.leader = '         a              '
        writer = MARCWriter(open('test/foo', 'w'))
        writer.write(record)
        writer.close()

        reader = MARCReader(open('test/foo'), to_unicode=True)
        record = reader.next()
        self.assertEqual(record['245']['a'], unichr(0x1234))

        os.remove('test/foo')
Пример #26
0
 def test_949_items_mandatory_subfields(self):
     b = Record()
     b.add_field(
         Field(tag='949', indicators=[' ', '1'], subfields=['a', 'TEST']))
     bibs.write_marc21('specs_test.mrc', b)
     passed, report = local_specs.local_specs_validation(
         'nypl', ['specs_test.mrc'], self.ncl)
     self.assertFalse(passed)
     self.assertIn('"i" subfield is mandatory.', report)
     self.assertIn('"l" subfield is mandatory.', report)
     self.assertIn('"p" subfield is mandatory.', report)
     self.assertIn('"t" subfield is mandatory.', report)
     self.assertIn('"v" subfield is mandatory.', report)
Пример #27
0
 def make_marc(self, obj):
     """Make one MARC record."""
     inst_id = obj.get('id', 'NO-ID')
     logging.info("Creating MARC for %s" % (inst_id))
     record = Record()
     # Find associated work
     if ('bf:instanceOf' in obj and 'id' in obj['bf:instanceOf']):
         work = self.find_obj_by_id(obj['bf:instanceOf']['id'], 'bf:Work')
     else:
         raise Exception("No bf:instanceOf so can't get work!")
     # <collection xmlns="http://www.loc.gov/MARC21/slim">
     #  <record>
     #    <leader>01050cam a22003011  4500</leader>
     #    <controlfield tag="001">102063</controlfield>
     #    <controlfield tag="008">860506s1957    nyua     b    000 0 eng  </controlfield>
     if ('bib:hasActivity' in obj and obj['bib:hasActivity'].get('type')
             == "bib:PublicationActivity"):
         # https://www.loc.gov/marc/bibliographic/bd008.html
         pub_year = obj['bib:hasActivity'].get('dcterms:date', '')
         pub_loc = ''
         pub_lang = ''
         if ('bib:atLocation' in obj['bib:hasActivity']):
             loc = obj['bib:hasActivity']['bib:atLocation'].get('id', '')
             if (loc.startswith('loc:')):
                 pub_loc = loc.lstrip('loc:')
         if ('dcterms:language' in work):
             lang = work['dcterms:language'].get('id', '')
         if (lang.startswith('lang:')):
             pub_lang = lang.lstrip('lang:')
         f008 = "%6s%1s%4s%4s%3s%17s%3s%1s%1s" % (
             '', '', pub_year, '', pub_loc, '', pub_lang, '', '')
         record.add_field(Field(tag='008', data=f008))
     # FIXME - seems that the 'eng' is recorded int the Work but the Work is not linked
     # FIXME - to the Instance!
     #    <datafield tag="245" ind1="0" ind2="0">
     #      <subfield code="a">Clinical cardiopulmonary physiology.</subfield>
     f245 = []
     if ('bf:title' in obj and 'rdfs:label' in obj['bf:title']):
         f245.append('a')
         f245.append(obj['bf:title']['rdfs:label'])
     #      <subfield code="c">Sponsored by the American College of Chest Physicians.  Editorial board: Burgess L. Gordon, chairman, editor-in-chief, Albert H. Andrews [and others]</subfield>
     if ('bf:responsibilityStatement' in obj):
         f245.append('c')
         f245.append(obj['bf:responsibilityStatement'])
     if (len(f245) > 0):
         record.add_field(
             Field(tag='245', indicators=[0, 0], subfields=f245))
     #    </datafield>
     #  </record>
     # </collection>
     return (record)
def addLBD(config, oclcnumber, note):
    oauth_session = config.get('oauth-session')
    #create the LBD
    record = Record(leader='00000n   a2200000   4500')
    record.add_field(Field(tag='004', data=oclcnumber))
    record.add_field(
        Field(indicators=[' ', ' '], tag='500', subfields=['a', note]),
        Field(indicators=[' ', ' '],
              tag='935',
              subfields=['a', str(time.time())]),
        Field(indicators=[' ', ' '],
              tag='940',
              subfields=['a', config.get('oclcSymbol')]))
    input = pymarc.record_to_xml(record).decode("utf-8")

    try:
        r = oauth_session.post(
            config.get('metadata_service_url') + "/lbd/data",
            data=input,
            headers={
                "Accept":
                'application/atom+xml;content="application/vnd.oclc.marc21+xml"',
                "Content-Type": "application/vnd.oclc.marc21+xml"
            })
        r.raise_for_status
        try:
            result = ElementTree.fromstring(r.content)
            ns = {
                'atom': 'http://www.w3.org/2005/Atom',
                'wc': 'http://worldcat.org/rb'
            }
            marcNode = result.findall('atom:content/wc:response',
                                      ns)[0].getchildren()[0]
            marcData = StringIO(
                ElementTree.tostring(marcNode,
                                     encoding='unicode',
                                     method='xml'))
            # need to get this XML section out as a string and into a file like object
            marcRecords = pymarc.parse_xml_to_array(marcData)
            # pull out the LBD accession number
            print(marcRecords)
            accessionNumber = marcRecords[0]['001'].value()
            status = "success"
        except xml.etree.ElementTree.ParseError as err:
            accessionNumber = ""
            status = "failed XML parsing issue"
            print(err)
    except requests.exceptions.HTTPError as err:
        status = "failed"
    return pd.Series([oclcnumber, accessionNumber, status])
Пример #29
0
 def test_091_subfields(self):
     b = Record()
     b.add_field(
         Field(tag='091',
               indicators=[' ', ' '],
               subfields=['p', 'TEST', 'p', 'TEST', 'c', 'TEST']))
     bibs.write_marc21('specs_test.mrc', b)
     passed, report = local_specs.local_specs_validation(
         'nypl', ['specs_test.mrc'], self.ncl)
     self.assertFalse(passed)
     self.assertIn(
         '"091": tag occurance 1:\n\t"p" subfield is not repeatable.',
         report)
     self.assertIn('"a" subfield is mandatory.', report)
Пример #30
0
 def test_949_items_location_mandatory(self):
     b = Record()
     b.add_field(
         Field(tag='949',
               indicators=[' ', '1'],
               subfields=[
                   'i', '33333700904853', 'p', '4.99', 't', '211', 'v',
                   'BTSERIES'
               ]))
     bibs.write_marc21('specs_test.mrc', b)
     passed, report = local_specs.local_specs_validation(
         'nypl', ['specs_test.mrc'], self.ncl)
     self.assertFalse(passed)
     self.assertIn('"l" subfield is mandatory.', report)
Пример #31
0
    def test_writing_unicode(self):
        record = Record()
        record.add_field(Field(245, ['1', '0'], ['a', unichr(0x1234)]))
        record.leader = '         a              '
        writer = MARCWriter(open('test/foo', 'wb'))
        writer.write(record)
        writer.close()

        reader = MARCReader(open('test/foo', 'rb'), to_unicode=True)
        record = next(reader)
        self.assertEqual(record['245']['a'], unichr(0x1234))
        reader.close()

        os.remove('test/foo')
Пример #32
0
    def test_writing_unicode(self):
        record = Record()
        record.add_field(Field(245, ["1", "0"], ["a", chr(0x1234)]))
        record.leader = "         a              "
        writer = MARCWriter(open("test/foo", "wb"))
        writer.write(record)
        writer.close()

        reader = MARCReader(open("test/foo", "rb"), to_unicode=True)
        record = next(reader)
        self.assertEqual(record["245"]["a"], chr(0x1234))
        reader.close()

        os.remove("test/foo")
Пример #33
0
def sort_6_subs(rec):
	msg = ''
	new_rec = Record(to_unicode=True, force_utf8=True)
	new_rec_fields = []
	rec_fields = rec.get_fields()
	for field in rec_fields:
		script_field = False
		if not field.is_control_field() and (len(field.get_subfields('6')) > 0):	# the field contains a subfield $6
			script_field = True
			ind1 = field.indicator1
			ind2 = field.indicator2
			tag = field.tag
			first_sub = True		# variable to keep track of whether you're on the first subfield in the field
			needs_sorted = True		# variable to keep track of whether the field needs sorted or if the $6 is already correctly the first subfield
			field_subs = []			# list variable to capture all the subfields in the field *except* for the subfield $6
			for subfield in field:
				# check if $6 is the first subfield - if so, the field is OK and does *not* need to be sorted
				if needs_sorted and first_sub and subfield[0] == '6':
					needs_sorted = False
				
				elif needs_sorted:
					if first_sub:
						# this is the first subfield and is *not* $6, so the field needs sorted - creates one instance of a new_field object only when the 1st subfield is encountered
						new_field = Field(tag=tag, indicators=[ind1,ind2], subfields=[])
					
					# when subfield $6 is finally encountered in the field (not the 1st), add it to the new_field object now so it becomes the first subfield
					# Note: subfield[0] is the subfield code and subfield[1] is the subfield content for this subfield
					if subfield[0]=='6':
						new_field.add_subfield(subfield[0],subfield[1])
					
					# if the subfield is *not* $6, add it to the list of subfields to be added later to the new_field
					else:
						field_subs.append([subfield[0],subfield[1]])
				
				first_sub = False
			
			if needs_sorted:
				# then the $6 was *not* the 1st subfield and we need to now add the remaining subfields to the new_field object
				for sub in field_subs:
					# add the remaining subfields to the new_field object
					new_field.add_subfield(sub[0],sub[1])
				new_rec_fields.append(new_field)	# add the new field to the record
		
		if not script_field or not needs_sorted:
			new_rec_fields.append(field)
	
	for new_f in new_rec_fields:
		new_rec.add_field(new_f)
	
	return new_rec
Пример #34
0
def item2marc(i):
  r = Record()
  id = unicode(i.no)
  r.add_field(Field(tag='001', data=id))
  if i.creator:
    r.add_field(Field(tag = '100', indicators = ['',''], subfields = ['a', i.creator]))
  if i.title:
    r.add_field(Field(tag = '245', indicators = ['',''], subfields = ['a', i.title]))
  if i.pages:
    pages = unicode(i.pages)
    r.add_field(Field(tag = '300', indicators = ['',''], subfields = ['a', pages]))
  for urn in i.urn:
    r.add_field(Field(tag = '856', indicators = ['',''], subfields = ['g', urn]))
  return r
Пример #35
0
def writeMetadataToMarc(data, MARCMapping, saveLocation):
    record = Record()
    for key in data:
        if key in MARCMapping:
            if(key == u'UUID'):
                field = Field(
                    tag = MARCMapping[key],
                    data = data[key])
            else:
		field = Field(
			tag = MARCMapping[key][:3],
			subfields = [MARCMapping[key][3], data[key]],
			indicators=['0', '0'])  
            record.add_field(field)
    writeRecordToFile(record, filename)
Пример #36
0
class JsonHandler:
    """Handle JSON."""
    def __init__(self):
        """Init."""
        self.records = []
        self._record = None
        self._field = None
        self._text = []

    def element(self, element_dict, name=None):
        """Converts a JSON `element_dict` to pymarc fields."""
        if not name:
            self._record = Record()
            self.element(element_dict, "leader")
        elif name == "leader":
            self._record.leader = element_dict[name]
            self.element(element_dict, "fields")
        elif name == "fields":
            fields = iter(element_dict[name])
            for field in fields:
                tag, remaining = field.popitem()
                self._field = Field(tag)
                if self._field.is_control_field():
                    self._field.data = remaining
                else:
                    self.element(remaining, "subfields")
                    self._field.indicators.extend(
                        [remaining["ind1"], remaining["ind2"]])
                self._record.add_field(self._field)
            self.process_record(self._record)
        elif name == "subfields":
            subfields = iter(element_dict[name])
            for subfield in subfields:
                code, text = subfield.popitem()
                self._field.add_subfield(code, text)

    def elements(self, dict_list):
        """Sends `dict_list` to `element`."""
        if type(dict_list) is not list:
            dict_list = [dict_list]
        for rec in dict_list:
            self.element(rec)
        return self.records

    def process_record(self, record):
        """Append `record` to `self.records`."""
        self.records.append(record)
Пример #37
0
 def __next__(self):
     jobj = next(self.iter)
     rec = Record()
     rec.leader = jobj['leader']
     for field in jobj['fields']:
         k,v = list(field.items())[0]
         if 'subfields' in v and hasattr(v,'update'):
             # flatten m-i-j dict to list in pymarc
             subfields = []
             for sub in v['subfields']:
                 for code,value in sub.items():
                     subfields.extend((code,value))
             fld = Field(tag=k,subfields=subfields,indicators=[v['ind1'], v['ind2']])
         else:
             fld = Field(tag=k,data=v)
         rec.add_field(fld)
     return rec
Пример #38
0
def handleXLSX(mapping, sheet, outputFolder, rowsToIgnore):
    # mapping as defined in mapping function loadMapping
    # sheet is the specific excel sheet that contains the data we're extracting
    # rowsToIgnore is the number of rows at top of sheet that we don't care about
    for row in sheet.rows[rowsToIgnore:]:
        record = Record()
        # for every key in our map
        for i, key_entry in enumerate(mapping):
            key = key_entry["field"]
            # if the key isn't empty (i.e. we're not mapping that column)
            if key:
                addField(record, key_entry, [key[3], unicode(row[i].value)])
        if DEBUG:
            print record.title()

	if record.isbn() <> None:
            # Create unique UUID & add to record
            bookUUID = str(uuid.uuid1())
            record.add_field(Field(tag='001', data=bookUUID))
        
            # Write out our marcxml for each row
            writeMARCXML(record, os.path.join(outputFolder, record.isbn() + '.xml'))
'''
from pymarc import Record,Field,record_to_xml
import MySQLdb
record=Record()
print dir(record)
dbLo=MySQLdb.connect("localhost","shailesh","123","shailesh")
dbKoha=MySQLdb.connect("localhost","root","","koha1")
curaKoha=dbKoha.cursor()
curaLocl = dbLo.cursor()
curaLocl.execute("select BookNo,BookName,authorName from book_info group by BookNo;")
dat=curaLocl.fetchall()
curaLocl.execute("select accession,BookNo,callNo from book_info;")
datIte=curaLocl.fetchall()
for i in dat:
		record=Record()
		record.add_field(Field(tag='040',indicators=['0','1'],subfields=['c','LIBRARY OF CONGRESS']))
		record.add_field(Field(tag='245',indicators=['0','1'],subfields=['a',i[1]]))	
		record.add_field(Field(tag='942',indicators=['0','1'],subfields=['2','book of parag','c','BOOK']))
		record.add_field(Field(tag='100',indicators=['0','1'],subfields=['a',i[2]]))
		record.add_field(Field(tag='999',indicators=['0','1'],subfields=['c','8','d','8']))
		marcI=record_to_xml(record)
		#print i[0],i[1],i[2]
		curaKoha.execute("insert into biblio(biblionumber,title,author) values(%s,%s,%s);",(i[0],i[1],i[2]))
		curaKoha.execute("insert into biblioitems(biblionumber,biblioitemnumber,marcxml) values(%s,%s,%s);",(i[0],i[0],marcI))

for i in datIte:
		barcode='1111'+str(i[0])
		curaKoha.execute("insert into items(itemnumber,biblionumber,biblioitemnumber,barcode,itemcallnumber) values(%s,%s,%s,%s,%s);",(i[0],i[1],i[1],barcode,i[2]))

dbKoha.commit()
dbKoha.close()		
Пример #40
0
    labels = g.preferredLabel(conc, lang=PRIMARYLANG)
    try:
        return labels[0][1]
    except IndexError:
        print >>sys.stderr, "WARNING: couldn't find label of %s, result: %s" % (conc,labels)
        return ''

for conc in sorted(g.subjects(RDF.type, SKOS.Concept)):
    if (conc, OWL.deprecated, Literal(True)) in g:
        continue
    rec = Record(leader=LEADER)
    
    # URI -> 001
    rec.add_field(
        Field(
            tag='001',
            data=conc
        )
    )
    
    # dct:modified -> 005
    mod = g.value(conc, DCT.modified, None)
    if mod is None:
        modified = datetime.date(2000, 1, 1)
    else:
        modified = mod.toPython() # datetime.date or datetime.datetime object
    rec.add_field(
        Field(
            tag='005',
            data=modified.strftime('%Y%m%d%H%M%S.0')
        )
    )
Пример #41
0
			# Get PDF
			pdfUrl = 'http://apps.who.int' + aPdf['href']
			urllib.urlretrieve(pdfUrl, SAVE_LOCATION + data['UUID'] + '.' + url.rsplit('.')[-1])
			# Print metadata in MARCXML
			record = Record()
			for key in data:
				if key in MARCMapping:
					if(key == u'UUID'):
						field = Field(
							tag = MARCMapping[key],
							data = data[key])
					else:
						field = Field(
							tag = MARCMapping[key][:3],
							subfields = [MARCMapping[key][3], data[key]],
							indicators=['0', '0'])  
					record.add_field(field)
			writer = XMLWriter(open(SAVE_LOCATION + data[u'UUID'] + '.xml', 'wb'))
			writer.write(record)
			writer.close() 
	except:
        # If there's an error, put it in error list
		errorUrlList.append(url)
		with open(errorListFile, 'wb') as fp:
			json.dump(errorUrlList, fp)
	else:
        # if there's no error, save metadata
		cleanUrlList.append(url)
		with open(cleanListFile, 'wb') as fp:
			json.dump(cleanUrlList, fp)
Пример #42
0
class XmlHandler(ContentHandler):

    """
    You can subclass XmlHandler and add your own process_record
    method that'll be passed a pymarc.Record as it becomes
    available. This could be useful if you want to stream the
    records elsewhere (like to a rdbms) without having to store
    them all in memory.
    """
    def __init__(self, strict=False, normalize_form=None):
        self.records = []
        self._record = None
        self._field = None
        self._subfield_code = None
        self._text = []
        self._strict = strict
        self.normalize_form = normalize_form

    def startElementNS(self, name, qname, attrs):
        if self._strict and name[0] != MARC_XML_NS:
            return

        element = name[1]
        self._text = []

        if element == 'record':
            self._record = Record()
        elif element == 'controlfield':
            tag = attrs.getValue((None, u'tag'))
            self._field = Field(tag)
        elif element == 'datafield':
            tag = attrs.getValue((None, u'tag'))
            ind1 = attrs.get((None, u'ind1'), u' ')
            ind2 = attrs.get((None, u'ind2'), u' ')
            self._field = Field(tag, [ind1, ind2])
        elif element == 'subfield':
            self._subfield_code = attrs[(None, 'code')]

    def endElementNS(self, name, qname):
        if self._strict and name[0] != MARC_XML_NS:
            return

        element = name[1]
        if self.normalize_form is not None:
            text = unicodedata.normalize(self.normalize_form, u''.join(self._text))
        else:
            text = u''.join(self._text)

        if element == 'record':
            self.process_record(self._record)
            self._record = None
        elif element == 'leader':
            self._record.leader = text
        elif element == 'controlfield':
            self._field.data = text
            self._record.add_field(self._field)
            self._field = None
        elif element == 'datafield':
            self._record.add_field(self._field)
            self._field = None
        elif element == 'subfield':
            self._field.subfields.append(self._subfield_code)
            self._field.subfields.append(text)
            self._subfield_code = None

        self._text = []

    def characters(self, chars):
        self._text.append(chars)

    def process_record(self, record):
        self.records.append(record)
Пример #43
0
def epub_to_marc(fname, conf_file=None):
    ns = {
    'n': 'urn:oasis:names:tc:opendocument:xmlns:container',
    'pkg': 'http://www.idpf.org/2007/opf',
    'dc': 'http://purl.org/dc/elements/1.1/'
    }

    # prepare to read from the .epub file
    zip = zipfile.ZipFile(fname)

    # find the contents metafile
    txt = zip.read('META-INF/container.xml')
    tree = etree.fromstring(txt)
    for el in tree:
        for elel in el:
            for item in elel.items():
                if item[0] == 'full-path':
                    cfname = item[1]
    
    # grab the metadata block from the contents metafile
    cf = zip.read(cfname)
    tree = etree.fromstring(cf)
    p = tree.xpath('/pkg:package/pkg:metadata',namespaces=ns)[0]

    # Read from the config file
    conf = configparser.ConfigParser()
    if conf_file:
        conf.read(conf_file)
    else:
        conf.read_string(DEFAULT_CONF)
    leader_dict = {}
    tag_005_dict = {}
    tag_006_dict = {}
    tag_007_dict = {}
    tag_008_dict = {}
    tag_040_dict = {}
    tag_264_dict = {}

    sections = conf.sections()
    for section in sections:
        if section == 'leader':
            for option in conf.options(section):
                leader_dict[option] = conf.get(section, option)
        elif section == '006':
            for option in conf.options(section):
                tag_006_dict[option] = conf.get(section, option)
        elif section == '007':
            for option in conf.options(section):
                tag_007_dict[option] = conf.get(section, option)
        elif section == '008':
            for option in conf.options(section):
                tag_008_dict[option] = conf.get(section, option)
        elif section == '040':
            for option in conf.options(section):
                tag_040_dict[option] = conf.get(section, option)
        elif section == '264':
            for option in conf.options(section):
                tag_264_dict[option] = conf.get(section, option)

    record = Record(force_utf8=True)
    # set the leader
    record.leader = build_leader(leader_dict)
    # I *think* it's updating the 'Base Address of Data' position when
    # it is written to file, so I have kept characters 12-16 blank.
    # Field 005
    record.add_field(Field(tag='005', data=build_tag_005()))
    # Field 006
    record.add_field(Field(tag='006', data=build_tag_006(tag_006_dict, 
        tag_008_dict)))
    # Field 007
    record.add_field(Field(tag='007', data=build_tag_007(tag_007_dict)))
    # Field 008
    record.add_field(Field(tag='008', data=build_tag_008(tag_008_dict, 
        p, ns)))
    # Field 020
    if p.xpath('dc:identifier[@id="ISBN"]/text()', namespaces=ns):
        epub_isbn = p.xpath(
            'dc:identifier[@id="ISBN"]/text()', namespaces=ns)[0].strip()
        epub_field = Field(
            tag = '020',
            indicators = [' ', ' '],
            subfields = ['a', epub_isbn, 'q', 'epub']
                )
    elif p.xpath('dc:identifier[@pkg:scheme="ISBN"]/text()', namespaces=ns):
        epub_isbn = p.xpath(
                'dc:identifier[@pkg:scheme="ISBN"]/text()', namespaces=ns)[0].strip()

        epub_field = Field(
            tag = '020',
            indicators = [' ', ' '],
            subfields = ['a', epub_isbn, 'q', 'epub']
                )

    # Field 040
    # First, check if the indicators are empty and if they are,
    # turn them into single spaces.
    for value in ('indicator_1', 'indicator_2'):
        if tag_040_dict[value] == '':
            tag_040_dict[value] = ' '
    record.add_field(Field(
                tag = '040',
                indicators = [tag_040_dict['indicator_1'], 
                              tag_040_dict['indicator_2']],
                subfields = ['a', tag_040_dict['subfield_a'], 
                             'b', tag_040_dict['subfield_b'], 
                             'e', tag_040_dict['subfield_e'],
                             'c', tag_040_dict['subfield_c']]
    ))

    # Field 245
    if p.xpath('dc:title/text()',namespaces=ns):
        full_title = p.xpath('dc:title/text()',namespaces=ns)[0]
        if ":" in full_title:
            title = full_title[:full_title.index(':') ].strip()
            subtitle = full_title[full_title.index(':') + 1:].strip()
        else:
            title = full_title
            subtitle = None
    if p.xpath('dc:creator/text()', namespaces=ns)[0]:
        creator_statement = p.xpath('dc:creator/text()', namespaces=ns)[0]
    if title and subtitle and creator_statement:
        offset = 0
        if ' ' in title:
            title_words = title.split(' ')
            if title_words[0].lower() in NON_FILING_WORDS:
                offset = len(title_words[0]) + 1
        record.add_field(
            Field('245', ['0', offset], 
                ['a', title + " :", 
                 'b', subtitle + " /", 
                 'c', creator_statement]))
    elif title and creator_statement:
        offset = 0
        if ' ' in title:
            title_words = title.split(' ')
            if title_words[0].lower() in NON_FILING_WORDS:
                offset = len(title_words[0]) + 1
        record.add_field(
            Field('245', ['0', offset], 
                ['a', title + " /", 
                 'c', creator_statement]))

    # Field 264
    if p.xpath('dc:publisher/text()', namespaces=ns) \
    and p.xpath('dc:date/text()', namespaces=ns):
        record.add_field(Field('264', [' ', '1'], 
            ['a', tag_264_dict['subfield_a'] + ' :', 
             'b', p.xpath('dc:publisher/text()', namespaces=ns)[0] + ", ",
             'c', p.xpath('dc:date/text()', namespaces=ns)[0]]))
    if p.xpath('dc:rights/text()', namespaces=ns):
        copyright_statement = ""
        copyright_symbol = "©"
        rights_words_array = p.xpath('dc:rights/text()', 
            namespaces=ns)[0].split()
        for word in rights_words_array:
            if word in copyright_year_range:
                copyright_statement = copyright_symbol + word
        if len(copyright_statement) > 4:
            record.add_field(Field('264', [' ', '4'], 
                ['c', copyright_statement]))
    return record
Пример #44
0
class CSV2MARC (object):
  """
    Converts CSV to MARC records.
  """
  
  def __init__(self):
    """
      Load the CSV file.
    """
    if len(sys.argv) > 1:
      filepath = sys.argv[1]
    else:
      raise Exception(
        "You need to provide a file path to the CSV file as an argument."
      )
    try:
      self.reader = csv.reader(
        open(filepath, "r"),
        delimiter = ","
      )
    except IOError:
      print >>sys.stderr, "Cannot open {0}".format(filepath)
      raise SystemExit
    
    output = "{0}.mrc".format(os.path.splitext(filepath)[0])
    self.file = open(output, "w")
    
    # State variables
    self.sysno = False
    self.record = False
    self.field = False
    self.fieldTag = False
    self.fieldTagOccurrence = False
    self.subfieldLabel = False
    self.subfieldLabelOccurrence = False
    self.line = False
      
  def checkFieldChange(self, fieldTag, fieldTagOccurrence):
    if (self.fieldTag != fieldTag) or ((self.fieldTag == fieldTag) and (self.fieldTagOccurrence != fieldTagOccurrence)):
      return True
    else:
      return False
  
  def checkRecordChange(self, sysno):
    if not (sysno == self.sysno):
      return True
    else:
      return False
  
  def writeMARCRecord(self, record):
    writer = MARCWriter(self.file)
    writer.write(record)
    
  def getNewRecord(self, sysno):
    self.sysno = sysno
    self.record = Record()
  
  def getNewField(self, line):
    self.fieldTag = line["fieldTag"]
    self.fieldTagOccurrence = line["fieldTagOccurrence"]
    if line["subfieldLabel"]:
      # Normal field
      self.field = Field(
        tag = line["fieldTag"],
        indicators = [
          line["indicator1"],
          line["indicator2"]
        ]
      )
    else:
      # Datafield    
      self.field = Field(
        tag = line["fieldTag"],
        data = line["value"]
      )
        
  def main(self):
    for line in self.reader:
      # Parse the line
      line = {
        "sysno" : line[0],
        "fieldTag" : line[1],
        "fieldTagOccurrence" : line[2],
        "indicator1" : line[3],
        "indicator2" : line[4],
        "subfieldLabel" : line[5],
        "subfieldLabelOccurrence" : line[6],
        "value" : line[7],
      }
        
      if not self.sysno:
        self.getNewRecord(line["sysno"])
      if self.checkRecordChange(line["sysno"]):
        self.record.add_field(self.field) # Add the last field of the previous record
        self.field = False # Remove the last field of the previous record
        self.fieldTag = False
        self.writeMARCRecord(self.record)
        self.getNewRecord(line["sysno"])
      
      if not self.fieldTag:
        self.getNewField(line)
      if self.checkFieldChange(line["fieldTag"], line["fieldTagOccurrence"]):
        self.record.add_field(self.field)
        self.getNewField(line)
      
      if line["subfieldLabel"]: # If we have a subfield
        self.field.add_subfield(
          line["subfieldLabel"],
          line["value"]
        )
    self.record.add_field(self.field) # Write the last field
    self.writeMARCRecord(self.record) # Write the last record after the iteration has ended
    self.file.close()
Пример #45
0
def book_to_mark21_file(book,owner, xml = False):
	#New record
	record = Record()
	
	# Number and value explanation : http://www.loc.gov/marc/bibliographic/bdleader.html
	# Adding Leader tags
	l = list(record.leader)
	l[5] = 'n' # New
	l[6] = 'a'   #For manuscript file use 't' 
	l[7] = 'm' # Monograph
	l[9] = 'a'
	l[19] = '#'
	record.leader = "".join(l)

	# Category of material  - Text
	record.add_field(record_control_field('007','t'))

	#Languages
	languages = book.languages.all()
	if languages:
		for lang in languages:
			record.add_field(record_control_field('008',lang.code)) 
	else:
		record.add_field(record_control_field('008','eng'))

	#ISBN - International Standard Book Number 
	isbn = models.Identifier.objects.filter(book=book).exclude(identifier='pub_id').exclude(identifier='urn').exclude(identifier='doi')
	for identifier in isbn:
		if book.book_type:
			record.add_field(record_field('020',['#','#'],['a', str(identifier.value)+' '+book.book_type]))
		else:
			record.add_field(record_field('020',['#','#'],['a', str(identifier.value)]))
	
	#Source of acquisition
	try:
		base_url = models.Setting.objects.get(group__name='general', name='base_url').value
	except:
		base_url='localhost:8000'
	book_url = 'http://%s/editor/submission/%s/' % (base_url, book.id)
	record.add_field(record_field('030',['#','#'],['b', book_url]))

	# Main entry - Personal name
	authors = book.author.all()
	author_names=''
	for author in authors:
		auhtor_names=author_names+author.full_name()+' '
		name=author.last_name+', '+author.first_name
		if author.middle_name:
			name=name+' '+author.middle_name[:1]+'.'
		record.add_field(record_field('100',['1','#'],['a', name]))

	#Title statement
	title_words = (book.title).split(' ')
	first_word = title_words[0]
	if first_word.lower() == 'the':
		record.add_field(record_field('245',['1','4'],['a', book.title,'c',author_names]))
	else:
		record.add_field(record_field('245',['1','0'],['a', book.title,'c',author_names]))

	#Publication
	try:
		press_name = models.Setting.objects.get(group__name='general', name='press_name').value
	except:
		press_name=None
	try: 
		city = models.Setting.objects.get(group__name='general', name='city').value
	except:
		city = None

	publication_info=[]
	if book.publication_date:
		#Press' city
		if city :
			publication_info.append('a')
			publication_info.append(str(city))
		#Press' name
		if press_name:
			publication_info.append('b')
			publication_info.append(str(press_name))
		#Date of Publication
		publication_info.append('c')
		publication_info.append(str(book.publication_date))
		record.add_field(record_field('260',['#','#'],publication_info))

	#Physical details
	if book.pages:
		record.add_field(record_field('300',['#','#'],['a',str(book.pages)+' pages']))
	
	#Content type
	record.add_field(record_field('336',['#','#'],['a', 'text','2','rdacontent']))

	#Media type
	record.add_field(record_field('337',['#','#'],['a', 'unmediated','2','rdamedia']))

	#Carrier type
	record.add_field(record_field('338',['#','#'],['a', 'volume','2','rdacarrier']))

	#Language note
	if languages:
		for lang in languages:
			record.add_field(record_field('546',['#','#'],['a', lang.display]))
	else:
		record.add_field(record_field('546',['#','#'],['a', 'In English']))
	
	press_editors = book.press_editors.all()
	#editors
	for editor in press_editors:
		record.add_field(record_field('700',['1','#'],['a', '%s, %s' % (editor.last_name,editor.first_name),'e','Press editor']))
	
	#Series
	if book.series:
		record.add_field(record_field('830',['#','0'],['a', book.series.name ]))
		if book.series.editor:
			record.add_field(record_field('700',['1','#'],['a', '%s, %s' % (book.series.editor.last_name,book.series.editor.first_name),'e','Series editor']))
	#Add record to file
	title= book.title
	if not xml:
		filename='book_'+str(book.id)+'_'+re.sub('[^a-zA-Z0-9\n\.]', '', title.lower())+'_marc21.dat'
		file=handle_marc21_file(record.as_marc(),filename, book, owner)
	else:
		filename='book_'+str(book.id)+'_'+re.sub('[^a-zA-Z0-9\n\.]', '', title.lower())+'_marc21.xml'
		content=record_to_xml(record, quiet=False, namespace=False)
		file=handle_marc21_file(content,filename, book, owner)
	return file.pk