scitex 2.1.1__py3-none-any.whl

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

@@ -0,0 +1,172 @@
+"""
+Central and Eastern European Online Library Journals Translator
+
+Translates journal articles from CEEOL to Zotero format.
+
+Metadata:
+    translatorID: 19cef926-c5b6-42e2-a91c-6f2722f8b36d
+    label: Central and Eastern European Online Library Journals
+    creator: Timotheus Kim
+    target: ^https?://www\.ceeol\.com/search
+    minVersion: 3.0
+    priority: 100
+    inRepository: True
+    translatorType: 4
+    browserSupport: gcsibv
+    lastUpdated: 2021-09-22 20:12:37
+"""
+
+from typing import Dict, Any
+from bs4 import BeautifulSoup
+
+
+class CentralAndEasternEuropeanOnlineLibraryJournalsTranslator:
+    """Translator for CEEOL journal articles."""
+
+    METADATA = {
+        "translatorID": "19cef926-c5b6-42e2-a91c-6f2722f8b36d",
+        "label": "Central and Eastern European Online Library Journals",
+        "creator": "Timotheus Kim",
+        "target": r"^https?://www\.ceeol\.com/search",
+        "minVersion": "3.0",
+        "priority": 100,
+        "inRepository": True,
+        "translatorType": 4,
+        "browserSupport": "gcsibv",
+        "lastUpdated": "2021-09-22 20:12:37"
+    }
+
+    def detect_web(self, doc: BeautifulSoup, url: str) -> str:
+        """Detect if page is an article or search results."""
+        if '/article-detail?' in url:
+            return 'journalArticle'
+
+        # Check for search results
+        if doc.select('.description a, .article-details > h3 > a'):
+            return 'multiple'
+
+        return ''
+
+    def do_web(self, doc: BeautifulSoup, url: str) -> Dict[str, Any]:
+        """Extract article data using embedded metadata."""
+        item = self._extract_embedded_metadata(doc, url)
+        self._post_process(doc, item)
+        return item
+
+    def _extract_embedded_metadata(self, doc: BeautifulSoup, url: str) -> Dict[str, Any]:
+        """Extract metadata from meta tags."""
+        item = {
+            'itemType': 'journalArticle',
+            'creators': [],
+            'tags': [],
+            'attachments': [],
+            'url': url
+        }
+
+        # Title
+        title_meta = doc.find('meta', attrs={'name': 'citation_title'})
+        if title_meta:
+            item['title'] = title_meta.get('content', '')
+
+        # Authors
+        author_metas = doc.find_all('meta', attrs={'name': 'citation_author'})
+        for author_meta in author_metas:
+            author_name = author_meta.get('content', '')
+            if author_name:
+                item['creators'].append(self._clean_author(author_name))
+
+        # Publication title
+        journal_meta = doc.find('meta', attrs={'name': 'citation_journal_title'})
+        if journal_meta:
+            item['publicationTitle'] = journal_meta.get('content', '')
+
+        # Date
+        date_meta = doc.find('meta', attrs={'name': 'citation_publication_date'})
+        if date_meta:
+            item['date'] = date_meta.get('content', '')
+
+        # Volume
+        volume_meta = doc.find('meta', attrs={'name': 'citation_volume'})
+        if volume_meta:
+            item['volume'] = volume_meta.get('content', '')
+
+        # Issue
+        issue_meta = doc.find('meta', attrs={'name': 'citation_issue'})
+        if issue_meta:
+            item['issue'] = issue_meta.get('content', '')
+
+        # Pages
+        first_page_meta = doc.find('meta', attrs={'name': 'citation_firstpage'})
+        last_page_meta = doc.find('meta', attrs={'name': 'citation_lastpage'})
+        if first_page_meta and last_page_meta:
+            first_page = first_page_meta.get('content', '')
+            last_page = last_page_meta.get('content', '')
+            if first_page and last_page:
+                item['pages'] = f'{first_page}-{last_page}'
+
+        # ISSN
+        issn_meta = doc.find('meta', attrs={'name': 'citation_issn'})
+        if issn_meta:
+            item['ISSN'] = issn_meta.get('content', '')
+
+        # Language
+        lang_meta = doc.find('meta', attrs={'name': 'citation_language'})
+        if lang_meta:
+            item['language'] = lang_meta.get('content', '')
+
+        # Keywords
+        keywords_meta = doc.find('meta', attrs={'name': 'citation_keywords'})
+        if keywords_meta:
+            keywords = keywords_meta.get('content', '').split(';')
+            for keyword in keywords:
+                keyword = keyword.strip()
+                if keyword:
+                    item['tags'].append({'tag': keyword})
+
+        # PDF URL
+        pdf_meta = doc.find('meta', attrs={'name': 'citation_pdf_url'})
+        if pdf_meta:
+            pdf_url = pdf_meta.get('content', '')
+            if pdf_url:
+                item['attachments'].append({
+                    'url': pdf_url,
+                    'title': 'Full Text PDF',
+                    'mimeType': 'application/pdf'
+                })
+
+        return item
+
+    def _post_process(self, doc: BeautifulSoup, item: Dict[str, Any]):
+        """Post-process to add abstract if not in embedded metadata."""
+        if not item.get('abstractNote'):
+            abstract_elem = doc.select_one('p.summary')
+            if abstract_elem:
+                item['abstractNote'] = abstract_elem.get_text().strip()
+
+    def _clean_author(self, name: str) -> Dict[str, Any]:
+        """Parse author name."""
+        name = name.strip()
+
+        # Handle comma-separated (LastName, FirstName)
+        if ',' in name:
+            parts = name.split(',', 1)
+            return {
+                'firstName': parts[1].strip() if len(parts) > 1 else '',
+                'lastName': parts[0].strip(),
+                'creatorType': 'author'
+            }
+        else:
+            # Space-separated
+            parts = name.split()
+            if len(parts) >= 2:
+                return {
+                    'firstName': ' '.join(parts[:-1]),
+                    'lastName': parts[-1],
+                    'creatorType': 'author'
+                }
+            else:
+                return {
+                    'lastName': name,
+                    'creatorType': 'author',
+                    'fieldMode': True
+                }

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

