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

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

@@ -33,19 +33,19 @@ class CentralAndEasternEuropeanOnlineLibraryJournalsTranslator:
         "inRepository": True,
         "translatorType": 4,
         "browserSupport": "gcsibv",
-        "lastUpdated": "2021-09-22 20:12:37"
+        "lastUpdated": "2021-09-22 20:12:37",
     }
 
     def detect_web(self, doc: BeautifulSoup, url: str) -> str:
         """Detect if page is an article or search results."""
-        if '/article-detail?' in url:
-            return 'journalArticle'
+        if "/article-detail?" in url:
+            return "journalArticle"
 
         # Check for search results
-        if doc.select('.description a, .article-details > h3 > a'):
-            return 'multiple'
+        if doc.select(".description a, .article-details > h3 > a"):
+            return "multiple"
 
-        return ''
+        return ""
 
     def do_web(self, doc: BeautifulSoup, url: str) -> Dict[str, Any]:
         """Extract article data using embedded metadata."""
@@ -53,120 +53,120 @@ class CentralAndEasternEuropeanOnlineLibraryJournalsTranslator:
         self._post_process(doc, item)
         return item
 
-    def _extract_embedded_metadata(self, doc: BeautifulSoup, url: str) -> Dict[str, Any]:
+    def _extract_embedded_metadata(
+        self, doc: BeautifulSoup, url: str
+    ) -> Dict[str, Any]:
         """Extract metadata from meta tags."""
         item = {
-            'itemType': 'journalArticle',
-            'creators': [],
-            'tags': [],
-            'attachments': [],
-            'url': url
+            "itemType": "journalArticle",
+            "creators": [],
+            "tags": [],
+            "attachments": [],
+            "url": url,
         }
 
         # 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))
+                item["creators"].append(self._clean_author(author_name))
 
         # Publication title
-        journal_meta = doc.find('meta', attrs={'name': 'citation_journal_title'})
+        journal_meta = doc.find("meta", attrs={"name": "citation_journal_title"})
         if journal_meta:
-            item['publicationTitle'] = journal_meta.get('content', '')
+            item["publicationTitle"] = journal_meta.get("content", "")
 
         # 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", "")
 
         # Volume
-        volume_meta = doc.find('meta', attrs={'name': 'citation_volume'})
+        volume_meta = doc.find("meta", attrs={"name": "citation_volume"})
         if volume_meta:
-            item['volume'] = volume_meta.get('content', '')
+            item["volume"] = volume_meta.get("content", "")
 
         # Issue
-        issue_meta = doc.find('meta', attrs={'name': 'citation_issue'})
+        issue_meta = doc.find("meta", attrs={"name": "citation_issue"})
         if issue_meta:
-            item['issue'] = issue_meta.get('content', '')
+            item["issue"] = issue_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}"
 
         # ISSN
-        issn_meta = doc.find('meta', attrs={'name': 'citation_issn'})
+        issn_meta = doc.find("meta", attrs={"name": "citation_issn"})
         if issn_meta:
-            item['ISSN'] = issn_meta.get('content', '')
+            item["ISSN"] = issn_meta.get("content", "")
 
         # Language
-        lang_meta = doc.find('meta', attrs={'name': 'citation_language'})
+        lang_meta = doc.find("meta", attrs={"name": "citation_language"})
         if lang_meta:
-            item['language'] = lang_meta.get('content', '')
+            item["language"] = lang_meta.get("content", "")
 
         # Keywords
-        keywords_meta = doc.find('meta', attrs={'name': 'citation_keywords'})
+        keywords_meta = doc.find("meta", attrs={"name": "citation_keywords"})
         if keywords_meta:
-            keywords = keywords_meta.get('content', '').split(';')
+            keywords = keywords_meta.get("content", "").split(";")
             for keyword in keywords:
                 keyword = keyword.strip()
                 if keyword:
-                    item['tags'].append({'tag': keyword})
+                    item["tags"].append({"tag": keyword})
 
         # PDF URL
-        pdf_meta = doc.find('meta', attrs={'name': 'citation_pdf_url'})
+        pdf_meta = doc.find("meta", attrs={"name": "citation_pdf_url"})
         if pdf_meta:
-            pdf_url = pdf_meta.get('content', '')
+            pdf_url = pdf_meta.get("content", "")
             if pdf_url:
