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

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

@@ -34,7 +34,7 @@ class BibLaTeXTranslator:
         "priority": 100,
         "inRepository": True,
         "translatorType": 2,  # Export translator
-        "lastUpdated": "2024-03-25 14:49:42"
+        "lastUpdated": "2024-03-25 14:49:42",
     }
 
     # Field mappings from Zotero to BibLaTeX
@@ -57,7 +57,7 @@ class BibLaTeXTranslator:
         "version": "version",
         "conferenceName": "eventtitle",
         "pages": "pages",
-        "numPages": "pagetotal"
+        "numPages": "pagetotal",
     }
 
     # Item type mappings from Zotero to BibLaTeX
@@ -95,7 +95,7 @@ class BibLaTeXTranslator:
         "computerProgram": "software",
         "document": "misc",
         "encyclopediaArticle": "inreference",
-        "dictionaryEntry": "inreference"
+        "dictionaryEntry": "inreference",
     }
 
     def __init__(self):
@@ -116,14 +116,14 @@ class BibLaTeXTranslator:
 
         for item in items:
             # Skip notes and attachments
-            if item.get('itemType') in ['note', 'attachment']:
+            if item.get("itemType") in ["note", "attachment"]:
                 continue
 
             entry = self._export_item(item)
             if entry:
                 output.append(entry)
 
-        return '\n\n'.join(output)
+        return "\n\n".join(output)
 
     def _export_item(self, item: Dict[str, Any]) -> str:
         """
@@ -136,8 +136,8 @@ class BibLaTeXTranslator:
             BibLaTeX entry string
         """
         # Determine entry type
-        item_type = item.get('itemType', 'misc')
-        bib_type = self.TYPE_MAP.get(item_type, 'misc')
+        item_type = item.get("itemType", "misc")
+        bib_type = self.TYPE_MAP.get(item_type, "misc")
 
         # Generate cite key
         cite_key = self._build_cite_key(item)
@@ -152,37 +152,44 @@ class BibLaTeXTranslator:
                 lines.append(f",\n\t{biblatex_field} = {{{value}}}")
 
         # Add special handling for publication title
-        if 'publicationTitle' in item and item['publicationTitle']:
-            if item_type in ['bookSection', 'conferencePaper', 'dictionaryEntry', 'encyclopediaArticle']:
-                field_name = 'booktitle'
-            elif item_type in ['magazineArticle', 'newspaperArticle', 'journalArticle']:
-                field_name = 'journaltitle'
+        if "publicationTitle" in item and item["publicationTitle"]:
+            if item_type in [
+                "bookSection",
+                "conferencePaper",
+                "dictionaryEntry",
+                "encyclopediaArticle",
+            ]:
+                field_name = "booktitle"
+            elif item_type in ["magazineArticle", "newspaperArticle", "journalArticle"]:
+                field_name = "journaltitle"
             else:
-                field_name = 'journaltitle'
+                field_name = "journaltitle"
 
-            value = self._escape_value(item['publicationTitle'])
+            value = self._escape_value(item["publicationTitle"])
             lines.append(f",\n\t{field_name} = {{{value}}}")
 
         # Add creators
-        if 'creators' in item and item['creators']:
-            creators_str = self._format_creators(item['creators'])
+        if "creators" in item and item["creators"]:
+            creators_str = self._format_creators(item["creators"])
             if creators_str:
                 lines.append(creators_str)
 
         # Add date
-        if 'date' in item and item['date']:
+        if "date" in item and item["date"]:
             lines.append(f",\n\tdate = {{{item['date']}}}")
 
         # Add tags as keywords
-        if 'tags' in item and item['tags']:
-            keywords = ', '.join(tag.get('tag', '') for tag in item['tags'] if tag.get('tag'))
+        if "tags" in item and item["tags"]:
+            keywords = ", ".join(
+                tag.get("tag", "") for tag in item["tags"] if tag.get("tag")
+            )
             if keywords:
                 lines.append(f",\n\tkeywords = {{{keywords}}}")
 
         # Close entry
         lines.append(",\n}")
 