@@ -0,0 +1,170 @@
+"""
+Champlain Society - Collection Translator
+
+Translates historical books from Champlain Society Collection to Zotero format.
+
+Metadata:
+    translatorID: 50d3ca81-3c4c-406b-afb2-0fe8105b9b38
+    label: Champlain Society - Collection
+    creator: Adam Crymble
+    target: ^https?://link\.library\.utoronto\.ca
+    minVersion: 1.0.0b4.r5
+    priority: 100
+    inRepository: True
+    translatorType: 4
+    browserSupport: gcsibv
+    lastUpdated: 2021-12-28 04:41:28
+"""
+
+from typing import Dict, Any
+from bs4 import BeautifulSoup
+import re
+
+
+class ChamplainSocietyCollectionTranslator:
+    """Translator for Champlain Society Collection."""
+
+    METADATA = {
+        "translatorID": "50d3ca81-3c4c-406b-afb2-0fe8105b9b38",
+        "label": "Champlain Society - Collection",
+        "creator": "Adam Crymble",
+        "target": r"^https?://link\.library\.utoronto\.ca",
+        "minVersion": "1.0.0b4.r5",
+        "priority": 100,
+        "inRepository": True,
+        "translatorType": 4,
+        "browserSupport": "gcsibv",
+        "lastUpdated": "2021-12-28 04:41:28"
+    }
+
+    def detect_web(self, doc: BeautifulSoup, url: str) -> str:
+        """Detect if page is a book or search results."""
+        if 'search_results' in url:
+            return 'multiple'
+        elif 'item_record' in url:
+            return 'book'
+        return ''
+
+    def do_web(self, doc: BeautifulSoup, url: str) -> Dict[str, Any]:
+        """Extract book data."""
+        return self.scrape(doc, url)
+
+    def scrape(self, doc: BeautifulSoup, url: str) -> Dict[str, Any]:
+        """
+        Scrape book data from the document.
+
+        Args:
+            doc: BeautifulSoup parsed document
+            url: URL of the page
+
+        Returns:
+            Dictionary containing book metadata
+        """
+        item = {
+            'itemType': 'book',
+            'creators': [],
+            'tags': [],
+            'attachments': [],
+            'url': url
+        }
+
+        data_tags = {}
+
+        # Extract metadata from table
+        table = doc.find('table')
+        if table:
+            rows = table.find_all('tr')
+            for row in rows:
+                header = row.find('b')
+                value_cell = row.find_all('td')
+
+                if header and len(value_cell) >= 2:
+                    field_title = header.get_text().strip().replace('\s+', '')
+                    field_value = value_cell[1].get_text().strip()
+
+                    # Normalize French to English
+                    field_title = self._normalize_field_name(field_title)
+                    data_tags[field_title] = field_value
+
+        # Process authors
+        if 'Author:' in data_tags:
+            author_text = data_tags['Author:']
+            if '; ' in author_text:
+                authors = author_text.split('; ')
+            else:
+                authors = [author_text]
+
+            for author in authors:
+                author = author.strip()
+                if ', ' in author:
+                    parts = author.split(', ', 1)
+                    first_name = parts[1] if len(parts) > 1 else ''
+                    last_name = parts[0]
+                    item['creators'].append({
+                        'firstName': first_name,
+                        'lastName': last_name,
+                        'creatorType': 'author'
+                    })
+                else:
+                    item['creators'].append({
+                        'lastName': author,
+                        'creatorType': 'author',
+                        'fieldMode': True
+                    })
+
+        # Process published information
+        if 'Published:' in data_tags:
+            published = data_tags['Published:']
+
+            # Extract place
+            if ': ' in published:
+                place_end = published.index(': ')
+                item['place'] = published[:place_end]
+                remainder = published[place_end + 2:]
+
+                # Extract date and publisher
+                if ', ' in remainder:
+                    date_start = remainder.rfind(', ')
+                    item['date'] = remainder[date_start + 2:]
+                    item['publisher'] = remainder[:date_start]
+                else:
+                    item['publisher'] = remainder
+
+        # Process subjects/tags
+        if 'Subjects:' in data_tags:
+            subjects = data_tags['Subjects:'].split('\n')
+            for subject in subjects:
+                subject = subject.strip()
+                if subject and re.search(r'\w', subject):
+                    item['tags'].append({'tag': subject})
+
+        # Other fields
+        self._associate_data(item, data_tags, 'Extent:', 'pages')
+        self._associate_data(item, data_tags, 'ID:', 'callNumber')
+        self._associate_data(item, data_tags, 'Notes:', 'abstractNote')
+
+        # Title
+        if 'Title:' in data_tags:
+            item['title'] = data_tags['Title:']
+        elif doc.title:
+            item['title'] = doc.title.string
+        else:
+            item['title'] = 'No Title Found: Champlain Collection'
+
+        return item
+
+    def _normalize_field_name(self, field_name: str) -> str:
+        """Normalize French field names to English."""
+        mapping = {
+            'Auteur:': 'Author:',
+            'Titre:': 'Title:',
+            'Description:': 'Extent:',
+            'Éditeur:': 'Published:',
+            'Sujet:': 'Subjects:'
+        }
+        return mapping.get(field_name, field_name)
+
+    def _associate_data(self, item: Dict, data_tags: Dict, field: str, zotero_field: str):
+        """Associate data from tags to item."""
+        if field in data_tags:
+            item[zotero_field] = data_tags[field]

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