-                item['attachments'].append({
-                    'url': pdf_url,
-                    'title': 'Full Text PDF',
-                    'mimeType': 'application/pdf'
-                })
+                item["attachments"].append(
+                    {
+                        "url": pdf_url,
+                        "title": "Full Text PDF",
+                        "mimeType": "application/pdf",
+                    }
+                )
 
         return item
 
     def _post_process(self, doc: BeautifulSoup, item: Dict[str, Any]):
         """Post-process to add abstract if not in embedded metadata."""
-        if not item.get('abstractNote'):
-            abstract_elem = doc.select_one('p.summary')
+        if not item.get("abstractNote"):
+            abstract_elem = doc.select_one("p.summary")
             if abstract_elem:
-                item['abstractNote'] = abstract_elem.get_text().strip()
+                item["abstractNote"] = abstract_elem.get_text().strip()
 
     def _clean_author(self, name: str) -> Dict[str, Any]:
         """Parse author name."""
         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': 'author'
+                "firstName": parts[1].strip() if len(parts) > 1 else "",
+                "lastName": parts[0].strip(),
+                "creatorType": "author",
             }
         else:
             # Space-separated
             parts = name.split()
             if len(parts) >= 2:
                 return {
-                    'firstName': ' '.join(parts[:-1]),
-                    'lastName': parts[-1],
-                    'creatorType': 'author'
+                    "firstName": " ".join(parts[:-1]),
+                    "lastName": parts[-1],
+                    "creatorType": "author",
                 }
             else:
-                return {
-                    'lastName': name,
-                    'creatorType': 'author',
-                    'fieldMode': True
-                }
+                return {"lastName": name, "creatorType": "author", "fieldMode": True}

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

@@ -34,16 +34,16 @@ class ChamplainSocietyCollectionTranslator:
         "inRepository": True,
         "translatorType": 4,
         "browserSupport": "gcsibv",
-        "lastUpdated": "2021-12-28 04:41:28"
+        "lastUpdated": "2021-12-28 04:41:28",
     }
 
     def detect_web(self, doc: BeautifulSoup, url: str) -> str:
         """Detect if page is a book or search results."""
-        if 'search_results' in url:
-            return 'multiple'
-        elif 'item_record' in url:
-            return 'book'
-        return ''
+        if "search_results" in url:
+            return "multiple"
+        elif "item_record" in url:
+            return "book"
+        return ""
 
     def do_web(self, doc: BeautifulSoup, url: str) -> Dict[str, Any]:
         """Extract book data."""
@@ -61,25 +61,25 @@ class ChamplainSocietyCollectionTranslator:
             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.find('table')
+        table = doc.find("table")
         if table:
-            rows = table.find_all('tr')
+            rows = table.find_all("tr")
             for row in rows:
-                header = row.find('b')
-                value_cell = row.find_all('td')
+                header = row.find("b")
+                value_cell = row.find_all("td")
 
                 if header and len(value_cell) >= 2:
-                    field_title = header.get_text().strip().replace('\s+', '')
+                    field_title = header.get_text().strip().replace("\s+", "")
                     field_value = value_cell[1].get_text().strip()
 
                     # Normalize French to English
@@ -87,84 +87,86 @@ class ChamplainSocietyCollectionTranslator:
                     data_tags[field_title] = field_value
 
         # Process authors
-        if 'Author:' in data_tags:
-            author_text = data_tags['Author:']
-            if '; ' in author_text:
-                authors = author_text.split('; ')
+        if "Author:" in data_tags:
+            author_text = data_tags["Author:"]
+            if "; " in author_text:
+                authors = author_text.split("; ")
             else:
                 authors = [author_text]
 
             for author in authors:
                 author = author.strip()
-                if ', ' in author:
-                    parts = author.split(', ', 1)
-                    first_name = parts[1] if len(parts) > 1 else ''
+                if ", " in author:
+                    parts = author.split(", ", 1)
+                    first_name = parts[1] if len(parts) > 1 else ""
                     last_name = parts[0]
-                    item['creators'].append({
-                        'firstName': first_name,
-                        'lastName': last_name,
-                        'creatorType': 'author'
-                    })
+                    item["creators"].append(
+                        {
+                            "firstName": first_name,
+                            "lastName": last_name,
+                            "creatorType": "author",
+                        }
+                    )
                 else:
