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

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

@@ -40,7 +40,7 @@ class ORCIDTranslator:
     # XML namespaces used in ORCID API responses
     NAMESPACES = {
         "work": "http://www.orcid.org/ns/work",
-        "activities": "http://www.orcid.org/ns/activities"
+        "activities": "http://www.orcid.org/ns/activities",
     }
 
     @classmethod
@@ -71,7 +71,7 @@ class ORCIDTranslator:
             return None
 
         # Check for work list
-        works = await page.query_selector_all('ul#body-work-list > li')
+        works = await page.query_selector_all("ul#body-work-list > li")
         if works:
             return "multiple"
 
@@ -96,12 +96,13 @@ class ORCIDTranslator:
             return None
 
         # Remove URL prefix if present and clean extra UI text
-        orcid = orcid_text.replace('https://orcid.org/', '').strip()
+        orcid = orcid_text.replace("https://orcid.org/", "").strip()
 
         # Extract just the ORCID ID pattern (0000-0000-0000-0000)
         # Remove any extra text like "content_copyprint" that might be from UI elements
         import re
-        match = re.search(r'\d{4}-\d{4}-\d{4}-\d{3}[\dX]', orcid)
+
+        match = re.search(r"\d{4}-\d{4}-\d{4}-\d{3}[\dX]", orcid)
         if match:
             return match.group(0)
 
@@ -129,12 +130,12 @@ class ORCIDTranslator:
         put_codes = {}
 
         # Find all work groups
-        for group in root.findall('.//activities:group', cls.NAMESPACES):
+        for group in root.findall(".//activities:group", cls.NAMESPACES):
             # Get first work summary in the group
-            work_summary = group.find('./work:work-summary', cls.NAMESPACES)
+            work_summary = group.find("./work:work-summary", cls.NAMESPACES)
             if work_summary is not None:
-                code = work_summary.get('put-code')
-                title_elem = work_summary.find('.//work:title', cls.NAMESPACES)
+                code = work_summary.get("put-code")
+                title_elem = work_summary.find(".//work:title", cls.NAMESPACES)
                 if code and title_elem is not None and title_elem.text:
                     put_codes[code] = title_elem.text.strip()
 