@@ -0,0 +1,194 @@
+"""
+Chicago Journal of Theoretical Computer Science Translator
+
+Translates journal articles from CJTCS to Zotero format.
+
+Metadata:
+    translatorID: 1e2a9aba-eb04-4398-9e3a-630e6132db13
+    label: Chicago Journal of Theoretical Computer Science
+    creator: Morgan Shirley
+    target: ^https?://cjtcs\.cs\.uchicago\.edu/articles
+    minVersion: 5.0
+    priority: 100
+    inRepository: True
+    translatorType: 4
+    browserSupport: gcsibv
+    lastUpdated: 2025-05-14 00:10:19
+"""
+
+from typing import Dict, Any
+from bs4 import BeautifulSoup
+import re
+
+
+class ChicagoJournalOfTheoreticalComputerScienceTranslator:
+    """Translator for Chicago Journal of Theoretical Computer Science."""
+
+    METADATA = {
+        "translatorID": "1e2a9aba-eb04-4398-9e3a-630e6132db13",
+        "label": "Chicago Journal of Theoretical Computer Science",
+        "creator": "Morgan Shirley",
+        "target": r"^https?://cjtcs\.cs\.uchicago\.edu/articles",
+        "minVersion": "5.0",
+        "priority": 100,
+        "inRepository": True,
+        "translatorType": 4,
+        "browserSupport": "gcsibv",
+        "lastUpdated": "2025-05-14 00:10:19"
+    }
+
+    SINGLE_RE = re.compile(r'^https?://cjtcs\.cs\.uchicago\.edu/articles/\w+/\d+/contents\.html')
+    MULTIPLE_RE = re.compile(r'^https?://cjtcs\.cs\.uchicago\.edu/articles/\w+/contents\.html')
+
+    def detect_web(self, doc: BeautifulSoup, url: str) -> str:
+        """Detect if page is an article or volume contents."""
+        if self.MULTIPLE_RE.match(url):
+            # Check for article links
+            article_links = doc.select('ul > li > ul > li a[href*="contents.html"]')
+            if article_links:
+                return 'multiple'
+        elif self.SINGLE_RE.match(url):
+            return 'journalArticle'
+
+        return ''
+
+    async def do_web(self, doc: BeautifulSoup, url: str, request_text_func) -> Dict[str, Any]:
+        """Extract article data."""
+        return await self.scrape(doc, url, request_text_func)
+
+    async def scrape(self, doc: BeautifulSoup, url: str, request_text_func) -> Dict[str, Any]:
+        """
+        Scrape article data by fetching and parsing BibTeX.
+
+        Args:
+            doc: BeautifulSoup parsed document
+            url: URL of the page
+            request_text_func: Function to request text content
+
+        Returns:
+            Dictionary containing article metadata
+        """
+        item = {
+            'itemType': 'journalArticle',
+            'creators': [],
+            'tags': [],
+            'attachments': []
+        }
+
+        # Find BibTeX link
+        bib_link = doc.select_one('a[href$=".bib"]')
+        if bib_link and bib_link.get('href'):
+            bib_url = bib_link['href']
+            if not bib_url.startswith('http'):
+                bib_url = 'http://cjtcs.cs.uchicago.edu' + bib_url
+
+            # Fetch BibTeX
+            bib_text = await request_text_func(bib_url)
+            if bib_text:
+                # Fix author line if needed
+                bib_text = self._fix_author_line(bib_text)
+                # Parse BibTeX
+                self._parse_bibtex(bib_text, item)
+
+        # Extract DOI
+        doi_link = doc.select_one('a[href*="dx.doi.org"]')
+        if doi_link and doi_link.get('href'):
+            doi_url = doi_link['href']
+            item['DOI'] = re.sub(r'https?://(?:dx\.)?doi\.org/', '', doi_url)
+
+        # Add PDF attachment if available
+        pdf_link = doc.select_one('a[href$=".pdf"]')
+        if pdf_link and pdf_link.get('href'):
+            pdf_url = pdf_link['href']
+            if not pdf_url.startswith('http'):
+                pdf_url = 'http://cjtcs.cs.uchicago.edu' + pdf_url
+            item['attachments'].append({
+                'url': pdf_url,
+                'title': 'Full Text PDF',
+                'mimeType': 'application/pdf'
+            })
+        else:
+            # Add snapshot if no PDF
+            item['attachments'].append({
+                'title': 'Snapshot',
+                'mimeType': 'text/html',
+                'url': url
+            })
+
+        return item
+
+    def _fix_author_line(self, bib_text: str) -> str:
+        """Fix BibTeX author line if missing equals sign."""
+        lines = bib_text.split('\n')
+        fixed_lines = []
+        for line in lines:
+            # Add equals sign after "author" if missing
+            fixed_line = re.sub(r'^(\s*author)(?!\s*=)', r'\1=', line)
+            fixed_lines.append(fixed_line)
+        return '\n'.join(fixed_lines)
+
+    def _parse_bibtex(self, bib_text: str, item: Dict[str, Any]):
+        """Parse BibTeX and fill item fields."""
+        # Simple BibTeX parser
+        # Extract title
+        title_match = re.search(r'title\s*=\s*[{"](.*?)[}"]', bib_text, re.IGNORECASE | re.DOTALL)
+        if title_match:
+            item['title'] = title_match.group(1).strip()
+
+        # Extract authors
+        author_match = re.search(r'author\s*=\s*[{"](.*?)[}"]', bib_text, re.IGNORECASE | re.DOTALL)
+        if author_match:
+            authors = author_match.group(1).strip()
+            # Split by 'and'
+            for author in authors.split(' and '):
+                author = author.strip()
+                if author:
+                    item['creators'].append(self._parse_author(author))
+
+        # Extract year/date
+        year_match = re.search(r'year\s*=\s*[{"](.*?)[}"]', bib_text, re.IGNORECASE)
+        if year_match:
+            item['date'] = year_match.group(1).strip()
+
+        # Extract volume
+        volume_match = re.search(r'volume\s*=\s*[{"](.*?)[}"]', bib_text, re.IGNORECASE)
+        if volume_match:
+            item['volume'] = volume_match.group(1).strip()
+
+        # Extract issue/number
+        issue_match = re.search(r'(?:issue|number)\s*=\s*[{"](.*?)[}"]', bib_text, re.IGNORECASE)
+        if issue_match:
+            item['issue'] = issue_match.group(1).strip()
+
+        # Extract journal
+        journal_match = re.search(r'journal\s*=\s*[{"](.*?)[}"]', bib_text, re.IGNORECASE)
+        if journal_match:
+            item['publicationTitle'] = journal_match.group(1).strip()
+
+    def _parse_author(self, author_str: str) -> Dict[str, Any]:
+        """Parse author name from BibTeX format."""
+        author_str = author_str.strip()
+
+        # Handle "Last, First" format
+        if ',' in author_str:
+            parts = author_str.split(',', 1)
+            return {
+                'firstName': parts[1].strip() if len(parts) > 1 else '',
+                'lastName': parts[0].strip(),
+                'creatorType': 'author'
+            }
+        else:
+            # Handle "First Last" format
+            parts = author_str.split()
+            if len(parts) >= 2:
+                return {
+                    'firstName': ' '.join(parts[:-1]),
+                    'lastName': parts[-1],
+                    'creatorType': 'author'
+                }
+            else:
+                return {
+                    'lastName': author_str,
+                    'creatorType': 'author',
+                    'fieldMode': True
+                }

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