-                    item['creators'].append({
-                        'lastName': author,
-                        'creatorType': 'author',
-                        'fieldMode': True
-                    })
+                    item["creators"].append(
+                        {"lastName": author, "creatorType": "author", "fieldMode": True}
+                    )
 
         # Process published information
-        if 'Published:' in data_tags:
-            published = data_tags['Published:']
+        if "Published:" in data_tags:
+            published = data_tags["Published:"]
 
             # Extract place
-            if ': ' in published:
-                place_end = published.index(': ')
-                item['place'] = published[:place_end]
-                remainder = published[place_end + 2:]
+            if ": " in published:
+                place_end = published.index(": ")
+                item["place"] = published[:place_end]
+                remainder = published[place_end + 2 :]
 
                 # Extract date and publisher
-                if ', ' in remainder:
-                    date_start = remainder.rfind(', ')
-                    item['date'] = remainder[date_start + 2:]
-                    item['publisher'] = remainder[:date_start]
+                if ", " in remainder:
+                    date_start = remainder.rfind(", ")
+                    item["date"] = remainder[date_start + 2 :]
+                    item["publisher"] = remainder[:date_start]
                 else:
-                    item['publisher'] = remainder
+                    item["publisher"] = remainder
 
         # Process subjects/tags
-        if 'Subjects:' in data_tags:
-            subjects = data_tags['Subjects:'].split('\n')
+        if "Subjects:" in data_tags:
+            subjects = data_tags["Subjects:"].split("\n")
             for subject in subjects:
                 subject = subject.strip()
-                if subject and re.search(r'\w', subject):
-                    item['tags'].append({'tag': subject})
+                if subject and re.search(r"\w", subject):
+                    item["tags"].append({"tag": subject})
 
         # Other fields
-        self._associate_data(item, data_tags, 'Extent:', 'pages')
-        self._associate_data(item, data_tags, 'ID:', 'callNumber')
-        self._associate_data(item, data_tags, 'Notes:', 'abstractNote')
+        self._associate_data(item, data_tags, "Extent:", "pages")
+        self._associate_data(item, data_tags, "ID:", "callNumber")
+        self._associate_data(item, data_tags, "Notes:", "abstractNote")
 
         # Title
-        if 'Title:' in data_tags:
-            item['title'] = data_tags['Title:']
+        if "Title:" in data_tags:
+            item["title"] = data_tags["Title:"]
         elif doc.title:
-            item['title'] = doc.title.string
+            item["title"] = doc.title.string
         else:
-            item['title'] = 'No Title Found: Champlain Collection'
+            item["title"] = "No Title Found: Champlain Collection"
 
         return item
 
     def _normalize_field_name(self, field_name: str) -> str:
         """Normalize French field names to English."""
         mapping = {
-            'Auteur:': 'Author:',
-            'Titre:': 'Title:',
-            'Description:': 'Extent:',
-            'Éditeur:': 'Published:',
-            'Sujet:': 'Subjects:'
+            "Auteur:": "Author:",
+            "Titre:": "Title:",
+            "Description:": "Extent:",
+            "Éditeur:": "Published:",
+            "Sujet:": "Subjects:",
         }
         return mapping.get(field_name, field_name)
 
-    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/Chicago_Journal_of_Theoretical_Computer_Science.py

@@ -34,11 +34,15 @@ class ChicagoJournalOfTheoreticalComputerScienceTranslator:
         "inRepository": True,
         "translatorType": 4,
         "browserSupport": "gcsibv",
-        "lastUpdated": "2025-05-14 00:10:19"
+        "lastUpdated": "2025-05-14 00:10:19",
     }
 
-    SINGLE_RE = re.compile(r'^https?://cjtcs\.cs\.uchicago\.edu/articles/\w+/\d+/contents\.html')
-    MULTIPLE_RE = re.compile(r'^https?://cjtcs\.cs\.uchicago\.edu/articles/\w+/contents\.html')
+    SINGLE_RE = re.compile(
+        r"^https?://cjtcs\.cs\.uchicago\.edu/articles/\w+/\d+/contents\.html"
+    )
+    MULTIPLE_RE = re.compile(
+        r"^https?://cjtcs\.cs\.uchicago\.edu/articles/\w+/contents\.html"
+    )
 
     def detect_web(self, doc: BeautifulSoup, url: str) -> str:
         """Detect if page is an article or volume contents."""