@@ -153,9 +154,7 @@ class ORCIDTranslator:
         """
         url = f"{cls.API_BASE}/{orcid}/work/{put_code}"
 
-        headers = {
-            "Accept": "application/vnd.citationstyles.csl+json"
-        }
+        headers = {"Accept": "application/vnd.citationstyles.csl+json"}
 
         try:
             async with httpx.AsyncClient() as client:
@@ -266,14 +265,16 @@ if __name__ == "__main__":
                     # Fetch metadata for first work
                     first_code = list(works.keys())[0]
                     print(f"\nFetching metadata for work {first_code}...")
-                    metadata = await ORCIDTranslator.fetch_work_metadata(orcid, first_code)
+                    metadata = await ORCIDTranslator.fetch_work_metadata(
+                        orcid, first_code
+                    )
 
                     if metadata:
                         print(f"Metadata keys: {list(metadata.keys())}")
-                        if 'title' in metadata:
+                        if "title" in metadata:
                             print(f"Title: {metadata['title']}")
-                        if 'author' in metadata:
-                            authors = metadata['author']
+                        if "author" in metadata:
+                            authors = metadata["author"]
                             if isinstance(authors, list) and authors:
                                 print(f"First author: {authors[0]}")
 

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

@@ -71,21 +71,23 @@ class OxfordTranslator(BaseTranslator):
                 'a[href*="/pdf/"]',
                 'a:has-text("Download PDF")',
                 'a:has-text("PDF")',
-                '.download-pdf a',
-                'a.pdf-link'
+                ".download-pdf a",
+                "a.pdf-link",
             ]
 
             for selector in pdf_selectors:
                 try:
-                    pdf_link = await page.locator(selector).first.get_attribute('href', timeout=1000)
+                    pdf_link = await page.locator(selector).first.get_attribute(
+                        "href", timeout=1000
+                    )
                     if pdf_link:
                         # Make absolute URL if needed
-                        if pdf_link.startswith('/'):
-                            base_url = await page.evaluate('window.location.origin')
+                        if pdf_link.startswith("/"):
+                            base_url = await page.evaluate("window.location.origin")
                             pdf_link = f"{base_url}{pdf_link}"
-                        elif not pdf_link.startswith('http'):
-                            base_url = await page.evaluate('window.location.href')
-                            base_url = re.sub(r'/[^/]*$', '', base_url)
+                        elif not pdf_link.startswith("http"):
+                            base_url = await page.evaluate("window.location.href")
+                            base_url = re.sub(r"/[^/]*$", "", base_url)
                             pdf_link = f"{base_url}/{pdf_link}"
 
                         pdf_urls.append(pdf_link)
@@ -102,19 +104,21 @@ class OxfordTranslator(BaseTranslator):
                 'a[href*="lookinside"]',
                 'a:has-text("Look Inside")',
                 'a:has-text("Preview")',
-                '.book-preview a'
+                ".book-preview a",
             ]
 
             for selector in preview_selectors:
                 try:
-                    preview_link = await page.locator(selector).first.get_attribute('href', timeout=1000)
-                    if preview_link and '.pdf' in preview_link.lower():
-                        if preview_link.startswith('/'):
-                            base_url = await page.evaluate('window.location.origin')
+                    preview_link = await page.locator(selector).first.get_attribute(
+                        "href", timeout=1000
+                    )
+                    if preview_link and ".pdf" in preview_link.lower():
+                        if preview_link.startswith("/"):
+                            base_url = await page.evaluate("window.location.origin")
                             preview_link = f"{base_url}{preview_link}"
-                        elif not preview_link.startswith('http'):
-                            base_url = await page.evaluate('window.location.href')
-                            base_url = re.sub(r'/[^/]*$', '', base_url)
+                        elif not preview_link.startswith("http"):
+                            base_url = await page.evaluate("window.location.href")
+                            base_url = re.sub(r"/[^/]*$", "", base_url)
                             preview_link = f"{base_url}/{preview_link}"
 
                         pdf_urls.append(preview_link)
@@ -127,13 +131,15 @@ class OxfordTranslator(BaseTranslator):
         # Method 3: Extract ISBN and attempt to construct PDF URL
         # (Usually doesn't work for OUP, but worth trying)
         try:
-            isbn_text = await page.locator('p:has-text("ISBN:")').first.inner_text(timeout=2000)
-            isbn_match = re.search(r'ISBN:\s*(\d{10,13})', isbn_text)
+            isbn_text = await page.locator('p:has-text("ISBN:")').first.inner_text(
+                timeout=2000
+            )
+            isbn_match = re.search(r"ISBN:\s*(\d{10,13})", isbn_text)
             if isbn_match:
                 isbn = isbn_match.group(1)
                 # Some academic publishers provide PDFs via ISBN
                 # This is speculative and may not work
-                base_url = await page.evaluate('window.location.origin')
+                base_url = await page.evaluate("window.location.origin")
                 potential_pdf = f"{base_url}/academic/pdf/{isbn}.pdf"
                 # We don't add this speculatively without verification
         except Exception:

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

@@ -12,7 +12,9 @@ class OxfordDictionariesPremiumTranslator(BaseTranslator):
     """Oxford Dictionaries Premium."""
 
     LABEL = "Oxford Dictionaries Premium"
-    URL_TARGET_PATTERN = r"^https?://premium\.oxforddictionaries\.com/(translate|definition)/"
+    URL_TARGET_PATTERN = (
+        r"^https?://premium\.oxforddictionaries\.com/(translate|definition)/"
+    )
 
     @classmethod
     def matches_url(cls, url: str) -> bool:

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

@@ -12,7 +12,9 @@ class OzonRuTranslator(BaseTranslator):
     """OZON.ru."""
 
     LABEL = "OZON.ru"
-    URL_TARGET_PATTERN = r"^https?://www\.ozon\.ru/(context/detail/id/|\?context=search)"
+    URL_TARGET_PATTERN = (
+        r"^https?://www\.ozon\.ru/(context/detail/id/|\?context=search)"
+    )
 
     @classmethod
     def matches_url(cls, url: str) -> bool:

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

@@ -60,7 +60,7 @@ class PLoSTranslator(BaseTranslator):
         try:
             pdf_url = await page.locator(
                 'meta[name="citation_pdf_url"]'
-            ).first.get_attribute('content', timeout=3000)
+            ).first.get_attribute("content", timeout=3000)
             if pdf_url:
                 pdf_urls.append(pdf_url)
                 return pdf_urls
@@ -72,11 +72,11 @@ class PLoSTranslator(BaseTranslator):
         try:
             pdf_link = await page.locator(
                 'a[href*="/article/file"][href*="type=printable"]'
-            ).first.get_attribute('href', timeout=2000)
+            ).first.get_attribute("href", timeout=2000)
             if pdf_link:
                 # Make absolute URL if needed
-                if pdf_link.startswith('/'):
-                    base_url = await page.evaluate('window.location.origin')
+                if pdf_link.startswith("/"):
+                    base_url = await page.evaluate("window.location.origin")
                     pdf_link = f"{base_url}{pdf_link}"
                 pdf_urls.append(pdf_link)
                 return pdf_urls
@@ -86,18 +86,15 @@ class PLoSTranslator(BaseTranslator):
         # Method 3: Construct PDF URL from DOI if present
         # Pattern: https://journals.plos.org/journal/article/file?id=DOI&type=printable
         try:
-            doi = await page.locator(
-                'meta[name="citation_doi"]'
-            ).first.get_attribute('content', timeout=2000)
-            current_url = await page.evaluate('window.location.href')
+            doi = await page.locator('meta[name="citation_doi"]').first.get_attribute(
+                "content", timeout=2000
+            )
+            current_url = await page.evaluate("window.location.href")
 
             if doi:
                 # Extract journal name from URL
                 # Pattern: journals.plos.org/{journal}/article?id=...
-                journal_match = re.search(
-                    r'journals\.plos\.org/([^/]+)/',
-                    current_url
-                )
+                journal_match = re.search(r"journals\.plos\.org/([^/]+)/", current_url)
                 if journal_match:
                     journal = journal_match.group(1)
                     pdf_url = f"https://journals.plos.org/{journal}/article/file?id={doi}&type=printable"

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

@@ -12,7 +12,9 @@ class PolygonTranslator(BaseTranslator):
     """Polygon."""
 
     LABEL = "Polygon"
-    URL_TARGET_PATTERN = r"^https?://(www\.)?(polygon|heroesneverdie|riftherald|theflyingcourier)\.com"
+    URL_TARGET_PATTERN = (
+        r"^https?://(www\.)?(polygon|heroesneverdie|riftherald|theflyingcourier)\.com"
+    )
 
     @classmethod
     def matches_url(cls, url: str) -> bool:

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

@@ -12,7 +12,9 @@ class PrimoTranslator(BaseTranslator):
     """Primo."""
 
     LABEL = "Primo"
-    URL_TARGET_PATTERN = r"/primo_library/|/nebis/|^https?://www\.recherche-portal\.ch/zbz/"
+    URL_TARGET_PATTERN = (
+        r"/primo_library/|/nebis/|^https?://www\.recherche-portal\.ch/zbz/"
+    )
 
     @classmethod
     def matches_url(cls, url: str) -> bool:

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

@@ -12,7 +12,9 @@ class ProjectMUSETranslator(BaseTranslator):
     """Project MUSE."""
 
     LABEL = "Project MUSE"
-    URL_TARGET_PATTERN = r"^https?://[^/]*muse\.jhu\.edu/(book/|pub/|article/|issue/|search\?)"
+    URL_TARGET_PATTERN = (
+        r"^https?://[^/]*muse\.jhu\.edu/(book/|pub/|article/|issue/|search\?)"
+    )
 
     @classmethod
     def matches_url(cls, url: str) -> bool:

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

@@ -12,7 +12,9 @@ class PubFactoryJournalsTranslator(BaseTranslator):
     """PubFactory Journals."""
 
     LABEL = "PubFactory Journals"
-    URL_TARGET_PATTERN = r"^https://([^/]+/view/journals/.+\.xml|[^.]*journals\.[^/]+/search)\b"
+    URL_TARGET_PATTERN = (
+        r"^https://([^/]+/view/journals/.+\.xml|[^.]*journals\.[^/]+/search)\b"
+    )
 
     @classmethod
     def matches_url(cls, url: str) -> bool:

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

@@ -56,37 +56,37 @@ class PubMedTranslator(BaseTranslator):
         """
         try:
             content = await page.content()
