scitex 2.5.0__py3-none-any.whl → 2.7.3__py3-none-any.whl

scitex/scholar/url_finder/translators/individual/Canadian_Letters_and_Images.py

@@ -34,26 +34,26 @@ class CanadianLettersAndImagesTranslator:
         "inRepository": True,
         "translatorType": 4,
         "browserSupport": "gcsibv",
-        "lastUpdated": "2016-09-09 19:45:42"
+        "lastUpdated": "2016-09-09 19:45:42",
     }
 
     def detect_web(self, doc: BeautifulSoup, url: str) -> str:
         """Detect if page is a document or search results."""
-        if '/content/document' in url:
+        if "/content/document" in url:
             # Determine type based on lineage
-            lineage_elem = doc.select_one('span.lineage-item')
+            lineage_elem = doc.select_one("span.lineage-item")
             if lineage_elem:
                 item_type = lineage_elem.get_text().strip()
-                if item_type in ['Letter', 'Postcard']:
-                    return 'letter'
-                elif item_type in ['Photo', 'Personal Item']:
-                    return 'artwork'
+                if item_type in ["Letter", "Postcard"]:
+                    return "letter"
+                elif item_type in ["Photo", "Personal Item"]:
+                    return "artwork"
 
         # Check for search results
-        if doc.select('h3.title a'):
-            return 'multiple'
+        if doc.select("h3.title a"):
+            return "multiple"
 
-        return ''
+        return ""
 
     def do_web(self, doc: BeautifulSoup, url: str) -> Dict[str, Any]:
         """Extract document data."""
@@ -73,60 +73,64 @@ class CanadianLettersAndImagesTranslator:
         item_type = self.detect_web(doc, url)
 
         item = {
-            'itemType': item_type if item_type in ['letter', 'artwork'] else 'letter',
-            'creators': [],
-            'tags': [],
-            'attachments': [],
-            'url': url
+            "itemType": item_type if item_type in ["letter", "artwork"] else "letter",
+            "creators": [],
+            "tags": [],
+            "attachments": [],
+            "url": url,
         }
 
         # Title
-        title_elem = doc.select_one('.breadcrumbs h1')
+        title_elem = doc.select_one(".breadcrumbs h1")
         if title_elem:
-            item['title'] = title_elem.get_text().strip()
+            item["title"] = title_elem.get_text().strip()
 
         # Type (for letter/artwork distinction)
-        lineage_elem = doc.select_one('span.lineage-item')
+        lineage_elem = doc.select_one("span.lineage-item")
         if lineage_elem:
             type_text = lineage_elem.get_text().strip()
-            if item['itemType'] == 'letter':
-                item['letterType'] = type_text
-            elif item['itemType'] == 'artwork':
-                item['artworkMedium'] = type_text
+            if item["itemType"] == "letter":
+                item["letterType"] = type_text
+            elif item["itemType"] == "artwork":
+                item["artworkMedium"] = type_text
 
         # Date
-        date_container = doc.find('span', class_='field-label', string=re.compile(r'Date'))
+        date_container = doc.find(
+            "span", class_="field-label", string=re.compile(r"Date")
+        )
         if date_container:
             date_value = date_container.find_next_sibling(string=True)
             if date_value:
-                item['date'] = self._str_to_iso(date_value.strip())
+                item["date"] = self._str_to_iso(date_value.strip())
 
         # From (Author)
-        from_label = doc.find('div', class_='field-label', string=re.compile(r'From'))
+        from_label = doc.find("div", class_="field-label", string=re.compile(r"From"))
         if from_label:
-            from_container = from_label.find_parent('div')
+            from_container = from_label.find_parent("div")
             if from_container:
-                from_value = from_container.select_one('.field-items')
+                from_value = from_container.select_one(".field-items")
                 if from_value:
                     author_name = from_value.get_text().strip()
-                    item['creators'].append(self._clean_author(author_name, 'author'))
+                    item["creators"].append(self._clean_author(author_name, "author"))
 
         # To (Recipient)
-        to_label = doc.find('div', class_='field-label', string=re.compile(r'To'))
+        to_label = doc.find("div", class_="field-label", string=re.compile(r"To"))
         if to_label:
-            to_container = to_label.find_parent('div')
+            to_container = to_label.find_parent("div")
             if to_container:
-                to_value = to_container.select_one('.field-items')
+                to_value = to_container.select_one(".field-items")
                 if to_value:
                     recipient_name = to_value.get_text().strip()
