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

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

@@ -31,39 +31,39 @@ class DataciteJSONTranslator:
         "priority": 100,
         "inRepository": True,
         "translatorType": 1,  # Import type
-        "lastUpdated": "2025-04-29 03:02:00"
+        "lastUpdated": "2025-04-29 03:02:00",
     }
 
     # Type mappings from DataCite/CSL to Zotero
     TYPE_MAPPINGS = {
-        'article': 'preprint',
-        'book': 'book',
-        'chapter': 'bookSection',
-        'article-journal': 'journalArticle',
-        'article-magazine': 'magazineArticle',
-        'article-newspaper': 'newspaperArticle',
-        'thesis': 'thesis',
-        'entry-encyclopedia': 'encyclopediaArticle',
-        'entry-dictionary': 'dictionaryEntry',
-        'paper-conference': 'conferencePaper',
-        'personal_communication': 'letter',
-        'manuscript': 'manuscript',
-        'interview': 'interview',
-        'motion_picture': 'film',
-        'graphic': 'artwork',
-        'webpage': 'webpage',
-        'report': 'report',
-        'bill': 'bill',
-        'legal_case': 'case',
-        'patent': 'patent',
-        'legislation': 'statute',
-        'map': 'map',
-        'post-weblog': 'blogPost',
-        'post': 'forumPost',
-        'song': 'audioRecording',
-        'speech': 'presentation',
-        'broadcast': 'radioBroadcast',
-        'dataset': 'dataset'
+        "article": "preprint",
+        "book": "book",
+        "chapter": "bookSection",
+        "article-journal": "journalArticle",
+        "article-magazine": "magazineArticle",
+        "article-newspaper": "newspaperArticle",
+        "thesis": "thesis",
+        "entry-encyclopedia": "encyclopediaArticle",
+        "entry-dictionary": "dictionaryEntry",
+        "paper-conference": "conferencePaper",
+        "personal_communication": "letter",
+        "manuscript": "manuscript",
+        "interview": "interview",
+        "motion_picture": "film",
+        "graphic": "artwork",
+        "webpage": "webpage",
+        "report": "report",
+        "bill": "bill",
+        "legal_case": "case",
+        "patent": "patent",
+        "legislation": "statute",
+        "map": "map",
+        "post-weblog": "blogPost",
+        "post": "forumPost",
+        "song": "audioRecording",
+        "speech": "presentation",
+        "broadcast": "radioBroadcast",
+        "dataset": "dataset",
     }
 
     def detect_import(self, content: str) -> bool:
@@ -79,9 +79,9 @@ class DataciteJSONTranslator:
         try:
             data = json.loads(content)
             # Check for DataCite schema version or agency
-            if data.get('schemaVersion', '').startswith('http://datacite.org/schema/'):
+            if data.get("schemaVersion", "").startswith("http://datacite.org/schema/"):
                 return True
-            if 'datacite' in data.get('agency', '').lower():
+            if "datacite" in data.get("agency", "").lower():
                 return True
             return False
         except (json.JSONDecodeError, AttributeError):
@@ -103,161 +103,176 @@ class DataciteJSONTranslator:
             return {}
 
         # Determine item type
-        item_type = 'journalArticle'  # default
+        item_type = "journalArticle"  # default
 
-        if data.get('types'):
-            types_info = data['types']
+        if data.get("types"):
+            types_info = data["types"]
 
             # Check citeproc type
-            if types_info.get('citeproc') and types_info['citeproc'] in self.TYPE_MAPPINGS:
-                item_type = self.TYPE_MAPPINGS[types_info['citeproc']]
+            if (
+                types_info.get("citeproc")
+                and types_info["citeproc"] in self.TYPE_MAPPINGS
+            ):
+                item_type = self.TYPE_MAPPINGS[types_info["citeproc"]]
 
             # Check for software types
-            schema_org = types_info.get('schemaOrg', '').lower()
-            if schema_org in ['softwaresourcecode', 'softwareapplication', 'mobileapplication', 'videogame', 'webapplication']:
-                item_type = 'computerProgram'
+            schema_org = types_info.get("schemaOrg", "").lower()
+            if schema_org in [
+                "softwaresourcecode",
+                "softwareapplication",
+                "mobileapplication",
+                "videogame",
+                "webapplication",
+            ]:
+                item_type = "computerProgram"
 
             # Special case for book chapters
-            if types_info.get('resourceTypeGeneral') == 'BookChapter':
-                item_type = 'bookSection'
+            if types_info.get("resourceTypeGeneral") == "BookChapter":
+                item_type = "bookSection"
 
-        item = {
-            'itemType': item_type,
-            'creators': [],
-            'tags': [],
-            'attachments': []
-        }
+        item = {"itemType": item_type, "creators": [], "tags": [], "attachments": []}
 
         # Handle dataset type for older Zotero versions
-        if data.get('types', {}).get('citeproc') == 'dataset' and item_type == 'document':
-            item['extra'] = 'Type: dataset'
+        if (
+            data.get("types", {}).get("citeproc") == "dataset"
+            and item_type == "document"
+        ):
+            item["extra"] = "Type: dataset"
 
         # Extract titles
-        title = ''
-        alternate_title = ''
-        for title_element in data.get('titles', []):
-            if not title_element.get('title'):
+        title = ""
+        alternate_title = ""
+        for title_element in data.get("titles", []):
+            if not title_element.get("title"):
                 continue
 
-            title_type = title_element.get('titleType', '').lower()
+            title_type = title_element.get("titleType", "").lower()
             if not title_type:
-                title = title_element['title'] + title
-            elif title_type == 'subtitle':
-                title = title + ': ' + title_element['title']
+                title = title_element["title"] + title
+            elif title_type == "subtitle":
+                title = title + ": " + title_element["title"]
             elif not alternate_title:
-                alternate_title = title_element['title']
+                alternate_title = title_element["title"]
 
-        item['title'] = title or alternate_title
+        item["title"] = title or alternate_title
 
         # Extract creators
-        for creator in data.get('creators', []):
-            if creator.get('familyName') and creator.get('givenName'):
-                item['creators'].append({
-                    'lastName': creator['familyName'],
-                    'firstName': creator['givenName'],
-                    'creatorType': 'author'
-                })
-            elif creator.get('nameType') == 'Personal':
-                name = creator.get('name', '')
+        for creator in data.get("creators", []):
+            if creator.get("familyName") and creator.get("givenName"):
+                item["creators"].append(
+                    {
+                        "lastName": creator["familyName"],
+                        "firstName": creator["givenName"],
+                        "creatorType": "author",
+                    }
+                )
+            elif creator.get("nameType") == "Personal":
+                name = creator.get("name", "")
                 names = name.split()
                 if len(names) >= 2:
-                    item['creators'].append({
-                        'lastName': names[-1],
-                        'firstName': ' '.join(names[:-1]),
-                        'creatorType': 'author'
-                    })
+                    item["creators"].append(
+                        {
+                            "lastName": names[-1],
+                            "firstName": " ".join(names[:-1]),
+                            "creatorType": "author",
+                        }
+                    )
                 else:
-                    item['creators'].append({
-                        'lastName': name,
-                        'creatorType': 'author',
-                        'fieldMode': True
-                    })
+                    item["creators"].append(
+                        {"lastName": name, "creatorType": "author", "fieldMode": True}
+                    )
             else:
-                item['creators'].append({
-                    'lastName': creator.get('name', ''),
-                    'creatorType': 'author',
-                    'fieldMode': True
-                })
+                item["creators"].append(
+                    {
+                        "lastName": creator.get("name", ""),
+                        "creatorType": "author",
+                        "fieldMode": True,
+                    }
+                )
 
         # Extract contributors
-        for contributor in data.get('contributors', []):
-            role = 'contributor'
-            contrib_type = contributor.get('contributorType', '').lower()
-            if contrib_type == 'editor':
-                role = 'editor'
-            elif contrib_type == 'producer':
-                role = 'producer'
-
-            if contributor.get('familyName') and contributor.get('givenName'):
-                item['creators'].append({
-                    'lastName': contributor['familyName'],
-                    'firstName': contributor['givenName'],
-                    'creatorType': role
-                })
-            elif contributor.get('nameType') == 'Personal':
-                name = contributor.get('name', '')
+        for contributor in data.get("contributors", []):
+            role = "contributor"
+            contrib_type = contributor.get("contributorType", "").lower()
+            if contrib_type == "editor":
+                role = "editor"
+            elif contrib_type == "producer":
+                role = "producer"
+
+            if contributor.get("familyName") and contributor.get("givenName"):
+                item["creators"].append(
+                    {
+                        "lastName": contributor["familyName"],
+                        "firstName": contributor["givenName"],
+                        "creatorType": role,
+                    }
+                )
+            elif contributor.get("nameType") == "Personal":
+                name = contributor.get("name", "")
                 names = name.split()
                 if len(names) >= 2:
-                    item['creators'].append({
-                        'lastName': names[-1],
-                        'firstName': ' '.join(names[:-1]),
-                        'creatorType': role
-                    })
+                    item["creators"].append(
+                        {
+                            "lastName": names[-1],
+                            "firstName": " ".join(names[:-1]),
+                            "creatorType": role,
+                        }
+                    )
                 else:
-                    item['creators'].append({
-                        'lastName': name,
-                        'creatorType': role,
-                        'fieldMode': True
-                    })
+                    item["creators"].append(
+                        {"lastName": name, "creatorType": role, "fieldMode": True}
+                    )
             else:
-                item['creators'].append({
-                    'lastName': contributor.get('name', ''),
-                    'creatorType': role,
-                    'fieldMode': True
-                })
+                item["creators"].append(
+                    {
+                        "lastName": contributor.get("name", ""),
+                        "creatorType": role,
+                        "fieldMode": True,
+                    }
+                )
 
         # Extract publisher
-        publisher = data.get('publisher')
+        publisher = data.get("publisher")
         if isinstance(publisher, dict):
-            item['publisher'] = publisher.get('name', '')
+            item["publisher"] = publisher.get("name", "")
         else:
-            item['publisher'] = publisher
+            item["publisher"] = publisher
 
         # Extract DOI
-        if data.get('doi'):
-            item['DOI'] = data['doi']
+        if data.get("doi"):
+            item["DOI"] = data["doi"]
 
         # Extract URL
-        if data.get('url'):
-            item['url'] = data['url']
+        if data.get("url"):
+            item["url"] = data["url"]
 
         # Extract dates
-        for date_info in data.get('dates', []):
-            date_type = date_info.get('dateType', '').lower()
-            date_value = date_info.get('date', '')
+        for date_info in data.get("dates", []):
+            date_type = date_info.get("dateType", "").lower()
+            date_value = date_info.get("date", "")
 
-            if date_type == 'issued' and date_value:
-                item['date'] = date_value[:10] if len(date_value) >= 10 else date_value
+            if date_type == "issued" and date_value:
+                item["date"] = date_value[:10] if len(date_value) >= 10 else date_value
 
         # Extract publication year
-        if data.get('publicationYear'):
-            if not item.get('date'):
-                item['date'] = str(data['publicationYear'])
+        if data.get("publicationYear"):
+            if not item.get("date"):
+                item["date"] = str(data["publicationYear"])
 
         # Extract descriptions (abstract)
-        for desc in data.get('descriptions', []):
-            if desc.get('descriptionType', '').lower() == 'abstract':
-                item['abstractNote'] = desc.get('description', '')
+        for desc in data.get("descriptions", []):
+            if desc.get("descriptionType", "").lower() == "abstract":
+                item["abstractNote"] = desc.get("description", "")
                 break
 
         # Extract subjects as tags
-        for subject in data.get('subjects', []):
-            subject_text = subject.get('subject', '').strip()
+        for subject in data.get("subjects", []):
+            subject_text = subject.get("subject", "").strip()
             if subject_text:
-                item['tags'].append({'tag': subject_text})
+                item["tags"].append({"tag": subject_text})
 
         # Extract language
-        if data.get('language'):
-            item['language'] = data['language']
+        if data.get("language"):
+            item["language"] = data["language"]
 
         return item

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

@@ -35,35 +35,37 @@ class DataverseTranslator:
         "inRepository": True,
         "translatorType": 4,
         "browserSupport": "gcsibv",
-        "lastUpdated": "2023-05-01 12:09:04"
+        "lastUpdated": "2023-05-01 12:09:04",
     }
 
     def detect_web(self, doc: BeautifulSoup, url: str) -> str:
         """Detect if page is Dataverse dataset or search."""
-        if not doc.select_one('#dataverseHeader'):
-            return ''
+        if not doc.select_one("#dataverseHeader"):
+            return ""
 
-        if '/dataset.xhtml' in url:
-            return 'dataset'
+        if "/dataset.xhtml" in url:
+            return "dataset"
         elif self.get_search_results(doc, check_only=True):
-            return 'multiple'
+            return "multiple"
 
-        return ''
+        return ""
 
-    def get_search_results(self, doc: BeautifulSoup, check_only: bool = False) -> Optional[Dict[str, str]]:
+    def get_search_results(
+        self, doc: BeautifulSoup, check_only: bool = False
+    ) -> Optional[Dict[str, str]]:
         """Extract search results."""
         items = {}
         rows = doc.select('.datasetResult a[href*="/dataset.xhtml"]')
 
         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
 
             if check_only:
-                return {'found': 'true'}
+                return {"found": "true"}
 
             items[href] = title
 
@@ -73,7 +75,7 @@ class DataverseTranslator:
         """Main extraction method."""
         page_type = self.detect_web(doc, url)
 
-        if page_type == 'multiple':
+        if page_type == "multiple":
             return self.get_search_results(doc, check_only=False)
         else:
             return self.scrape(doc, url)
@@ -81,11 +83,11 @@ class DataverseTranslator:
     def scrape(self, doc: BeautifulSoup, url: str) -> Dict[str, Any]:
         """Scrape dataset metadata."""
         item = {
-            'itemType': 'dataset',
-            'url': url,
-            'creators': [],
-            'tags': [],
-            'attachments': []
+            "itemType": "dataset",
+            "url": url,
+            "creators": [],
+            "tags": [],
+            "attachments": [],
         }
 
         # Parse JSON-LD schema
@@ -95,92 +97,94 @@ class DataverseTranslator:
                 schema = json.loads(ld_json_tag.string)
 
                 # Extract license
-                license_info = schema.get('license')
+                license_info = schema.get("license")
                 if isinstance(license_info, dict):
-                    license_info = license_info.get('text', '')
+                    license_info = license_info.get("text", "")
                 if license_info:
                     # Clean HTML tags from license text
-                    item['rights'] = re.sub(r'<[^>]+>', '', str(license_info)).strip()
+                    item["rights"] = re.sub(r"<[^>]+>", "", str(license_info)).strip()
 
                 # Extract abstract
-                if schema.get('description'):
-                    item['abstractNote'] = schema['description']
+                if schema.get("description"):
+                    item["abstractNote"] = schema["description"]
 
                 # Extract version
-                version = schema.get('version')
+                version = schema.get("version")
                 if version and version > 1:
-                    item['versionNumber'] = str(version)
+                    item["versionNumber"] = str(version)
 
             except (json.JSONDecodeError, KeyError):
                 pass
 
         # Extract library catalog (repository name)
-        breadcrumb = doc.select_one('#breadcrumbLnk0')
+        breadcrumb = doc.select_one("#breadcrumbLnk0")
         if breadcrumb:
-            item['libraryCatalog'] = breadcrumb.get_text(strip=True)
+            item["libraryCatalog"] = breadcrumb.get_text(strip=True)
 
         # Extract title from meta tags
-        title_tag = doc.find('meta', {'property': 'og:title'})
-        if title_tag and title_tag.get('content'):
-            title = title_tag['content']
+        title_tag = doc.find("meta", {"property": "og:title"})
+        if title_tag and title_tag.get("content"):
+            title = title_tag["content"]
             # Handle "Replication Data for:" pattern
-            if re.match(r'^(Replication )?[Dd]ata for:', title):
-                match = re.match(r'(^(Replication )?[Dd]ata for:.*?)(:|$)', title)
+            if re.match(r"^(Replication )?[Dd]ata for:", title):
+                match = re.match(r"(^(Replication )?[Dd]ata for:.*?)(:|$)", title)
                 if match:
-                    item['shortTitle'] = match.group(1)
-            item['title'] = title
+                    item["shortTitle"] = match.group(1)
+            item["title"] = title
 
         # Extract DOI
-        doi_tag = doc.find('meta', {'property': 'citation_doi'})
-        if doi_tag and doi_tag.get('content'):
-            item['DOI'] = doi_tag['content']
+        doi_tag = doc.find("meta", {"property": "citation_doi"})
+        if doi_tag and doi_tag.get("content"):
+            item["DOI"] = doi_tag["content"]
 
         # Extract repository
-        repo_tag = doc.find('meta', {'property': 'citation_publisher'})
-        if repo_tag and repo_tag.get('content'):
-            item['repository'] = repo_tag['content']
+        repo_tag = doc.find("meta", {"property": "citation_publisher"})
+        if repo_tag and repo_tag.get("content"):
+            item["repository"] = repo_tag["content"]
 
         # Extract creators
-        author_tags = doc.find_all('meta', {'property': 'citation_author'})
+        author_tags = doc.find_all("meta", {"property": "citation_author"})
         for author_tag in author_tags:
-            author_name = author_tag.get('content', '')
+            author_name = author_tag.get("content", "")
             if author_name:
                 names = author_name.split()
                 if len(names) >= 2:
-                    item['creators'].append({
-                        'firstName': ' '.join(names[:-1]),
-                        'lastName': names[-1],
-                        'creatorType': 'author'
-                    })
+                    item["creators"].append(
+                        {
+                            "firstName": " ".join(names[:-1]),
+                            "lastName": names[-1],
+                            "creatorType": "author",
+                        }
+                    )
                 else:
-                    item['creators'].append({
-                        'lastName': author_name,
-                        'creatorType': 'author',
-                        'fieldMode': True
-                    })
+                    item["creators"].append(
+                        {
+                            "lastName": author_name,
+                            "creatorType": "author",
+                            "fieldMode": True,
+                        }
+                    )
 
         # Extract date
-        date_tag = doc.find('meta', {'property': 'citation_publication_date'})
-        if date_tag and date_tag.get('content'):
-            item['date'] = date_tag['content']
+        date_tag = doc.find("meta", {"property": "citation_publication_date"})
+        if date_tag and date_tag.get("content"):
+            item["date"] = date_tag["content"]
 
         # Extract language
-        lang_tag = doc.find('meta', {'property': 'og:locale'})
-        if lang_tag and lang_tag.get('content'):
-            item['language'] = lang_tag['content']
+        lang_tag = doc.find("meta", {"property": "og:locale"})
+        if lang_tag and lang_tag.get("content"):
+            item["language"] = lang_tag["content"]
 
         # Extract keywords as tags
-        keywords_tags = doc.find_all('meta', {'property': 'citation_keywords'})
+        keywords_tags = doc.find_all("meta", {"property": "citation_keywords"})
         for kw_tag in keywords_tags:
-            keyword = kw_tag.get('content', '').strip()
+            keyword = kw_tag.get("content", "").strip()
             if keyword:
-                item['tags'].append({'tag': keyword})
+                item["tags"].append({"tag": keyword})
 
         # Add snapshot attachment
-        item['attachments'].append({
-            'title': 'Snapshot',
-            'mimeType': 'text/html',
-            'url': url
-        })
+        item["attachments"].append(
+            {"title": "Snapshot", "mimeType": "text/html", "url": url}
+        )
 
         return item