@@ -46,17 +50,21 @@ class ChicagoJournalOfTheoreticalComputerScienceTranslator:
             # Check for article links
             article_links = doc.select('ul > li > ul > li a[href*="contents.html"]')
             if article_links:
-                return 'multiple'
+                return "multiple"
         elif self.SINGLE_RE.match(url):
-            return 'journalArticle'
+            return "journalArticle"
 
-        return ''
+        return ""
 
-    async def do_web(self, doc: BeautifulSoup, url: str, request_text_func) -> Dict[str, Any]:
+    async def do_web(
+        self, doc: BeautifulSoup, url: str, request_text_func
+    ) -> Dict[str, Any]:
         """Extract article data."""
         return await self.scrape(doc, url, request_text_func)
 
-    async def scrape(self, doc: BeautifulSoup, url: str, request_text_func) -> Dict[str, Any]:
+    async def scrape(
+        self, doc: BeautifulSoup, url: str, request_text_func
+    ) -> Dict[str, Any]:
         """
         Scrape article data by fetching and parsing BibTeX.
 
@@ -69,18 +77,18 @@ class ChicagoJournalOfTheoreticalComputerScienceTranslator:
             Dictionary containing article metadata
         """
         item = {
-            'itemType': 'journalArticle',
-            'creators': [],
-            'tags': [],
-            'attachments': []
+            "itemType": "journalArticle",
+            "creators": [],
+            "tags": [],
+            "attachments": [],
         }
 
         # Find BibTeX link
         bib_link = doc.select_one('a[href$=".bib"]')
-        if bib_link and bib_link.get('href'):
-            bib_url = bib_link['href']
-            if not bib_url.startswith('http'):
-                bib_url = 'http://cjtcs.cs.uchicago.edu' + bib_url
+        if bib_link and bib_link.get("href"):
+            bib_url = bib_link["href"]
+            if not bib_url.startswith("http"):
+                bib_url = "http://cjtcs.cs.uchicago.edu" + bib_url
 
             # Fetch BibTeX
             bib_text = await request_text_func(bib_url)
@@ -92,103 +100,111 @@ class ChicagoJournalOfTheoreticalComputerScienceTranslator:
 
         # Extract DOI
         doi_link = doc.select_one('a[href*="dx.doi.org"]')
-        if doi_link and doi_link.get('href'):
-            doi_url = doi_link['href']
-            item['DOI'] = re.sub(r'https?://(?:dx\.)?doi\.org/', '', doi_url)
+        if doi_link and doi_link.get("href"):
+            doi_url = doi_link["href"]
+            item["DOI"] = re.sub(r"https?://(?:dx\.)?doi\.org/", "", doi_url)
 
         # Add PDF attachment if available
         pdf_link = doc.select_one('a[href$=".pdf"]')
-        if pdf_link and pdf_link.get('href'):
-            pdf_url = pdf_link['href']
-            if not pdf_url.startswith('http'):
-                pdf_url = 'http://cjtcs.cs.uchicago.edu' + pdf_url
-            item['attachments'].append({
-                'url': pdf_url,
-                'title': 'Full Text PDF',
-                'mimeType': 'application/pdf'
-            })
+        if pdf_link and pdf_link.get("href"):
+            pdf_url = pdf_link["href"]
+            if not pdf_url.startswith("http"):
+                pdf_url = "http://cjtcs.cs.uchicago.edu" + pdf_url
+            item["attachments"].append(
+                {
+                    "url": pdf_url,
+                    "title": "Full Text PDF",
+                    "mimeType": "application/pdf",
+                }
+            )
         else:
             # Add snapshot if no PDF
-            item['attachments'].append({
-                'title': 'Snapshot',
-                'mimeType': 'text/html',
-                'url': url
-            })
+            item["attachments"].append(
+                {"title": "Snapshot", "mimeType": "text/html", "url": url}
+            )
 
         return item
 
     def _fix_author_line(self, bib_text: str) -> str:
         """Fix BibTeX author line if missing equals sign."""
-        lines = bib_text.split('\n')
+        lines = bib_text.split("\n")
         fixed_lines = []
         for line in lines:
             # Add equals sign after "author" if missing