-                    item['creators'].append(self._clean_author(recipient_name, 'recipient'))
+                    item["creators"].append(
+                        self._clean_author(recipient_name, "recipient")
+                    )
 
         return item
 
     def _str_to_iso(self, date_str: str) -> str:
         """Convert date string to ISO format."""
         # Simple date parsing - could be enhanced
-        date_match = re.search(r'(\d{4})-(\d{2})-(\d{2})', date_str)
+        date_match = re.search(r"(\d{4})-(\d{2})-(\d{2})", date_str)
         if date_match:
             return date_match.group(0)
         return date_str
@@ -136,17 +140,13 @@ class CanadianLettersAndImagesTranslator:
         name = name.strip()
 
         # Handle comma-separated (LastName, FirstName)
-        if ',' in name:
-            parts = name.split(',', 1)
+        if "," in name:
+            parts = name.split(",", 1)
             return {
-                'firstName': parts[1].strip() if len(parts) > 1 else '',
-                'lastName': parts[0].strip(),
-                'creatorType': creator_type
+                "firstName": parts[1].strip() if len(parts) > 1 else "",
+                "lastName": parts[0].strip(),
+                "creatorType": creator_type,
             }
         else:
             # Single name or no clear separation
-            return {
-                'lastName': name,
-                'creatorType': creator_type,
-                'fieldMode': True
-            }
+            return {"lastName": name, "creatorType": creator_type, "fieldMode": True}

scitex/scholar/url_finder/translators/individual/Canadiana_ca.py

@@ -34,16 +34,16 @@ class CanadianaCATranslator:
         "inRepository": True,
         "translatorType": 4,
         "browserSupport": "gcsibv",
-        "lastUpdated": "2012-07-03 16:44:04"
+        "lastUpdated": "2012-07-03 16:44:04",
     }
 
     def detect_web(self, doc: BeautifulSoup, url: str) -> str:
         """Detect if page is a book or search results."""
-        if '/view/' in url:
-            return 'book'
-        elif '/search?' in url:
-            return 'multiple'
-        return ''
+        if "/view/" in url:
+            return "book"
+        elif "/search?" in url:
+            return "multiple"
+        return ""
 
     def do_web(self, doc: BeautifulSoup, url: str) -> Dict[str, Any]:
         """Extract book data."""