-            soup = BeautifulSoup(content, 'html.parser')
+            soup = BeautifulSoup(content, "html.parser")
 
             # Strategy 1: meta tags
-            for meta_name in ['ncbi_uidlist', 'ncbi_article_id', 'uid']:
-                meta = soup.find('meta', attrs={'name': meta_name})
-                if meta and meta.get('content'):
-                    pmid = meta['content'].strip()
+            for meta_name in ["ncbi_uidlist", "ncbi_article_id", "uid"]:
+                meta = soup.find("meta", attrs={"name": meta_name})
+                if meta and meta.get("content"):
+                    pmid = meta["content"].strip()
                     if pmid.isdigit():
                         return pmid
 
             # Strategy 2: input element
-            input_elem = soup.find('input', attrs={'id': 'absid'})
-            if input_elem and input_elem.get('value'):
-                pmid = input_elem['value'].strip()
+            input_elem = soup.find("input", attrs={"id": "absid"})
+            if input_elem and input_elem.get("value"):
+                pmid = input_elem["value"].strip()
                 if pmid.isdigit():
                     return pmid
 
             # Strategy 3: link href patterns
-            for rel in ['canonical', 'handheld']:
-                link = soup.find('link', attrs={'rel': rel})
-                if link and link.get('href'):
-                    match = re.search(r'/(\d+)(?:/|$)', link['href'])
+            for rel in ["canonical", "handheld"]:
+                link = soup.find("link", attrs={"rel": rel})
+                if link and link.get("href"):
+                    match = re.search(r"/(\d+)(?:/|$)", link["href"])
                     if match:
                         return match.group(1)
 
             # Strategy 4: bookshelf PubMed record links