-        return ''.join(lines)
+        return "".join(lines)
 
     def _build_cite_key(self, item: Dict[str, Any]) -> str:
         """
@@ -198,32 +205,32 @@ class BibLaTeXTranslator:
         parts = []
 
         # Add first author last name
-        if 'creators' in item and item['creators']:
-            first_creator = item['creators'][0]
-            last_name = first_creator.get('lastName', 'noauthor')
+        if "creators" in item and item["creators"]:
+            first_creator = item["creators"][0]
+            last_name = first_creator.get("lastName", "noauthor")
             parts.append(self._clean_cite_key_part(last_name))
         else:
-            parts.append('noauthor')
+            parts.append("noauthor")
 
         # Add first word of title
-        if 'title' in item and item['title']:
-            title_words = item['title'].split()
+        if "title" in item and item["title"]:
+            title_words = item["title"].split()
             if title_words:
                 parts.append(self._clean_cite_key_part(title_words[0]))
         else:
-            parts.append('notitle')
+            parts.append("notitle")
 
         # Add year
-        if 'date' in item and item['date']:
-            year_match = re.search(r'\d{4}', item['date'])
+        if "date" in item and item["date"]:
+            year_match = re.search(r"\d{4}", item["date"])
             if year_match:
                 parts.append(year_match.group(0))
             else:
-                parts.append('nodate')
+                parts.append("nodate")
         else:
-            parts.append('nodate')
+            parts.append("nodate")
 
-        base_key = '_'.join(parts)
+        base_key = "_".join(parts)
 
         # Ensure uniqueness
         cite_key = base_key
@@ -247,7 +254,7 @@ class BibLaTeXTranslator:
         """
         # Remove special characters, keep only alphanumeric and underscore
         text = text.lower()
-        text = re.sub(r'[^a-z0-9_-]', '', text)
+        text = re.sub(r"[^a-z0-9_-]", "", text)
         return text
 
     def _format_creators(self, creators: List[Dict[str, Any]]) -> str:
@@ -264,30 +271,30 @@ class BibLaTeXTranslator:
         editors = []
 
         for creator in creators:
-            creator_type = creator.get('creatorType', 'author')
+            creator_type = creator.get("creatorType", "author")
 
             # Format name
-            if creator.get('firstName') and creator.get('lastName'):
+            if creator.get("firstName") and creator.get("lastName"):
                 name = f"{creator['lastName']}, {creator['firstName']}"
-            elif creator.get('lastName'):
-                name = creator['lastName']
+            elif creator.get("lastName"):
+                name = creator["lastName"]
             else:
                 continue
 
-            if creator_type in ['author', 'inventor', 'artist', 'programmer']:
+            if creator_type in ["author", "inventor", "artist", "programmer"]:
                 authors.append(name)
-            elif creator_type == 'editor':
+            elif creator_type == "editor":
                 editors.append(name)
 
         result = []
         if authors:
-            author_str = ' and '.join(authors)
+            author_str = " and ".join(authors)
             result.append(f",\n\tauthor = {{{author_str}}}")
         if editors:
-            editor_str = ' and '.join(editors)
+            editor_str = " and ".join(editors)
             result.append(f",\n\teditor = {{{editor_str}}}")
 
-        return ''.join(result)
+        return "".join(result)
 
     def _escape_value(self, value: Any) -> str:
         """
@@ -304,16 +311,16 @@ class BibLaTeXTranslator:
 
         # Escape special LaTeX characters
         replacements = {
-            '\\': '\\textbackslash{}',
-            '{': '\\{',
-            '}': '\\}',
-            '#': '\\#',
-            '$': '\\$',
-            '%': '\\%',
-            '&': '\\&',
-            '_': '\\_',
-            '~': '\\textasciitilde{}',
-            '^': '\\textasciicircum{}'
+            "\\": "\\textbackslash{}",
+            "{": "\\{",
+            "}": "\\}",
+            "#": "\\#",
+            "$": "\\$",
+            "%": "\\%",
+            "&": "\\&",
+            "_": "\\_",
+            "~": "\\textasciitilde{}",
+            "^": "\\textasciicircum{}",
         }
 
         for char, replacement in replacements.items():

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

@@ -34,7 +34,7 @@ class BibTeXTranslator:
         "priority": 100,
         "inRepository": True,
         "translatorType": 3,  # Import + Export
-        "lastUpdated": "2024-05-23 02:08:36"
+        "lastUpdated": "2024-05-23 02:08:36",
     }
 
     # Item type mappings (simplified)
@@ -50,7 +50,7 @@ class BibTeXTranslator:
         "report": "techreport",
         "patent": "misc",
         "webpage": "misc",
-        "document": "misc"
+        "document": "misc",
     }
 
     def __init__(self):
@@ -68,7 +68,7 @@ class BibTeXTranslator:
             True if BibTeX format is detected
         """
         # Look for BibTeX entry pattern: @type{key,
-        pattern = r'^\s*@[a-zA-Z]+[\(\{]'
+        pattern = r"^\s*@[a-zA-Z]+[\(\{]"
         return bool(re.search(pattern, text, re.MULTILINE))
 
     def do_import(self, text: str) -> List[Dict[str, Any]]:
@@ -84,7 +84,7 @@ class BibTeXTranslator:
         items = []
 
         # Pattern to match BibTeX entries
-        entry_pattern = r'@(\w+)\s*\{([^,]+),\s*([^}]+)\}'
+        entry_pattern = r"@(\w+)\s*\{([^,]+),\s*([^}]+)\}"
 
         for match in re.finditer(entry_pattern, text, re.DOTALL):
             entry_type, cite_key, fields_text = match.groups()