@@ -61,24 +61,24 @@ class CanadianaCATranslator:
             Dictionary containing book metadata
         """
         item = {
-            'itemType': 'book',
-            'creators': [],
-            'tags': [],
-            'attachments': [],
-            'url': url
+            "itemType": "book",
+            "creators": [],
+            "tags": [],
+            "attachments": [],
+            "url": url,
         }
 
         data_tags = {}
 
         # Extract metadata from table
-        table = doc.select_one('#documentRecord table tbody')
+        table = doc.select_one("#documentRecord table tbody")
         if table:
-            rows = table.find_all('tr')
+            rows = table.find_all("tr")
             for row in rows:
-                header = row.find('th')
-                value = row.find('td')
+                header = row.find("th")
+                value = row.find("td")
                 if header and value:
-                    field_title = header.get_text().strip().replace('\s+', '')
+                    field_title = header.get_text().strip().replace("\s+", "")
                     field_value = value.get_text().strip()
 
                     # Normalize French to English field names
@@ -86,75 +86,88 @@ class CanadianaCATranslator:
                     data_tags[field_title] = field_value
 
         # Process Creator/Author
-        if 'Creator' in data_tags or 'PrincipalAuthor' in data_tags:
-            author_name = data_tags.get('Creator') or data_tags.get('PrincipalAuthor')
+        if "Creator" in data_tags or "PrincipalAuthor" in data_tags:
+            author_name = data_tags.get("Creator") or data_tags.get("PrincipalAuthor")
             if author_name:
-                item['creators'].append(self._clean_author(author_name))
+                item["creators"].append(self._clean_author(author_name))
 
         # Process Published/Imprint information
-        if 'Published' in data_tags or 'Imprint' in data_tags:
-            imprint = data_tags.get('Published') or data_tags.get('Imprint')
+        if "Published" in data_tags or "Imprint" in data_tags:
+            imprint = data_tags.get("Published") or data_tags.get("Imprint")
             if imprint:
                 # Extract date
-                date_match = re.search(r'\d+[-?\s\d]*', imprint)
+                date_match = re.search(r"\d+[-?\s\d]*", imprint)
                 if date_match:
-                    item['date'] = date_match.group(0).strip()
+                    item["date"] = date_match.group(0).strip()
 
                 # Extract place
-                place_match = re.search(r'.+?:', imprint)
+                place_match = re.search(r".+?:", imprint)
                 if place_match:
-                    item['place'] = place_match.group(0).replace(':', '').replace('[', '').replace(']', '').strip()
+                    item["place"] = (
+                        place_match.group(0)
+                        .replace(":", "")
+                        .replace("[", "")
+                        .replace("]", "")
+                        .strip()
+                    )
 
                 # Extract publisher
-                publisher_match = re.search(r':[^,\d]+', imprint)
+                publisher_match = re.search(r":[^,\d]+", imprint)
                 if publisher_match:
-                    item['publisher'] = publisher_match.group(0).replace(':', '').replace('[', '').replace(']', '').replace('?', '').strip()
+                    item["publisher"] = (
+                        publisher_match.group(0)
+                        .replace(":", "")
+                        .replace("[", "")
+                        .replace("]", "")
+                        .replace("?", "")
+                        .strip()
+                    )
 
         # Process subjects/tags
-        if 'Subjects' in data_tags:
-            subjects = data_tags['Subjects'].replace('\n', '||').split('||')
+        if "Subjects" in data_tags:
+            subjects = data_tags["Subjects"].replace("\n", "||").split("||")
             for subject in subjects:
                 subject = subject.strip()
                 if subject:
-                    item['tags'].append({'tag': subject})
+                    item["tags"].append({"tag": subject})
 
         # Process identifier
-        if 'Identifier' in data_tags:
-            item['extra'] = 'CIHM Number: ' + data_tags['Identifier'].strip()
+        if "Identifier" in data_tags:
+            item["extra"] = "CIHM Number: " + data_tags["Identifier"].strip()
 
         # Other fields
-        self._associate_data(item, data_tags, 'Title', 'title')
-        self._associate_data(item, data_tags, 'Language', 'language')
-        self._associate_data(item, data_tags, 'Pages', 'pages')
-        self._associate_data(item, data_tags, 'DocumentSource', 'rights')
-        self._associate_data(item, data_tags, 'PermanentLink', 'url')
+        self._associate_data(item, data_tags, "Title", "title")
+        self._associate_data(item, data_tags, "Language", "language")
+        self._associate_data(item, data_tags, "Pages", "pages")
+        self._associate_data(item, data_tags, "DocumentSource", "rights")
+        self._associate_data(item, data_tags, "PermanentLink", "url")
 
         # Clean title
-        if item.get('title'):
-            item['title'] = ' '.join(item['title'].split())
+        if item.get("title"):
+            item["title"] = " ".join(item["title"].split())
 
         # Fix language encoding
-        if item.get('language'):
-            if 'English' in item['language'] or 'Anglais' in item['language']:
-                item['language'] = 'en-CA'
+        if item.get("language"):
+            if "English" in item["language"] or "Anglais" in item["language"]:
+                item["language"] = "en-CA"
 
         return item
 
     def _normalize_field_name(self, field_name: str) -> str:
         """Normalize French field names to English."""
         mapping = {
-            'Créateur': 'Creator',
-            'Titre': 'Title',
-            'Adressebibliographique': 'Published',
-            'Éditeur': 'Published',
-            'Langue': 'Language',
-            'Nombredepages': 'Pages',
-            'Description': 'Extent',
-            'Sujet': 'Subjects',
-            'Identificateur': 'Identifier',
-            'ICMHno': 'Identifier',
-            'Documentoriginal': 'DocumentSource',
-            'Lienpermanent': 'PermanentLink'
+            "Créateur": "Creator",
+            "Titre": "Title",
+            "Adressebibliographique": "Published",
+            "Éditeur": "Published",
+            "Langue": "Language",
+            "Nombredepages": "Pages",
+            "Description": "Extent",
+            "Sujet": "Subjects",
+            "Identificateur": "Identifier",
+            "ICMHno": "Identifier",
+            "Documentoriginal": "DocumentSource",
+            "Lienpermanent": "PermanentLink",
         }
         return mapping.get(field_name, field_name)
 
@@ -162,23 +175,21 @@ class CanadianaCATranslator:
         """Parse author name."""
         name = name.strip()
 
-        if ',' in name:
-            parts = name.split(',', 1)
-            first_name = parts[1].strip() if len(parts) > 1 else ''
+        if "," in name:
+            parts = name.split(",", 1)
+            first_name = parts[1].strip() if len(parts) > 1 else ""
             last_name = parts[0].strip()
             return {
-                'firstName': first_name,
-                'lastName': last_name,
-                'creatorType': 'author'
+                "firstName": first_name,
+                "lastName": last_name,
+                "creatorType": "author",
             }
         else:
-            return {
-                'lastName': name,
-                'creatorType': 'author',
-                'fieldMode': True
-            }
+            return {"lastName": name, "creatorType": "author", "fieldMode": True}
 
-    def _associate_data(self, item: Dict, data_tags: Dict, field: str, zotero_field: str):
+    def _associate_data(
+        self, item: Dict, data_tags: Dict, field: str, zotero_field: str
+    ):
         """Associate data from tags to item."""
         if field in data_tags:
             item[zotero_field] = data_tags[field]

scitex/scholar/url_finder/translators/individual/Cascadilla_Proceedings_Project.py

@@ -33,20 +33,22 @@ class CascadillaProceedingsProjectTranslator:
         "inRepository": True,
         "translatorType": 4,
         "browserSupport": "gcsibv",
-        "lastUpdated": "2021-10-29 00:35:04"
+        "lastUpdated": "2021-10-29 00:35:04",
     }
 
     def detect_web(self, doc: BeautifulSoup, url: str) -> str:
         """Detect if page is a conference paper or search results."""
-        if doc.select_one('.bookinfo'):
-            return 'conferencePaper'
+        if doc.select_one(".bookinfo"):
+            return "conferencePaper"
 
         # Check for article links
-        links = doc.select('.pagecontent > .contentpadding > a[href*="abstract"][href$=".html"]')
+        links = doc.select(
+            '.pagecontent > .contentpadding > a[href*="abstract"][href$=".html"]'
+        )
         if links:
-            return 'multiple'
+            return "multiple"
 
-        return ''
+        return ""
 
     def do_web(self, doc: BeautifulSoup, url: str) -> Dict[str, Any]:
         """Extract conference paper data."""
@@ -64,11 +66,11 @@ class CascadillaProceedingsProjectTranslator:
             Dictionary containing conference paper metadata
         """
         item = {
-            'itemType': 'conferencePaper',
-            'creators': [],
-            'tags': [],
-            'attachments': [],
-            'url': url
+            "itemType": "conferencePaper",
+            "creators": [],
+            "tags": [],
+            "attachments": [],
+            "url": url,
         }
 
         # Extract embedded metadata