-            maincontent = soup.find(id='maincontent')
+            maincontent = soup.find(id="maincontent")
             if maincontent:
-                pubmed_link = maincontent.find('a', attrs={
-                    'title': re.compile(r'PubMed record')
-                })
+                pubmed_link = maincontent.find(
+                    "a", attrs={"title": re.compile(r"PubMed record")}
+                )
                 if pubmed_link:
                     pmid = pubmed_link.get_text(strip=True)
                     if pmid.isdigit():
@@ -94,11 +94,11 @@ class PubMedTranslator(BaseTranslator):
 
             # Strategy 5: URL extraction
             url = page.url
-            match = re.search(r'/pubmed/(\d+)', url)
+            match = re.search(r"/pubmed/(\d+)", url)
             if match:
                 return match.group(1)
 
-            match = re.search(r'pubmed\.ncbi\.nlm\.nih\.gov/(\d+)', url)
+            match = re.search(r"pubmed\.ncbi\.nlm\.nih\.gov/(\d+)", url)
             if match:
                 return match.group(1)
 
@@ -119,11 +119,11 @@ class PubMedTranslator(BaseTranslator):
         """
         try:
             params = {
-                'db': 'PubMed',
-                'tool': 'ZoteroTranslatorsPython',
-                'retmode': 'xml',
-                'rettype': 'citation',
-                'id': pmid
+                "db": "PubMed",
+                "tool": "ZoteroTranslatorsPython",
+                "retmode": "xml",
+                "rettype": "citation",
+                "id": pmid,
             }
 
             async with httpx.AsyncClient(timeout=30.0) as client:
@@ -132,13 +132,16 @@ class PubMedTranslator(BaseTranslator):
                 xml_text = response.text
 
                 # Check if valid PubMed data was returned (case-insensitive)
-                if 'pubmedarticle' not in xml_text.lower() and 'pubmedbookarticle' not in xml_text.lower():
+                if (
+                    "pubmedarticle" not in xml_text.lower()
+                    and "pubmedbookarticle" not in xml_text.lower()
+                ):
                     logger.warning(f"No PubMed data found for PMID {pmid}")
                     return None
 
                 # Parse XML to extract metadata
                 metadata = cls._parse_pubmed_xml(xml_text)
-                metadata['pmid'] = pmid
+                metadata["pmid"] = pmid
                 return metadata
 
         except Exception as e:
@@ -155,54 +158,56 @@ class PubMedTranslator(BaseTranslator):
         Returns:
             Dictionary containing parsed metadata
         """
-        soup = BeautifulSoup(xml_text, 'xml')
+        soup = BeautifulSoup(xml_text, "xml")
         metadata = {}
 
         try:
             # Extract article title