@@ -0,0 +1,124 @@
+"""
+Christian Science Monitor Translator
+
+Translates magazine articles from Christian Science Monitor to Zotero format.
+
+Metadata:
+    translatorID: 04c0db88-a7fc-4d1a-9cf7-471d0990acb1
+    label: Christian Science Monitor
+    creator: Sebastian Karcher
+    target: ^https?://(features\.csmonitor|www\.csmonitor)\.com
+    minVersion: 2.1.9
+    priority: 100
+    inRepository: True
+    translatorType: 4
+    browserSupport: gcsibv
+    lastUpdated: 2016-11-01 18:26:01
+"""
+
+from typing import Dict, Any
+from bs4 import BeautifulSoup
+
+
+class ChristianScienceMonitorTranslator:
+    """Translator for Christian Science Monitor magazine articles."""
+
+    METADATA = {
+        "translatorID": "04c0db88-a7fc-4d1a-9cf7-471d0990acb1",
+        "label": "Christian Science Monitor",
+        "creator": "Sebastian Karcher",
+        "target": r"^https?://(features\.csmonitor|www\.csmonitor)\.com",
+        "minVersion": "2.1.9",
+        "priority": 100,
+        "inRepository": True,
+        "translatorType": 4,
+        "browserSupport": "gcsibv",
+        "lastUpdated": "2016-11-01 18:26:01"
+    }
+
+    def detect_web(self, doc: BeautifulSoup, url: str) -> str:
+        """Detect if page is an article or search results."""
+        if doc.select_one('h1#headline'):
+            return 'magazineArticle'
+
+        if '/content/search?' in url:
+            return 'multiple'
+
+        return ''
+
+    def do_web(self, doc: BeautifulSoup, url: str) -> Dict[str, Any]:
+        """Extract article data."""
+        return self.scrape(doc, url)
+
+    def scrape(self, doc: BeautifulSoup, url: str) -> Dict[str, Any]:
+        """
+        Scrape article data from the document.
+
+        Args:
+            doc: BeautifulSoup parsed document
+            url: URL of the page
+
+        Returns:
+            Dictionary containing article metadata
+        """
+        item = {
+            'itemType': 'magazineArticle',
+            'creators': [],
+            'tags': [],
+            'attachments': [],
+            'url': url,
+            'ISSN': '0882-7729',
+            'publicationTitle': 'Christian Science Monitor'
+        }
+
+        # Title
+        headline = doc.select_one('h1#headline')
+        if headline:
+            item['title'] = headline.get_text().strip()
+
+        # Authors
+        author_meta = doc.find('meta', attrs={'name': 'sailthru.author'})
+        if author_meta and author_meta.get('content'):
+            author_text = author_meta['content']
+            # Handle multiple authors
+            authors = [a.strip() for a in author_text.split(',')]
+            for author in authors:
+                if author:
+                    item['creators'].append(self._clean_author(author))
+
+        # Date
+        date_elem = doc.select_one('time#date-published')
+        if date_elem and date_elem.get('datetime'):
+            item['date'] = date_elem['datetime']
+
+        # Abstract
+        summary = doc.select_one('h2#summary')
+        if summary:
+            item['abstractNote'] = summary.get_text().strip()
+
+        # Snapshot attachment
+        item['attachments'].append({
+            'title': 'CS Monitor Snapshot',
+            'mimeType': 'text/html',
+            'url': url
+        })
+
+        return item
+
+    def _clean_author(self, name: str) -> Dict[str, Any]:
+        """Parse author name into first and last name."""
+        name = name.strip()
+        parts = name.split()
+
+        if len(parts) >= 2:
+            return {
+                'firstName': ' '.join(parts[:-1]),
+                'lastName': parts[-1],
+                'creatorType': 'author'
+            }
+        else:
+            return {
+                'lastName': name,
+                'creatorType': 'author',
+                'fieldMode': True
+            }