@@ -108,16 +108,18 @@ class BibTeXTranslator:
         output = []
 
         for item in items:
-            if item.get('itemType') in ['note', 'attachment']:
+            if item.get("itemType") in ["note", "attachment"]:
                 continue
 
             entry = self._export_item(item)
             if entry:
                 output.append(entry)
 
-        return '\n\n'.join(output)
+        return "\n\n".join(output)
 
-    def _parse_entry(self, entry_type: str, cite_key: str, fields_text: str) -> Optional[Dict[str, Any]]:
+    def _parse_entry(
+        self, entry_type: str, cite_key: str, fields_text: str
+    ) -> Optional[Dict[str, Any]]:
         """
         Parse a single BibTeX entry.
 
@@ -133,11 +135,11 @@ class BibTeXTranslator:
         zotero_type = self._bibtex_to_zotero_type(entry_type.lower())
 
         item = {
-            'itemType': zotero_type,
-            'citationKey': cite_key,
-            'creators': [],
-            'tags': [],
-            'attachments': []
+            "itemType": zotero_type,
+            "citationKey": cite_key,
+            "creators": [],
+            "tags": [],
+            "attachments": [],
         }
 
         # Parse fields
@@ -158,56 +160,58 @@ class BibTeXTranslator:
     def _bibtex_to_zotero_type(self, bibtex_type: str) -> str:
         """Map BibTeX type to Zotero type."""
         type_map = {
-            'article': 'journalArticle',
-            'book': 'book',
-            'inproceedings': 'conferencePaper',
-            'incollection': 'bookSection',
-            'phdthesis': 'thesis',
-            'mastersthesis': 'thesis',
-            'techreport': 'report',
-            'unpublished': 'manuscript',
-            'misc': 'document'
+            "article": "journalArticle",
+            "book": "book",
+            "inproceedings": "conferencePaper",
+            "incollection": "bookSection",
+            "phdthesis": "thesis",
+            "mastersthesis": "thesis",
+            "techreport": "report",
+            "unpublished": "manuscript",
+            "misc": "document",
         }
-        return type_map.get(bibtex_type, 'document')
+        return type_map.get(bibtex_type, "document")
 
     def _process_field(self, item: Dict[str, Any], field_name: str, field_value: str):
         """Process a BibTeX field and add to item."""
         field_map = {
-            'title': 'title',
-            'journal': 'publicationTitle',
-            'booktitle': 'publicationTitle',
-            'year': 'date',
-            'volume': 'volume',
-            'number': 'issue',
-            'pages': 'pages',
-            'doi': 'DOI',
-            'isbn': 'ISBN',
-            'issn': 'ISSN',
-            'url': 'url',
-            'abstract': 'abstractNote',
-            'publisher': 'publisher',
-            'address': 'place',
-            'edition': 'edition',
-            'series': 'series'
+            "title": "title",
+            "journal": "publicationTitle",
+            "booktitle": "publicationTitle",
+            "year": "date",
+            "volume": "volume",
+            "number": "issue",
+            "pages": "pages",
+            "doi": "DOI",
+            "isbn": "ISBN",
+            "issn": "ISSN",
+            "url": "url",
+            "abstract": "abstractNote",
+            "publisher": "publisher",
+            "address": "place",
+            "edition": "edition",
+            "series": "series",
         }
 
-        if field_name == 'author' or field_name == 'editor':
+        if field_name == "author" or field_name == "editor":
             # Parse authors/editors
             creators = self._parse_creators(field_value, field_name)
-            item['creators'].extend(creators)
-        elif field_name == 'keywords':
+            item["creators"].extend(creators)
+        elif field_name == "keywords":
             # Parse keywords as tags
-            keywords = field_value.split(',')
-            item['tags'].extend({'tag': k.strip()} for k in keywords if k.strip())
+            keywords = field_value.split(",")
+            item["tags"].extend({"tag": k.strip()} for k in keywords if k.strip())
         elif field_name in field_map:
             item[field_map[field_name]] = field_value.strip()
 
-    def _parse_creators(self, creators_text: str, creator_type: str) -> List[Dict[str, Any]]:
+    def _parse_creators(
+        self, creators_text: str, creator_type: str
+    ) -> List[Dict[str, Any]]:
         """Parse BibTeX author/editor field."""
         creators = []
 
         # Split by " and "
-        names = creators_text.split(' and ')
+        names = creators_text.split(" and ")
 
         for name in names:
             name = name.strip()
@@ -215,27 +219,27 @@ class BibTeXTranslator:
                 continue
 
             # Handle "Last, First" format
-            if ',' in name:
-                parts = name.split(',', 1)
+            if "," in name:
+                parts = name.split(",", 1)
                 creator = {
-                    'lastName': parts[0].strip(),
-                    'firstName': parts[1].strip(),
-                    'creatorType': creator_type
+                    "lastName": parts[0].strip(),
+                    "firstName": parts[1].strip(),
+                    "creatorType": creator_type,
                 }
             else:
                 # Handle "First Last" format
                 parts = name.split()
                 if len(parts) >= 2:
                     creator = {
-                        'firstName': ' '.join(parts[:-1]),
-                        'lastName': parts[-1],
-                        'creatorType': creator_type
+                        "firstName": " ".join(parts[:-1]),
+                        "lastName": parts[-1],
+                        "creatorType": creator_type,
                     }
                 else:
                     creator = {
-                        'lastName': name,
-                        'creatorType': creator_type,
-                        'fieldMode': True
+                        "lastName": name,
+                        "creatorType": creator_type,
+                        "fieldMode": True,
                     }
 
             creators.append(creator)
@@ -244,57 +248,57 @@ class BibTeXTranslator:
 
     def _export_item(self, item: Dict[str, Any]) -> str:
         """Export a single item to BibTeX format."""
-        item_type = item.get('itemType', 'misc')
-        bib_type = self.TYPE_MAP.get(item_type, 'misc')
+        item_type = item.get("itemType", "misc")
+        bib_type = self.TYPE_MAP.get(item_type, "misc")
 
         cite_key = self._build_cite_key(item)
 
         lines = [f"@{bib_type}{{{cite_key}"]
 
         # Add fields
-        if 'title' in item:
+        if "title" in item:
             lines.append(f",\n\ttitle = {{{item['title']}}}")
 
-        if 'creators' in item:
-            authors, editors = self._format_creators(item['creators'])
+        if "creators" in item:
+            authors, editors = self._format_creators(item["creators"])
             if authors:
                 lines.append(f",\n\tauthor = {{{authors}}}")
             if editors:
                 lines.append(f",\n\teditor = {{{editors}}}")
 
-        if 'publicationTitle' in item:
-            field = 'journal' if item_type == 'journalArticle' else 'booktitle'
+        if "publicationTitle" in item:
+            field = "journal" if item_type == "journalArticle" else "booktitle"
             lines.append(f",\n\t{field} = {{{item['publicationTitle']}}}")
 
-        if 'date' in item:
-            year_match = re.search(r'\d{4}', item['date'])
+        if "date" in item:
+            year_match = re.search(r"\d{4}", item["date"])
             if year_match:
                 lines.append(f",\n\tyear = {{{year_match.group(0)}}}")
 
-        for field in ['volume', 'pages', 'DOI', 'ISBN', 'ISSN', 'url', 'publisher']:
+        for field in ["volume", "pages", "DOI", "ISBN", "ISSN", "url", "publisher"]:
             if field in item and item[field]:
                 bib_field = field.lower()
                 lines.append(f",\n\t{bib_field} = {{{item[field]}}}")
 
         lines.append("\n}")
-        return ''.join(lines)
+        return "".join(lines)
 
     def _build_cite_key(self, item: Dict[str, Any]) -> str:
         """Build citation key."""
         parts = []
 
-        if 'creators' in item and item['creators']:
-            last_name = item['creators'][0].get('lastName', 'noauthor')
-            parts.append(last_name.lower().replace(' ', ''))
+        if "creators" in item and item["creators"]:
+            last_name = item["creators"][0].get("lastName", "noauthor")
+            parts.append(last_name.lower().replace(" ", ""))
         else:
-            parts.append('noauthor')
+            parts.append("noauthor")
 
-        if 'date' in item:
-            year_match = re.search(r'\d{4}', item['date'])
+        if "date" in item:
+            year_match = re.search(r"\d{4}", item["date"])
             if year_match:
                 parts.append(year_match.group(0))
 
-        base_key = '_'.join(parts) if parts else 'unknown'
+        base_key = "_".join(parts) if parts else "unknown"
 
         cite_key = base_key
         counter = 1
@@ -311,16 +315,16 @@ class BibTeXTranslator:
         editors = []
 
         for creator in creators:
-            if creator.get('firstName') and creator.get('lastName'):
+            if creator.get("firstName") and creator.get("lastName"):
                 name = f"{creator['lastName']}, {creator['firstName']}"
-            elif creator.get('lastName'):
-                name = creator['lastName']
+            elif creator.get("lastName"):
+                name = creator["lastName"]
             else:
                 continue
 
-            if creator.get('creatorType') == 'editor':
+            if creator.get("creatorType") == "editor":
                 editors.append(name)
             else:
                 authors.append(name)
 
-        return (' and '.join(authors), ' and '.join(editors))
+        return (" and ".join(authors), " and ".join(editors))