-            article_title = soup.find('ArticleTitle')
+            article_title = soup.find("ArticleTitle")
             if article_title:
-                metadata['title'] = article_title.get_text(strip=True)
+                metadata["title"] = article_title.get_text(strip=True)
 
             # Extract authors
             authors = []
-            for author in soup.find_all('Author'):
-                last_name = author.find('LastName')
-                fore_name = author.find('ForeName')
+            for author in soup.find_all("Author"):
+                last_name = author.find("LastName")
+                fore_name = author.find("ForeName")
                 if last_name:
                     author_name = last_name.get_text(strip=True)
                     if fore_name:
                         author_name = f"{fore_name.get_text(strip=True)} {author_name}"
                     authors.append(author_name)
-            metadata['authors'] = authors
+            metadata["authors"] = authors
 
             # Extract DOI
-            article_ids = soup.find_all('ArticleId', attrs={'IdType': 'doi'})
+            article_ids = soup.find_all("ArticleId", attrs={"IdType": "doi"})
             if article_ids:
-                metadata['doi'] = article_ids[0].get_text(strip=True)
+                metadata["doi"] = article_ids[0].get_text(strip=True)
 
             # Extract abstract
-            abstract = soup.find('AbstractText')
+            abstract = soup.find("AbstractText")
             if abstract:
-                metadata['abstract'] = abstract.get_text(strip=True)
+                metadata["abstract"] = abstract.get_text(strip=True)
 
             # Extract journal information
-            journal = soup.find('Journal')
+            journal = soup.find("Journal")
             if journal:
-                journal_title = journal.find('Title')
+                journal_title = journal.find("Title")
                 if journal_title:
-                    metadata['journal'] = journal_title.get_text(strip=True)
+                    metadata["journal"] = journal_title.get_text(strip=True)
 
-                journal_abbrev = journal.find('ISOAbbreviation')
+                journal_abbrev = journal.find("ISOAbbreviation")
                 if journal_abbrev:
-                    metadata['journal_abbreviation'] = journal_abbrev.get_text(strip=True)
+                    metadata["journal_abbreviation"] = journal_abbrev.get_text(
+                        strip=True
+                    )
 
             # Extract publication date
-            pub_date = soup.find('PubDate')
+            pub_date = soup.find("PubDate")
             if pub_date:
-                year = pub_date.find('Year')
-                month = pub_date.find('Month')
-                day = pub_date.find('Day')
+                year = pub_date.find("Year")
+                month = pub_date.find("Month")
+                day = pub_date.find("Day")
                 date_parts = []
                 if year:
                     date_parts.append(year.get_text(strip=True))
@@ -210,21 +215,21 @@ class PubMedTranslator(BaseTranslator):
                     date_parts.append(month.get_text(strip=True))
                 if day:
                     date_parts.append(day.get_text(strip=True))
-                metadata['date'] = '-'.join(date_parts)
+                metadata["date"] = "-".join(date_parts)
 
             # Extract volume and issue
-            volume = soup.find('Volume')
+            volume = soup.find("Volume")
             if volume:
-                metadata['volume'] = volume.get_text(strip=True)
+                metadata["volume"] = volume.get_text(strip=True)
 
-            issue = soup.find('Issue')
+            issue = soup.find("Issue")
             if issue:
-                metadata['issue'] = issue.get_text(strip=True)
+                metadata["issue"] = issue.get_text(strip=True)
 
             # Extract pages
-            medline_pgn = soup.find('MedlinePgn')
+            medline_pgn = soup.find("MedlinePgn")
             if medline_pgn:
-                metadata['pages'] = medline_pgn.get_text(strip=True)
+                metadata["pages"] = medline_pgn.get_text(strip=True)
 
         except Exception as e:
             logger.error(f"Error parsing PubMed XML: {e}")
@@ -242,31 +247,31 @@ class PubMedTranslator(BaseTranslator):
 
         try:
             content = await page.content()
-            soup = BeautifulSoup(content, 'html.parser')
+            soup = BeautifulSoup(content, "html.parser")
 
             # Look for "Full Text Links" section
-            full_text_section = soup.find('div', class_=re.compile(r'full-text-links'))
+            full_text_section = soup.find("div", class_=re.compile(r"full-text-links"))
             if full_text_section:
