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

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

@@ -34,18 +34,18 @@ class CornellLIITranslator:
         "inRepository": True,
         "translatorType": 4,
         "browserSupport": "gcsbv",
-        "lastUpdated": "2013-02-09 12:09:10"
+        "lastUpdated": "2013-02-09 12:09:10",
     }
 
     def detect_web(self, doc: BeautifulSoup, url: str) -> str:
         """Detect if the page contains case law."""
-        lii_regexp = re.compile(r'/supct/html/.+')
+        lii_regexp = re.compile(r"/supct/html/.+")
         if lii_regexp.search(url):
             return "case"
         else:
             # Check for links to cases
-            for a in doc.find_all('a', href=True):
-                if lii_regexp.search(a['href']):
+            for a in doc.find_all("a", href=True):
+                if lii_regexp.search(a["href"]):
                     return "multiple"
         return ""
 
@@ -58,104 +58,108 @@ class CornellLIITranslator:
     def scrape(self, doc: BeautifulSoup, url: str) -> Dict[str, Any]:
         """Scrape case data from the document."""
         item = {
-            'itemType': 'case',
-            'url': url,
-            'language': 'en-us',
-            'court': 'U.S. Supreme Court',
-            'reporter': 'U.S.',
-            'creators': [],
-            'tags': [],
-            'attachments': [],
-            'notes': []
+            "itemType": "case",
+            "url": url,
+            "language": "en-us",
+            "court": "U.S. Supreme Court",
+            "reporter": "U.S.",
+            "creators": [],
+            "tags": [],
+            "attachments": [],
+            "notes": [],
         }
 
         # Extract casename
-        casename_meta = doc.find('meta', {'name': 'CASENAME'})
-        if casename_meta and casename_meta.get('content'):
-            casename = casename_meta['content']
-            item['title'] = casename
-            item['caseName'] = casename
+        casename_meta = doc.find("meta", {"name": "CASENAME"})
+        if casename_meta and casename_meta.get("content"):
+            casename = casename_meta["content"]
+            item["title"] = casename
+            item["caseName"] = casename
             # Capitalize properly
             casename_lower = casename.lower()
-            casename_capitalized = ' '.join([word.capitalize() for word in casename_lower.split()])
-            casename_capitalized = casename_capitalized.replace(' V. ', ' v. ')
-            item['caseName'] = casename_capitalized
-            item['shortTitle'] = casename_capitalized
+            casename_capitalized = " ".join(
+                [word.capitalize() for word in casename_lower.split()]
+            )
+            casename_capitalized = casename_capitalized.replace(" V. ", " v. ")
+            item["caseName"] = casename_capitalized
+            item["shortTitle"] = casename_capitalized
 
         # Extract history
-        history_meta = doc.find('meta', {'name': 'COURTBELOW'})
-        if history_meta and history_meta.get('content'):
-            item['history'] = history_meta['content']
+        history_meta = doc.find("meta", {"name": "COURTBELOW"})
+        if history_meta and history_meta.get("content"):
+            item["history"] = history_meta["content"]
 
         # Extract judge/author
-        author_meta = doc.find('meta', attrs={'name': re.compile('AUTHOR', re.I)})
+        author_meta = doc.find("meta", attrs={"name": re.compile("AUTHOR", re.I)})
         if author_meta:
-            author = author_meta.get('content', 'Author Not Provided')
-            item['creators'].append({
-                'lastName': author if author else 'Author Not Provided',
-                'creatorType': 'judge',
-                'fieldMode': True
-            })
+            author = author_meta.get("content", "Author Not Provided")
+            item["creators"].append(
+                {
+                    "lastName": author if author else "Author Not Provided",
+                    "creatorType": "judge",
+                    "fieldMode": True,
+                }
+            )
 
         # Extract tags from GROUP meta tags
-        for tag_meta in doc.find_all('meta', attrs={'name': re.compile('GROUP', re.I)}):
-            tag_value = tag_meta.get('content')
+        for tag_meta in doc.find_all("meta", attrs={"name": re.compile("GROUP", re.I)}):
+            tag_value = tag_meta.get("content")
             if tag_value:
-                item['tags'].append({'tag': tag_value})
+                item["tags"].append({"tag": tag_value})
 
         # Parse decision date
-        decdate_meta = doc.find('meta', attrs={'name': re.compile('DECDATE', re.I)})
+        decdate_meta = doc.find("meta", attrs={"name": re.compile("DECDATE", re.I)})
         if decdate_meta:
-            decdate = decdate_meta.get('content', '')
+            decdate = decdate_meta.get("content", "")
             # Parse format like "January 15, 2003"
-            date_match = re.match(r'(\w+)\s+(\d+),\s+(\d+)', decdate)
+            date_match = re.match(r"(\w+)\s+(\d+),\s+(\d+)", decdate)
             if date_match:
                 month, day, year = date_match.groups()
-                item['dateDecided'] = f"{year} {month} {day}"
+                item["dateDecided"] = f"{year} {month} {day}"
 
         # Create attachment to PDF
-        pdf_match = re.match(r'^(.+)/html/(.+)(\.Z\w+)\.html$', url)
+        pdf_match = re.match(r"^(.+)/html/(.+)(\.Z\w+)\.html$", url)
         if pdf_match:
-            pdf_url = f"{pdf_match.group(1)}/pdf/{pdf_match.group(2)}P{pdf_match.group(3)}"
-            item['attachments'].append({
-                'url': pdf_url,
-                'title': 'PDF version',
-                'mimeType': 'application/pdf'
-            })
+            pdf_url = (
+                f"{pdf_match.group(1)}/pdf/{pdf_match.group(2)}P{pdf_match.group(3)}"
+            )
+            item["attachments"].append(
+                {"url": pdf_url, "title": "PDF version", "mimeType": "application/pdf"}
+            )
 
         # Parse citation from CASENUMBER
-        cite_elem = doc.find('CASENUMBER')
+        cite_elem = doc.find("CASENUMBER")
         if cite_elem:
             cite_text = cite_elem.get_text()
-            cite_match = re.search(r'([0-9]+)\s+U\.S\.\s+([0-9]+)', cite_text)
+            cite_match = re.search(r"([0-9]+)\s+U\.S\.\s+([0-9]+)", cite_text)
             if cite_match:
-                item['reporterVolume'] = cite_match.group(1)
-                item['firstPage'] = cite_match.group(2)
+                item["reporterVolume"] = cite_match.group(1)
+                item["firstPage"] = cite_match.group(2)
 
         # Look for citation in span.offcite
-        for span in doc.find_all('span', class_='offcite'):
-            cite_match = re.search(r'([0-9]+)\s+U\.S\.\s+([0-9]+)', span.get_text())
+        for span in doc.find_all("span", class_="offcite"):
+            cite_match = re.search(r"([0-9]+)\s+U\.S\.\s+([0-9]+)", span.get_text())
             if cite_match:
-                item['reporterVolume'] = cite_match.group(1)
-                item['firstPage'] = cite_match.group(2)
+                item["reporterVolume"] = cite_match.group(1)
+                item["firstPage"] = cite_match.group(2)
                 break
 
         # Create bluebook citation note
-        if 'reporterVolume' in item and 'firstPage' in item:
-            year = re.search(r'\d{4}', item.get('dateDecided', ''))
-            year_str = year.group(0) if year else ''
+        if "reporterVolume" in item and "firstPage" in item:
+            year = re.search(r"\d{4}", item.get("dateDecided", ""))
+            year_str = year.group(0) if year else ""
             bluebook = f"Bluebook citation: {item.get('shortTitle', '')}, {item['reporterVolume']} U.S. {item['firstPage']}"
             if year_str:
                 bluebook += f" ({year_str})"
             bluebook += "."
-            item['notes'].append({'note': bluebook})
+            item["notes"].append({"note": bluebook})
 
         # Parse disposition
-        disposition_elem = doc.find('DISPOSITION')
+        disposition_elem = doc.find("DISPOSITION")
         if disposition_elem:
             disposition = disposition_elem.get_text().strip()
-            disposition = re.sub(r'\s+', ' ', disposition)
-            item['title'] = f"{item.get('title', '')} ({disposition})"
-            item['caseName'] = f"{item.get('caseName', '')} ({disposition})"
+            disposition = re.sub(r"\s+", " ", disposition)
+            item["title"] = f"{item.get('title', '')} ({disposition})"
+            item["caseName"] = f"{item.get('caseName', '')} ({disposition})"
 
         return item

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

@@ -34,7 +34,7 @@ class CornellUniversityPressTranslator:
         "inRepository": True,
         "translatorType": 4,
         "browserSupport": "gcsibv",
-        "lastUpdated": "2016-09-10 11:32:31"
+        "lastUpdated": "2016-09-10 11:32:31",
     }
 
     def detect_web(self, doc: BeautifulSoup, url: str) -> str:
@@ -53,94 +53,91 @@ class CornellUniversityPressTranslator:
 
     def scrape(self, doc: BeautifulSoup, url: str) -> Dict[str, Any]:
         """Scrape book data from the document."""
-        item = {
-            'itemType': 'book',
-            'creators': [],
-            'tags': [],
-            'attachments': []
-        }
+        item = {"itemType": "book", "creators": [], "tags": [], "attachments": []}
 
         # Extract fields from span.detailbox elements
-        fields = doc.select('span.detailbox')
+        fields = doc.select("span.detailbox")
 
         for field_elem in fields:
             field_name = field_elem.get_text(strip=True)
-            value_elem = field_elem.find_next_sibling('span', class_='DetailLabelText')
+            value_elem = field_elem.find_next_sibling("span", class_="DetailLabelText")
             if not value_elem:
                 continue
 
             value = value_elem.get_text(strip=True)
 
             if field_name == "Title":
-                item['title'] = value
+                item["title"] = value
 
             elif field_name == "Subtitle":
-                if 'title' in item:
-                    item['title'] = f"{item['title']}: {value}"
+                if "title" in item:
+                    item["title"] = f"{item['title']}: {value}"
 
             elif field_name == "Author":
-                item['creators'].append(self._clean_author(value, "author"))
+                item["creators"].append(self._clean_author(value, "author"))
 
             elif field_name == "Authors":
-                authors = value.split(',')
+                authors = value.split(",")
                 for author in authors:
                     author = author.strip()
                     if author:
-                        item['creators'].append(self._clean_author(author, "author"))
+                        item["creators"].append(self._clean_author(author, "author"))
 
             elif field_name == "Edited by":
-                editors = value.split(',')
+                editors = value.split(",")
                 for editor in editors:
                     editor = editor.strip()
                     if editor:
-                        item['creators'].append(self._clean_author(editor, "editor"))
+                        item["creators"].append(self._clean_author(editor, "editor"))
 
             elif field_name == "Translated by":
-                translators = value.split(',')
+                translators = value.split(",")
                 for translator in translators:
                     translator = translator.strip()
                     if translator:
-                        item['creators'].append(self._clean_author(translator, "translator"))
+                        item["creators"].append(
+                            self._clean_author(translator, "translator")
+                        )
 
             elif field_name == "Publisher":
-                item['publisher'] = value
+                item["publisher"] = value
 
             elif field_name == "ISBN-13":
-                item['ISBN'] = value
+                item["ISBN"] = value
 
             elif field_name in ["Publication Date", "Title First Published"]:
-                item['date'] = value
+                item["date"] = value
 
             elif field_name == "Collection":
-                item['series'] = value
+                item["series"] = value
 
             elif field_name in ["Language", "Languages"]:
-                item['language'] = value
+                item["language"] = value
 
             elif field_name in ["Nb of pages", "Main content page count"]:
-                item['numPages'] = value
+                item["numPages"] = value
 
             elif field_name == "BISAC Subject Heading":
-                tags = value.split('\n')
+                tags = value.split("\n")
                 for tag in tags:
-                    tag = re.sub(r'.+/', '', tag).strip()
+                    tag = re.sub(r".+/", "", tag).strip()
                     if tag:
-                        item['tags'].append({'tag': tag})
+                        item["tags"].append({"tag": tag})
 
         # Add default publisher and place if not specified
-        if 'publisher' not in item:
-            item['publisher'] = "Cornell University Press"
-            item['place'] = "Ithaca, NY"
-        elif 'place' not in item:
-            if "Leuven" in item.get('publisher', ''):
-                item['place'] = "Leuven"
+        if "publisher" not in item:
+            item["publisher"] = "Cornell University Press"
+            item["place"] = "Ithaca, NY"
+        elif "place" not in item:
+            if "Leuven" in item.get("publisher", ""):
+                item["place"] = "Leuven"
             else:
-                item['place'] = "Ithaca, NY"
+                item["place"] = "Ithaca, NY"
 
         # Extract abstract
-        abstract_elem = doc.select_one('div#bookpagedescription')
+        abstract_elem = doc.select_one("div#bookpagedescription")
         if abstract_elem:
-            item['abstractNote'] = abstract_elem.get_text(strip=True)
+            item["abstractNote"] = abstract_elem.get_text(strip=True)
 
         return item
 
@@ -151,13 +148,9 @@ class CornellUniversityPressTranslator:
 
         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}

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

@@ -34,25 +34,27 @@ class CourtListenerTranslator:
         "inRepository": True,
         "translatorType": 4,
         "browserSupport": "gcsibv",
-        "lastUpdated": "2025-04-29 03:02:00"
+        "lastUpdated": "2025-04-29 03:02:00",
     }
 
     def detect_web(self, doc: BeautifulSoup, url: str) -> str:
         """Detect if the page contains a case or search results."""
-        if '/opinion/' in url:
-            return 'case'
+        if "/opinion/" in url:
+            return "case"
         elif self._get_search_results(doc, True):
-            return 'multiple'
+            return "multiple"
         return ""
 
-    def _get_search_results(self, doc: BeautifulSoup, check_only: bool = False) -> Dict[str, str]:
+    def _get_search_results(
+        self, doc: BeautifulSoup, check_only: bool = False
+    ) -> Dict[str, str]:
         """Get search results from the page."""
         items = {}
         found = False
-        rows = doc.select('article > h3 > a')
+        rows = doc.select("article > h3 > a")
 
         for row in rows:
-            href = row.get('href')
+            href = row.get("href")
             title = row.get_text(strip=True)
             if not href or not title:
                 continue
@@ -65,96 +67,94 @@ class CourtListenerTranslator:
 
     def do_web(self, doc: BeautifulSoup, url: str) -> List[Dict[str, Any]]:
         """Extract case data."""
-        if self.detect_web(doc, url) == 'case':
+        if self.detect_web(doc, url) == "case":
             return [self.scrape(doc, url)]
         return []
 
     def scrape(self, doc: BeautifulSoup, url: str) -> Dict[str, Any]:
         """Scrape case data from the document."""
         item = {
-            'itemType': 'case',
-            'url': re.sub(r'/\?.*', '', url),  # Remove query parameters
-            'creators': [],
-            'tags': [],
-            'attachments': [],
-            'notes': []
+            "itemType": "case",
+            "url": re.sub(r"/\?.*", "", url),  # Remove query parameters
+            "creators": [],
+            "tags": [],
+            "attachments": [],
+            "notes": [],
         }
 
         # Extract citations
         citations = []
-        for elem in doc.select('li strong'):
-            if 'Citations:' in elem.get_text():
-                for span in elem.find_next_siblings('span'):
+        for elem in doc.select("li strong"):
+            if "Citations:" in elem.get_text():
+                for span in elem.find_next_siblings("span"):
                     citations.append(span.get_text(strip=True))
 
         # Get main citation from center
-        citation_elem = doc.select_one('center b .citation')
+        citation_elem = doc.select_one("center b .citation")
         citation = citation_elem.get_text(strip=True) if citation_elem else ""
 
         # Extract basic fields
-        caption_elem = doc.select_one('#caption')
+        caption_elem = doc.select_one("#caption")
         if caption_elem:
-            item['caseName'] = caption_elem.get_text(strip=True)
+            item["caseName"] = caption_elem.get_text(strip=True)
 
-        court_elem = doc.select_one('.case-court')
+        court_elem = doc.select_one(".case-court")
         if court_elem:
-            item['court'] = court_elem.get_text(strip=True)
+            item["court"] = court_elem.get_text(strip=True)
 
-        reporter_elem = doc.select_one('.citation .reporter')
+        reporter_elem = doc.select_one(".citation .reporter")
         if reporter_elem:
-            item['reporter'] = reporter_elem.get_text(strip=True)
+            item["reporter"] = reporter_elem.get_text(strip=True)
 
-        volume_elem = doc.select_one('.citation .volume')
+        volume_elem = doc.select_one(".citation .volume")
         if volume_elem:
-            item['reporterVolume'] = volume_elem.get_text(strip=True)
+            item["reporterVolume"] = volume_elem.get_text(strip=True)
 
-        page_elem = doc.select_one('.citation .page')
+        page_elem = doc.select_one(".citation .page")
         if page_elem:
-            item['firstPage'] = page_elem.get_text(strip=True)
+            item["firstPage"] = page_elem.get_text(strip=True)
 
         # If reporter elements aren't tagged, parse from citation
-        if not item.get('reporter') and not item.get('reporterVolume'):
+        if not item.get("reporter") and not item.get("reporterVolume"):
             if not citation and citations:
                 citation = citations[0]
 
             if citation:
                 cite_match = re.match(
-                    r'^(\d+)\s((?:[A-Z][a-z]?\.\s?)+(?:[2-3]d)?(?:Supp\.)?)\s(\d{1,4})(,|$)',
-                    citation.strip()
+                    r"^(\d+)\s((?:[A-Z][a-z]?\.\s?)+(?:[2-3]d)?(?:Supp\.)?)\s(\d{1,4})(,|$)",
+                    citation.strip(),
                 )
                 if cite_match:
-                    item['reporterVolume'] = cite_match.group(1)
-                    item['reporter'] = cite_match.group(2)
-                    item['firstPage'] = cite_match.group(3)
+                    item["reporterVolume"] = cite_match.group(1)
+                    item["reporter"] = cite_match.group(2)
+                    item["firstPage"] = cite_match.group(3)
                 else:
-                    item['history'] = citation
+                    item["history"] = citation
 
         # Set history from additional citations
-        if 'history' not in item and len(citations) > 1:
-            item['history'] = ', '.join(citations[1:])
+        if "history" not in item and len(citations) > 1:
+            item["history"] = ", ".join(citations[1:])
 
         # Extract date
-        date_elem = doc.select_one('.case-date-new')
+        date_elem = doc.select_one(".case-date-new")
         if date_elem:
-            item['dateDecided'] = date_elem.get_text(strip=True)
+            item["dateDecided"] = date_elem.get_text(strip=True)
 
         # Extract docket number
-        docket_li = doc.find('li', string=re.compile('Docket Number:'))
+        docket_li = doc.find("li", string=re.compile("Docket Number:"))
         if docket_li:
-            docket_text = ''.join(docket_li.find_all(string=True, recursive=False))
-            item['docketNumber'] = docket_text.strip()
+            docket_text = "".join(docket_li.find_all(string=True, recursive=False))
+            item["docketNumber"] = docket_text.strip()
 
         # Extract authors (judges)
         for author_link in doc.select(".opinion-section-title > a[href*='/person/']"):
             author_name = author_link.get_text(strip=True)
-            item['creators'].append(self._clean_author(author_name, "author"))
+            item["creators"].append(self._clean_author(author_name, "author"))
 
         # Add snapshot attachment
-        item['attachments'].append({
-            'title': 'Full Text',
-            'mimeType': 'text/html',
-            'url': url
-        })
+        item["attachments"].append(
+            {"title": "Full Text", "mimeType": "text/html", "url": url}
+        )
 
         return item
 
@@ -165,13 +165,9 @@ class CourtListenerTranslator:
 
         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': False
-            }
+            return {"lastName": name, "creatorType": creator_type, "fieldMode": False}