-            fixed_line = re.sub(r'^(\s*author)(?!\s*=)', r'\1=', line)
+            fixed_line = re.sub(r"^(\s*author)(?!\s*=)", r"\1=", line)
             fixed_lines.append(fixed_line)
-        return '\n'.join(fixed_lines)
+        return "\n".join(fixed_lines)
 
     def _parse_bibtex(self, bib_text: str, item: Dict[str, Any]):
         """Parse BibTeX and fill item fields."""
         # Simple BibTeX parser
         # Extract title
-        title_match = re.search(r'title\s*=\s*[{"](.*?)[}"]', bib_text, re.IGNORECASE | re.DOTALL)
+        title_match = re.search(
+            r'title\s*=\s*[{"](.*?)[}"]', bib_text, re.IGNORECASE | re.DOTALL
+        )
         if title_match:
-            item['title'] = title_match.group(1).strip()
+            item["title"] = title_match.group(1).strip()
 
         # Extract authors
-        author_match = re.search(r'author\s*=\s*[{"](.*?)[}"]', bib_text, re.IGNORECASE | re.DOTALL)
+        author_match = re.search(
+            r'author\s*=\s*[{"](.*?)[}"]', bib_text, re.IGNORECASE | re.DOTALL
+        )
         if author_match:
             authors = author_match.group(1).strip()
             # Split by 'and'
-            for author in authors.split(' and '):
+            for author in authors.split(" and "):
                 author = author.strip()
                 if author:
-                    item['creators'].append(self._parse_author(author))
+                    item["creators"].append(self._parse_author(author))
 
         # Extract year/date
         year_match = re.search(r'year\s*=\s*[{"](.*?)[}"]', bib_text, re.IGNORECASE)
         if year_match:
-            item['date'] = year_match.group(1).strip()
+            item["date"] = year_match.group(1).strip()
 
         # Extract volume
         volume_match = re.search(r'volume\s*=\s*[{"](.*?)[}"]', bib_text, re.IGNORECASE)
         if volume_match:
-            item['volume'] = volume_match.group(1).strip()
+            item["volume"] = volume_match.group(1).strip()
 
         # Extract issue/number
-        issue_match = re.search(r'(?:issue|number)\s*=\s*[{"](.*?)[}"]', bib_text, re.IGNORECASE)
+        issue_match = re.search(
+            r'(?:issue|number)\s*=\s*[{"](.*?)[}"]', bib_text, re.IGNORECASE
+        )
         if issue_match:
-            item['issue'] = issue_match.group(1).strip()
+            item["issue"] = issue_match.group(1).strip()
 
         # Extract journal
-        journal_match = re.search(r'journal\s*=\s*[{"](.*?)[}"]', bib_text, re.IGNORECASE)
+        journal_match = re.search(
+            r'journal\s*=\s*[{"](.*?)[}"]', bib_text, re.IGNORECASE
+        )
         if journal_match:
-            item['publicationTitle'] = journal_match.group(1).strip()
+            item["publicationTitle"] = journal_match.group(1).strip()
 
     def _parse_author(self, author_str: str) -> Dict[str, Any]:
         """Parse author name from BibTeX format."""
         author_str = author_str.strip()
 
         # Handle "Last, First" format
-        if ',' in author_str:
-            parts = author_str.split(',', 1)
+        if "," in author_str:
+            parts = author_str.split(",", 1)
             return {
-                'firstName': parts[1].strip() if len(parts) > 1 else '',
-                'lastName': parts[0].strip(),
-                'creatorType': 'author'
+                "firstName": parts[1].strip() if len(parts) > 1 else "",
+                "lastName": parts[0].strip(),
+                "creatorType": "author",
             }
         else:
             # Handle "First Last" format
             parts = author_str.split()
             if len(parts) >= 2:
                 return {
-                    'firstName': ' '.join(parts[:-1]),
-                    'lastName': parts[-1],
-                    'creatorType': 'author'
+                    "firstName": " ".join(parts[:-1]),
+                    "lastName": parts[-1],
+                    "creatorType": "author",
                 }
             else:
                 return {
-                    'lastName': author_str,
-                    'creatorType': 'author',
-                    'fieldMode': True
+                    "lastName": author_str,
+                    "creatorType": "author",
+                    "fieldMode": True,
                 }