-                links = full_text_section.find_all('a', href=True)
+                links = full_text_section.find_all("a", href=True)
                 for link in links:
-                    href = link['href']
+                    href = link["href"]
                     # Filter for likely PDF links
-                    if any(x in href.lower() for x in ['.pdf', 'download', 'pdf']):
+                    if any(x in href.lower() for x in [".pdf", "download", "pdf"]):
                         pdf_urls.append(href)
 
             # Look for LinkOut resources
-            linkout_section = soup.find('div', attrs={'id': 'link-out'})
+            linkout_section = soup.find("div", attrs={"id": "link-out"})
             if linkout_section:
-                links = linkout_section.find_all('a', href=True)
+                links = linkout_section.find_all("a", href=True)
                 for link in links:
-                    href = link['href']
-                    if 'pdf' in href.lower():
+                    href = link["href"]
+                    if "pdf" in href.lower():
                         pdf_urls.append(href)
 
             # PMC (PubMed Central) link - free full text
-            pmc_link = soup.find('a', attrs={'data-ga-action': 'PMC article'})
-            if pmc_link and pmc_link.get('href'):
-                pdf_urls.append(pmc_link['href'])
+            pmc_link = soup.find("a", attrs={"data-ga-action": "PMC article"})
+            if pmc_link and pmc_link.get("href"):
+                pdf_urls.append(pmc_link["href"])
 
         except Exception as e:
             logger.error(f"Error extracting PDF URLs: {e}")
@@ -292,7 +297,7 @@ async def main():
             page = await browser.new_page()
 
             try:
-                await page.goto(test_url, wait_until='domcontentloaded', timeout=30000)
+                await page.goto(test_url, wait_until="domcontentloaded", timeout=30000)
 
                 # Extract PMID
                 pmid = await PubMedTranslator.extract_pmid_from_page(page)
@@ -321,4 +326,5 @@ async def main():
 
 if __name__ == "__main__":
     import asyncio
+
     asyncio.run(main())

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

@@ -12,7 +12,9 @@ class PubMedCentralTranslator(BaseTranslator):
     """PubMed Central."""
 
     LABEL = "PubMed Central"
-    URL_TARGET_PATTERN = r"^https://(www\.)?(pmc\.ncbi\.nlm\.nih\.gov/|ncbi\.nlm\.nih\.gov/pmc)"
+    URL_TARGET_PATTERN = (
+        r"^https://(www\.)?(pmc\.ncbi\.nlm\.nih\.gov/|ncbi\.nlm\.nih\.gov/pmc)"
+    )
 
     @classmethod
     def matches_url(cls, url: str) -> bool:
@@ -37,7 +39,7 @@ class PubMedCentralTranslator(BaseTranslator):
         current_url = page.url
 
         # Check if already viewing a PDF
-        if re.search(r'/pdf/.+\.pdf', current_url):
+        if re.search(r"/pdf/.+\.pdf", current_url):
             return [current_url]
 
         # Try multiple selectors (from JavaScript translator lines 70-74)
@@ -53,12 +55,12 @@ class PubMedCentralTranslator(BaseTranslator):
             try:
                 elements = await page.query_selector_all(selector)
                 for element in elements:
-                    href = await element.get_attribute('href')
-                    if href and '.pdf' in href.lower():
+                    href = await element.get_attribute("href")
+                    if href and ".pdf" in href.lower():
                         # Make absolute URL if relative
-                        if href.startswith('/'):
+                        if href.startswith("/"):
                             href = f"https://www.ncbi.nlm.nih.gov{href}"
-                        elif not href.startswith('http'):
+                        elif not href.startswith("http"):
                             href = f"https://www.ncbi.nlm.nih.gov/pmc/{href}"
 
                         if href not in pdf_urls:

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

@@ -12,7 +12,9 @@ class RechtspraakNlTranslator(BaseTranslator):
     """Rechtspraak.nl."""
 
     LABEL = "Rechtspraak.nl"
-    URL_TARGET_PATTERN = r"^https?://(uitspraken\.rechtspraak|linkeddata\.overheid)\.nl/"
+    URL_TARGET_PATTERN = (
+        r"^https?://(uitspraken\.rechtspraak|linkeddata\.overheid)\.nl/"
+    )
 
     @classmethod
     def matches_url(cls, url: str) -> bool: