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

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

@@ -32,7 +32,7 @@ class CamaraBrasileiraDoLivroISBNTranslator:
         "priority": 98,
         "inRepository": True,
         "translatorType": 8,
-        "lastUpdated": "2023-09-26 16:11:18"
+        "lastUpdated": "2023-09-26 16:11:18",
     }
 
     def detect_search(self, items: List[Dict[str, Any]]) -> bool:
@@ -48,7 +48,9 @@ class CamaraBrasileiraDoLivroISBNTranslator:
         cleaned_items = self._clean_data(items)
         return len(cleaned_items) > 0
 
-    async def do_search(self, items: List[Dict[str, Any]], request_json_func) -> List[Dict[str, Any]]:
+    async def do_search(
+        self, items: List[Dict[str, Any]], request_json_func
+    ) -> List[Dict[str, Any]]:
         """
         Search for books by ISBN.
 
@@ -63,43 +65,43 @@ class CamaraBrasileiraDoLivroISBNTranslator:
         results = []
 
         for item in items:
-            isbn = item.get('ISBN')
+            isbn = item.get("ISBN")
             if not isbn:
                 continue
 
             search = isbn
             if len(isbn) == 10:
-                search += ' OR ' + self._to_isbn13(isbn)
+                search += " OR " + self._to_isbn13(isbn)
 
             body = {
-                'count': True,
-                'facets': [],
-                'filter': '',
-                'orderby': None,
-                'queryType': 'full',
-                'search': search,
-                'searchFields': 'FormattedKey,RowKey',
-                'searchMode': 'any',
-                'select': '*',
-                'skip': 0,
-                'top': 1
+                "count": True,
+                "facets": [],
+                "filter": "",
+                "orderby": None,
+                "queryType": "full",
+                "search": search,
+                "searchFields": "FormattedKey,RowKey",
+                "searchMode": "any",
+                "select": "*",
+                "skip": 0,
+                "top": 1,
             }
 
             headers = {
-                'Content-Type': 'application/json; charset=UTF-8',
-                'api-key': '100216A23C5AEE390338BBD19EA86D29',
-                'Origin': 'https://www.cblservicos.org.br',
-                'Referer': 'https://www.cblservicos.org.br/'
+                "Content-Type": "application/json; charset=UTF-8",
+                "api-key": "100216A23C5AEE390338BBD19EA86D29",
+                "Origin": "https://www.cblservicos.org.br",
+                "Referer": "https://www.cblservicos.org.br/",
             }
 
             response = await request_json_func(
-                'https://isbn-search-br.search.windows.net/indexes/isbn-index/docs/search?api-version=2016-09-01',
-                method='POST',
+                "https://isbn-search-br.search.windows.net/indexes/isbn-index/docs/search?api-version=2016-09-01",
+                method="POST",
                 headers=headers,
-                body=json.dumps(body)
+                body=json.dumps(body),
             )
 
-            for result in response.get('value', []):
+            for result in response.get("value", []):
                 results.append(self._translate_result(result))
 
         return results
@@ -114,79 +116,76 @@ class CamaraBrasileiraDoLivroISBNTranslator:
         Returns:
             Zotero item dictionary
         """
-        item = {
-            'itemType': 'book',
-            'creators': [],
-            'tags': [],
-            'attachments': []
-        }
+        item = {"itemType": "book", "creators": [], "tags": [], "attachments": []}
 
         # Title
-        title = result.get('Title', '')
-        subtitle = result.get('Subtitle', '')
-        if subtitle and ':' not in title and ':' not in subtitle:
-            title += ': ' + subtitle
-        item['title'] = self._fix_case(title)
+        title = result.get("Title", "")
+        subtitle = result.get("Subtitle", "")
+        if subtitle and ":" not in title and ":" not in subtitle:
+            title += ": " + subtitle
+        item["title"] = self._fix_case(title)
 
         # Other fields
-        item['abstractNote'] = result.get('Sinopse', '')
-        item['series'] = self._fix_case(result.get('Colection', ''))
-        item['edition'] = result.get('Edicao', '')
-        if item['edition'] == '1':
-            item['edition'] = ''
+        item["abstractNote"] = result.get("Sinopse", "")
+        item["series"] = self._fix_case(result.get("Colection", ""))
+        item["edition"] = result.get("Edicao", "")
+        if item["edition"] == "1":
+            item["edition"] = ""
 
         # Place
-        cidade = result.get('Cidade', '')
-        uf = result.get('UF', '')
+        cidade = result.get("Cidade", "")
+        uf = result.get("UF", "")
         if cidade or uf:
-            item['place'] = cidade + (', ' + uf if uf else '')
+            item["place"] = cidade + (", " + uf if uf else "")
 
-        item['publisher'] = self._fix_case(result.get('Imprint', ''))
-        item['date'] = self._str_to_iso(result.get('Date', ''))
-        item['numPages'] = result.get('Paginas', '')
-        if item['numPages'] == '0':
-            item['numPages'] = ''
+        item["publisher"] = self._fix_case(result.get("Imprint", ""))
+        item["date"] = self._str_to_iso(result.get("Date", ""))
+        item["numPages"] = result.get("Paginas", "")
+        if item["numPages"] == "0":
+            item["numPages"] = ""
 
         # Language
-        language = result.get('IdiomasObra', [''])[0] if result.get('IdiomasObra') else 'pt-BR'
-        if language == 'português (Brasil)':
-            language = 'pt-BR'
-        item['language'] = language
+        language = (
+            result.get("IdiomasObra", [""])[0] if result.get("IdiomasObra") else "pt-BR"
+        )
+        if language == "português (Brasil)":
+            language = "pt-BR"
+        item["language"] = language
 
-        item['ISBN'] = self._clean_isbn(result.get('FormattedKey', ''))
+        item["ISBN"] = self._clean_isbn(result.get("FormattedKey", ""))
 
         # Authors
-        authors = result.get('Authors', [])
-        profissoes = result.get('Profissoes', [])
+        authors = result.get("Authors", [])
+        profissoes = result.get("Profissoes", [])
 
         for i, author in enumerate(authors):
             if author == author.upper():
                 author = self._capitalize_name(author)
 
-            creator_type = 'author'
+            creator_type = "author"
             if profissoes and len(profissoes) == len(authors):
                 profissao = profissoes[i]
-                if profissao in ['Coordenador', 'Autor', 'Roteirista']:
-                    creator_type = 'author'
-                elif profissao in ['Revisor', 'Organizador', 'Editor']:
-                    creator_type = 'editor'
-                elif profissao == 'Tradutor':
-                    creator_type = 'translator'
-                elif profissao in ['Ilustrador', 'Projeto Gráfico']:
-                    creator_type = 'illustrator'
+                if profissao in ["Coordenador", "Autor", "Roteirista"]:
+                    creator_type = "author"
+                elif profissao in ["Revisor", "Organizador", "Editor"]:
+                    creator_type = "editor"
+                elif profissao == "Tradutor":
+                    creator_type = "translator"
+                elif profissao in ["Ilustrador", "Projeto Gráfico"]:
+                    creator_type = "illustrator"
                 else:
-                    creator_type = 'author' if i == 0 else 'contributor'
+                    creator_type = "author" if i == 0 else "contributor"
             elif i > 0:
-                creator_type = 'contributor'
+                creator_type = "contributor"
 
             creator = self._clean_author(author, creator_type)
-            item['creators'].append(creator)
+            item["creators"].append(creator)
 
         # Tags
-        if result.get('Subject'):
-            item['tags'].append({'tag': result['Subject']})
-        for tag in result.get('PalavrasChave', []):
-            item['tags'].append({'tag': tag})
+        if result.get("Subject"):
+            item["tags"].append({"tag": result["Subject"]})
+        for tag in result.get("PalavrasChave", []):
+            item["tags"].append({"tag": tag})
 
         return item
 
@@ -198,11 +197,11 @@ class CamaraBrasileiraDoLivroISBNTranslator:
 
     def _capitalize_title(self, s: str) -> str:
         """Capitalize title properly."""
-        return ' '.join(word.capitalize() for word in s.split())
+        return " ".join(word.capitalize() for word in s.split())
 
     def _capitalize_name(self, s: str) -> str:
         """Capitalize name properly."""
-        return ' '.join(word.capitalize() for word in s.split())
+        return " ".join(word.capitalize() for word in s.split())
 
     def _str_to_iso(self, date_str: str) -> str:
         """Convert date string to ISO format."""
@@ -211,13 +210,13 @@ class CamaraBrasileiraDoLivroISBNTranslator:
 
     def _clean_isbn(self, isbn: str) -> str:
         """Clean ISBN string."""
-        return re.sub(r'[^0-9X]', '', isbn.upper())
+        return re.sub(r"[^0-9X]", "", isbn.upper())
 
     def _to_isbn13(self, isbn10: str) -> str:
         """Convert ISBN-10 to ISBN-13."""
         if len(isbn10) != 10:
             return isbn10
-        isbn13 = '978' + isbn10[:-1]
+        isbn13 = "978" + isbn10[:-1]
         check_sum = sum((3 if i % 2 else 1) * int(c) for i, c in enumerate(isbn13))
         check_digit = (10 - (check_sum % 10)) % 10
         return isbn13 + str(check_digit)
@@ -225,46 +224,46 @@ class CamaraBrasileiraDoLivroISBNTranslator:
     def _clean_author(self, name: str, creator_type: str) -> Dict[str, Any]:
         """Parse author name."""
         name = name.strip()
-        has_comma = ',' in name
+        has_comma = "," in name
 
         if has_comma:
-            parts = name.split(',', 1)
+            parts = name.split(",", 1)
             last_name = parts[0].strip()
-            first_name = parts[1].strip() if len(parts) > 1 else ''
+            first_name = parts[1].strip() if len(parts) > 1 else ""
 
             # Handle suffixes
-            suffixes = ['filho', 'junior', 'neto', 'sobrinho', 'segundo', 'terceiro']
+            suffixes = ["filho", "junior", "neto", "sobrinho", "segundo", "terceiro"]
             last_name_lower = self._remove_diacritics(last_name.lower())
             if last_name_lower in suffixes and first_name:
                 first_parts = first_name.split()
                 if first_parts:
-                    last_name = first_parts[-1] + ' ' + last_name
-                    first_name = ' '.join(first_parts[:-1])
+                    last_name = first_parts[-1] + " " + last_name
+                    first_name = " ".join(first_parts[:-1])
 
             if first_name:
                 return {
-                    'firstName': first_name,
-                    'lastName': last_name,
-                    'creatorType': creator_type
+                    "firstName": first_name,
+                    "lastName": last_name,
+                    "creatorType": creator_type,
                 }
             else:
                 return {
-                    'lastName': last_name,
-                    'creatorType': creator_type,
-                    'fieldMode': True
+                    "lastName": last_name,
+                    "creatorType": creator_type,
+                    "fieldMode": True,
                 }
         else:
-            return {
-                'lastName': name,
-                'creatorType': creator_type,
-                'fieldMode': True
-            }
+            return {"lastName": name, "creatorType": creator_type, "fieldMode": True}
 
     def _remove_diacritics(self, text: str) -> str:
         """Remove diacritics from text."""
         import unicodedata
-        return ''.join(c for c in unicodedata.normalize('NFD', text)
-                      if unicodedata.category(c) != 'Mn')
+
+        return "".join(
+            c
+            for c in unicodedata.normalize("NFD", text)
+            if unicodedata.category(c) != "Mn"
+        )
 
     def _clean_data(self, items: Any) -> List[Dict[str, Any]]:
         """Clean and filter items."""
@@ -274,14 +273,18 @@ class CamaraBrasileiraDoLivroISBNTranslator:
         result = []
         for item in items:
             if isinstance(item, str):
-                item = {'ISBN': item}
+                item = {"ISBN": item}
 
-            if item.get('ISBN'):
-                isbn = self._clean_isbn(item['ISBN'])
+            if item.get("ISBN"):
+                isbn = self._clean_isbn(item["ISBN"])
                 # Filter for Brazilian ISBNs
-                if (isbn.startswith('97865') or isbn.startswith('65') or
-                    isbn.startswith('97885') or isbn.startswith('85')):
-                    item['ISBN'] = isbn
+                if (
+                    isbn.startswith("97865")
+                    or isbn.startswith("65")
+                    or isbn.startswith("97885")
+                    or isbn.startswith("85")
+                ):
+                    item["ISBN"] = isbn
                     result.append(item)
 
         return result

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

@@ -34,26 +34,28 @@ class CanLIITranslator:
         "inRepository": True,
         "translatorType": 4,
         "browserSupport": "gcsibv",
-        "lastUpdated": "2023-03-15 05:20:22"
+        "lastUpdated": "2023-03-15 05:20:22",
     }
 
-    CAN_LII_REGEXP = re.compile(r'https?://(?:www\.)?canlii\.org[^/]*/(?:en|fr)/[^/]+/[^/]+/doc/.+')
+    CAN_LII_REGEXP = re.compile(
+        r"https?://(?:www\.)?canlii\.org[^/]*/(?:en|fr)/[^/]+/[^/]+/doc/.+"
+    )
 
     def detect_web(self, doc: BeautifulSoup, url: str) -> str:
         """Detect if page is a CanLII case or search results."""
         if self.CAN_LII_REGEXP.match(url):
-            return 'case'
+            return "case"
 
         # Check for links to cases
-        for link in doc.find_all('a', href=True):
-            if self.CAN_LII_REGEXP.match(link['href']):
-                return 'multiple'
+        for link in doc.find_all("a", href=True):
+            if self.CAN_LII_REGEXP.match(link["href"]):
+                return "multiple"
 
-        return ''
+        return ""
 
     def do_web(self, doc: BeautifulSoup, url: str) -> 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 {}
 
@@ -69,77 +71,81 @@ class CanLIITranslator:
             Dictionary containing case metadata
         """
         item = {
-            'itemType': 'case',
-            'creators': [],
-            'tags': [],
-            'attachments': [],
-            'notes': []
+            "itemType": "case",
+            "creators": [],
+            "tags": [],
+            "attachments": [],
+            "notes": [],
         }
 
         # Get citation text
-        citation_div = doc.select_one('.documentMeta-citation + div')
+        citation_div = doc.select_one(".documentMeta-citation + div")
         if citation_div:
             voliss = citation_div.get_text().strip()
 
             # Parse citation
             # e.g. Reference re Secession of Quebec, 1998 CanLII 793 (SCC), [1998] 2 SCR 217
-            citation_parts = voliss.split(',')
+            citation_parts = voliss.split(",")
             if citation_parts:
-                item['caseName'] = citation_parts[0].strip()
+                item["caseName"] = citation_parts[0].strip()
 
             # Extract reporter information
-            reporter_regex = re.compile(r'\[(\d{4})\]\s+(\d+)\s+([A-Z]+)\s+(\d+)')
+            reporter_regex = re.compile(r"\[(\d{4})\]\s+(\d+)\s+([A-Z]+)\s+(\d+)")
             reporter_match = reporter_regex.search(voliss)
             if reporter_match:
-                item['reporterVolume'] = reporter_match.group(2)
-                item['reporter'] = reporter_match.group(3)
-                item['firstPage'] = reporter_match.group(4)
+                item["reporterVolume"] = reporter_match.group(2)
+                item["reporter"] = reporter_match.group(3)
+                item["firstPage"] = reporter_match.group(4)
 
         # Court
         court_elem = doc.select_one('#breadcrumbs *[itemprop="name"]:nth-of-type(3)')
         if court_elem:
-            item['court'] = court_elem.get_text().strip()
+            item["court"] = court_elem.get_text().strip()
 
         # Date decided
-        date_div = doc.find('div', string=re.compile(r'Date'))
+        date_div = doc.find("div", string=re.compile(r"Date"))
         if date_div:
-            date_sibling = date_div.find_next_sibling('div')
+            date_sibling = date_div.find_next_sibling("div")
             if date_sibling:
-                item['dateDecided'] = date_sibling.get_text().strip()
+                item["dateDecided"] = date_sibling.get_text().strip()
 
         # Docket number
-        docket_div = doc.find('div', string=re.compile(r'File number|Numéro de dossier'))
+        docket_div = doc.find(
+            "div", string=re.compile(r"File number|Numéro de dossier")
+        )
         if docket_div:
-            docket_sibling = docket_div.find_next_sibling('div')
+            docket_sibling = docket_div.find_next_sibling("div")
             if docket_sibling:
-                item['docketNumber'] = docket_sibling.get_text().strip()
+                item["docketNumber"] = docket_sibling.get_text().strip()
 
         # Other citations
-        other_citations_div = doc.find('div', string=re.compile(r'Other citations|Autres citations'))
+        other_citations_div = doc.find(
+            "div", string=re.compile(r"Other citations|Autres citations")
+        )
         if other_citations_div:
-            citations_sibling = other_citations_div.find_next_sibling('div')
+            citations_sibling = other_citations_div.find_next_sibling("div")
             if citations_sibling:
                 other_citations = citations_sibling.get_text().strip()
-                item['notes'].append({'note': f'Other Citations: {other_citations}'})
+                item["notes"].append({"note": f"Other Citations: {other_citations}"})
 
         # Short URL
-        short_url_elem = doc.select_one('.documentStaticUrl')
+        short_url_elem = doc.select_one(".documentStaticUrl")
         if short_url_elem:
-            item['url'] = short_url_elem.get_text().strip()
+            item["url"] = short_url_elem.get_text().strip()
 
         # PDF attachment
-        pdf_url = re.sub(r'\.html(?:[?#].*)?', '.pdf', url)
-        item['attachments'].append({
-            'url': pdf_url,
-            'title': 'CanLII Full Text PDF',
-            'mimeType': 'application/pdf'
-        })
+        pdf_url = re.sub(r"\.html(?:[?#].*)?", ".pdf", url)
+        item["attachments"].append(
+            {
+                "url": pdf_url,
+                "title": "CanLII Full Text PDF",
+                "mimeType": "application/pdf",
+            }
+        )
 
         # Snapshot attachment
-        item['attachments'].append({
-            'title': 'CanLII Snapshot',
-            'mimeType': 'text/html',
-            'url': url
-        })
+        item["attachments"].append(
+            {"title": "CanLII Snapshot", "mimeType": "text/html", "url": url}
+        )
 
         return item

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

@@ -34,16 +34,16 @@ class CanadaComTranslator:
         "inRepository": True,
         "translatorType": 4,
         "browserSupport": "gcsibv",
-        "lastUpdated": "2021-12-28 04:34:11"
+        "lastUpdated": "2021-12-28 04:34:11",
     }
 
     def detect_web(self, doc: BeautifulSoup, url: str) -> str:
         """Detect if page is an article or search results."""
-        if 'story' in url:
-            return 'newspaperArticle'
-        elif 'search' in url:
-            return 'multiple'
-        return ''
+        if "story" in url:
+            return "newspaperArticle"
+        elif "search" in url:
+            return "multiple"
+        return ""
 
     def do_web(self, doc: BeautifulSoup, url: str) -> Dict[str, Any]:
         """Extract article data."""
@@ -61,54 +61,54 @@ class CanadaComTranslator:
             Dictionary containing article metadata
         """
         item = {
-            'itemType': 'newspaperArticle',
-            'creators': [],
-            'tags': [],
-            'attachments': [],
-            'url': url
+            "itemType": "newspaperArticle",
+            "creators": [],
+            "tags": [],
+            "attachments": [],
+            "url": url,
         }
 
         # Title
-        item['title'] = doc.title.string if doc.title else ''
+        item["title"] = doc.title.string if doc.title else ""
 
         # Abstract
-        abstract_elem = doc.select_one('.storyheader h4')
+        abstract_elem = doc.select_one(".storyheader h4")
         if abstract_elem:
-            item['abstractNote'] = abstract_elem.get_text().strip()
-        elif doc.select_one('.storyheader h2'):
-            item['abstractNote'] = doc.select_one('.storyheader h2').get_text().strip()
+            item["abstractNote"] = abstract_elem.get_text().strip()
+        elif doc.select_one(".storyheader h2"):
+            item["abstractNote"] = doc.select_one(".storyheader h2").get_text().strip()
 
         # Author
-        author_meta = doc.find('meta', attrs={'name': 'Author'})
-        if author_meta and author_meta.get('content'):
-            author_text = author_meta['content']
+        author_meta = doc.find("meta", attrs={"name": "Author"})
+        if author_meta and author_meta.get("content"):
+            author_text = author_meta["content"]
 
             # Handle multiple authors separated by newlines or "and"
-            if '\n' in author_text:
-                author_parts = author_text.split('\n')
+            if "\n" in author_text:
+                author_parts = author_text.split("\n")
                 author_text = author_parts[0]
 
-            if ' and ' in author_text:
-                authors = author_text.split(' and ')
+            if " and " in author_text:
+                authors = author_text.split(" and ")
                 for author in authors:
-                    item['creators'].append(self._clean_author(author.strip()))
+                    item["creators"].append(self._clean_author(author.strip()))
             else:
-                item['creators'].append(self._clean_author(author_text.strip()))
+                item["creators"].append(self._clean_author(author_text.strip()))
 
         # Date
-        date_meta = doc.find('meta', attrs={'name': 'PubDate'})
-        if date_meta and date_meta.get('content'):
-            item['date'] = date_meta['content'].strip()
+        date_meta = doc.find("meta", attrs={"name": "PubDate"})
+        if date_meta and date_meta.get("content"):
+            item["date"] = date_meta["content"].strip()
 
         # Publication title
-        pub_title_elem = doc.select_one('ul.home li a span')
+        pub_title_elem = doc.select_one("ul.home li a span")
         if pub_title_elem:
             pub_title = pub_title_elem.get_text().strip()
-            if pub_title.endswith('Home'):
+            if pub_title.endswith("Home"):
                 pub_title = pub_title[:-4].strip()
-            item['publicationTitle'] = pub_title
+            item["publicationTitle"] = pub_title
         else:
-            item['publicationTitle'] = 'Canada.com'
+            item["publicationTitle"] = "Canada.com"
 
         return item
 
@@ -119,13 +119,9 @@ class CanadaComTranslator:
 
         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}