@@ -79,103 +81,111 @@ class CascadillaProceedingsProjectTranslator:
 
         # Add PDF attachment if available
         pdf_link = doc.select_one('a[href$=".pdf"]')
-        if pdf_link and pdf_link.get('href'):
-            item['attachments'].append({
-                'url': pdf_link['href'] if pdf_link['href'].startswith('http') else 'https://www.lingref.com' + pdf_link['href'],
-                'title': 'Full Text PDF',
-                'mimeType': 'application/pdf'
-            })
+        if pdf_link and pdf_link.get("href"):
+            item["attachments"].append(
+                {
+                    "url": pdf_link["href"]
+                    if pdf_link["href"].startswith("http")
+                    else "https://www.lingref.com" + pdf_link["href"],
+                    "title": "Full Text PDF",
+                    "mimeType": "application/pdf",
+                }
+            )
 
         # Add snapshot
-        item['attachments'].append({
-            'title': 'Snapshot',
-            'mimeType': 'text/html',
-            'url': url
-        })
+        item["attachments"].append(
+            {"title": "Snapshot", "mimeType": "text/html", "url": url}
+        )
 
         return item
 
     def _extract_meta_tags(self, doc: BeautifulSoup, item: Dict[str, Any]):
         """Extract metadata from meta tags."""
         # Title
-        title_meta = doc.find('meta', attrs={'name': 'citation_title'})
+        title_meta = doc.find("meta", attrs={"name": "citation_title"})
         if title_meta:
-            item['title'] = title_meta.get('content', '')
+            item["title"] = title_meta.get("content", "")
 
         # Authors
-        author_metas = doc.find_all('meta', attrs={'name': 'citation_author'})
+        author_metas = doc.find_all("meta", attrs={"name": "citation_author"})
         for author_meta in author_metas:
-            author_name = author_meta.get('content', '')
+            author_name = author_meta.get("content", "")
             if author_name:
-                item['creators'].append(self._clean_author(author_name, 'author'))
+                item["creators"].append(self._clean_author(author_name, "author"))
 
         # Date
-        date_meta = doc.find('meta', attrs={'name': 'citation_publication_date'})
+        date_meta = doc.find("meta", attrs={"name": "citation_publication_date"})
         if date_meta:
-            item['date'] = date_meta.get('content', '')
+            item["date"] = date_meta.get("content", "")
 
         # ISBN
-        isbn_meta = doc.find('meta', attrs={'name': 'citation_isbn'})
+        isbn_meta = doc.find("meta", attrs={"name": "citation_isbn"})
         if isbn_meta:
-            item['ISBN'] = isbn_meta.get('content', '')
+            item["ISBN"] = isbn_meta.get("content", "")
 
         # Publisher
-        publisher_meta = doc.find('meta', attrs={'name': 'citation_publisher'})
+        publisher_meta = doc.find("meta", attrs={"name": "citation_publisher"})
         if publisher_meta:
-            item['publisher'] = publisher_meta.get('content', '')
+            item["publisher"] = publisher_meta.get("content", "")
 
         # Conference name
-        conf_meta = doc.find('meta', attrs={'name': 'citation_conference_title'})
+        conf_meta = doc.find("meta", attrs={"name": "citation_conference_title"})
         if conf_meta:
-            item['conferenceName'] = conf_meta.get('content', '')
+            item["conferenceName"] = conf_meta.get("content", "")
 
         # Pages
-        first_page_meta = doc.find('meta', attrs={'name': 'citation_firstpage'})
-        last_page_meta = doc.find('meta', attrs={'name': 'citation_lastpage'})
+        first_page_meta = doc.find("meta", attrs={"name": "citation_firstpage"})
+        last_page_meta = doc.find("meta", attrs={"name": "citation_lastpage"})
         if first_page_meta and last_page_meta:
-            first_page = first_page_meta.get('content', '')
-            last_page = last_page_meta.get('content', '')
+            first_page = first_page_meta.get("content", "")
+            last_page = last_page_meta.get("content", "")
             if first_page and last_page:
-                item['pages'] = f'{first_page}-{last_page}'
+                item["pages"] = f"{first_page}-{last_page}"
 
     def _fill_book_info(self, doc: BeautifulSoup, item: Dict[str, Any]):
         """Fill proceedings information."""
-        bookinfo = doc.select_one('.bookinfo > .contentpadding')
+        bookinfo = doc.select_one(".bookinfo > .contentpadding")
         if not bookinfo:
-            bookinfo = doc.select_one('.pagecontent > .contentpadding')
+            bookinfo = doc.select_one(".pagecontent > .contentpadding")
 
         if bookinfo:
             # Proceedings title
-            proceedings_title = bookinfo.select_one('.largerfont')
+            proceedings_title = bookinfo.select_one(".largerfont")
             if proceedings_title:
-                item['proceedingsTitle'] = proceedings_title.get_text().strip()
+                item["proceedingsTitle"] = proceedings_title.get_text().strip()
 
             # Publisher place for Cascadilla
-            if item.get('publisher', '').startswith('Cascadilla'):
-                item['place'] = 'Somerville, MA'
+            if item.get("publisher", "").startswith("Cascadilla"):
+                item["place"] = "Somerville, MA"
 
             # Extract editors
             for child in bookinfo.children:
-                if hasattr(child, 'get_text'):
+                if hasattr(child, "get_text"):
                     text = child.get_text().strip()
-                    if text.startswith('edited by'):
-                        editor_text = text.replace('edited by', '').strip()
+                    if text.startswith("edited by"):
+                        editor_text = text.replace("edited by", "").strip()
                         # Split by commas and "and"
                         editors = []
-                        for part in editor_text.replace(', and ', '|||').replace(' and ', '|||').split(','):
-                            for editor in part.split('|||'):
+                        for part in (
+                            editor_text.replace(", and ", "|||")
+                            .replace(" and ", "|||")
+                            .split(",")
+                        ):
+                            for editor in part.split("|||"):
                                 editor = editor.strip()
                                 if editor:
                                     editors.append(editor)
 
                         for editor_name in editors:
-                            item['creators'].append(self._clean_author(editor_name, 'editor'))
+                            item["creators"].append(
+                                self._clean_author(editor_name, "editor")
+                            )
                         break
 
         # Abstract
-        abstract_div = doc.select_one('.abstract div')
+        abstract_div = doc.select_one(".abstract div")
         if abstract_div:
-            item['abstractNote'] = abstract_div.get_text().strip()
+            item["abstractNote"] = abstract_div.get_text().strip()
 
     def _clean_author(self, name: str, creator_type: str) -> Dict[str, Any]:
         """Parse author/editor name."""
@@ -184,13 +194,9 @@ class CascadillaProceedingsProjectTranslator:
 
         if len(parts) >= 2:
             return {
-                'firstName': ' '.join(parts[:-1]),
-                'lastName': parts[-1],
-                'creatorType': creator_type
+                "firstName": " ".join(parts[:-1]),
+                "lastName": parts[-1],
+                "creatorType": creator_type,
             }
         else:
-            return {
-                'lastName': name,
-                'creatorType': creator_type,
-                'fieldMode': True
-            }
+            return {"lastName": name, "creatorType": creator_type, "fieldMode": True}