tulit 0.2.2__tar.gz → 0.2.4__tar.gz

{tulit-0.2.2 → tulit-0.2.4}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: tulit
-Version: 0.2.2
-Summary: TULIT - The Universal Legal Informatics Toolkit, is set of legal informatics utilities collected in a Python package that focuses on the retrieval of legal data and metadata from official sources in the EU, and their transformation in pythonic data structures
+Version: 0.2.4
+Summary: TULIT - The Universal Legal Informatics Toolkit, is set of legal informatics utilities collected in a Python package that focuses on the retrieval of legal data and metadata from official sources in the EU, and their transformation in legalJSON, a pythonic data structure for legal documents
 License: EUPL 1.2
 Author: AlessioNar
 Author-email: alessio.nardin@gmail.com
@@ -10,6 +10,7 @@ Classifier: License :: Other/Proprietary License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Requires-Dist: beautifulsoup4 (>=4.9.3,<5.0.0)
 Requires-Dist: chardet (>=5.2.0,<6.0.0)
 Requires-Dist: coverage (>=7.6.9,<8.0.0)

{tulit-0.2.2 → tulit-0.2.4}/pyproject.toml

@@ -1,12 +1,12 @@
 [project]
 name = "tulit"
-version = "0.2.2"
-description = "TULIT - The Universal Legal Informatics Toolkit, is set of legal informatics utilities collected in a Python package that focuses on the retrieval of legal data and metadata from official sources in the EU, and their transformation in pythonic data structures"
+version = "0.2.4"
+description = "TULIT - The Universal Legal Informatics Toolkit, is set of legal informatics utilities collected in a Python package that focuses on the retrieval of legal data and metadata from official sources in the EU, and their transformation in legalJSON, a pythonic data structure for legal documents"
 
 [tool.poetry]
 name = "tulit"
-version = "0.2.2"
-description = "TULIT - The Universal Legal Informatics Toolkit, is set of legal informatics utilities collected in a Python package that focuses on the retrieval of legal data and metadata from official sources in the EU, and their transformation in pythonic data structures"
+version = "0.2.4"
+description = "TULIT - The Universal Legal Informatics Toolkit, is set of legal informatics utilities collected in a Python package that focuses on the retrieval of legal data and metadata from official sources in the EU, and their transformation in legalJSON, a pythonic data structure for legal documents"
 authors = ["AlessioNar <alessio.nardin@gmail.com>"]
 license = "EUPL 1.2"
 readme = "README.md"

{tulit-0.2.2 → tulit-0.2.4}/tulit/parsers/xml/formex.py

@@ -191,48 +191,41 @@ class Formex4Parser(XMLParser):
                 
                 children = []
                 
+                index = 0
+                
                 # Check whether within the ARTICLE element there are 
                 # QUOT.S elements, that mark the presence of amendments
                 if article.findall('.//QUOT.S'):
                     for alinea in article.xpath('.//ALINEA[not(ancestor::QUOT.S)]'):
                         children.append({
-                            "eId": 0,
+                            "eId": index,
                             "text": self.clean_text(alinea),
                             "amendment": True
                         })
-                        
-                    #article.xpath('.//ALINEA')
-                    
-                    
-                    # Treat amendments. First extract the text contained within the
-                    # a P element that is outside of a LIST element
-                    #for p in article.xpath('.//P[not(ancestor::LIST)]'):
-                    #    self._extract_elements(p, '.', children)
-                    
-                    # Treat all the rest of the content of the ARTICLE element
-                    # as a unique child
-                    #children
-                    
+                                            
                 
-                # Extract text and metadata from PARAG elements that are not descendants of QUOT.S elements (exclude amendments)
+                # Extract text and metadata from PARAG elements 
+                # that are not descendants of QUOT.S elements (exclude amendments)
                 elif article.xpath('.//PARAG'):
                     self._extract_elements(article, './/PARAG', children)
                 elif article.findall('.//ALINEA'):
                     # If no PARAG elements, check for ALINEA elements
                     alineas = article.xpath('.//ALINEA')
                     for alinea in alineas:
+                        
                         p_elements = alinea.xpath('.//P')
-                        if p_elements:
+                        if p_elements:                            
                             for p in p_elements:
-                                self._extract_elements(p, '.', children)
-                            for item in alinea.findall('.//LIST//ITEM'):
-                                self._extract_elements(item, '.', children)                                
+                                if not p.xpath('ancestor::ITEM'):                            
+                                    self._extract_elements(p, '.', children)
+                            # Extract text and metadata from LIST/ITEM elements that are a direct child of ALINEA
+                            # And exclude those that are descendants of other LIST/ITEM elements
+                            for item in alinea.xpath('./LIST/ITEM'):
+                                # Check if this is a top-level item (its parent LIST is a direct child of ALINEA)
+                                self._extract_elements(item, '.', children)
                         else:
                             self._extract_elements(alinea, '.', children)
                 
-                                    
-                    
-                
                 self.articles.append({
                     "eId": article_eId,
                     "num": article.findtext('.//TI.ART') or article.findtext('.//TI.ART//P'),
@@ -244,21 +237,7 @@ class Formex4Parser(XMLParser):
         else:
             print('No enacting terms XML tag has been found')
             return []
-        
-    def clean_text(self, element):
-        for sub_element in element.iter():
-            if sub_element.tag == 'QUOT.START':                    
-                sub_element.text = "‘"                    
-            elif sub_element.tag == 'QUOT.END':                    
-                sub_element.text = "’"
-        text = "".join(element.itertext()).strip()
-        text = re.sub(r'^\(\d+\)', '', text).strip()
-        text = text.replace('\n', '').replace('\t', '').replace('\r', '')  # remove newline and tab characters
-        text = text.replace('\u00A0', ' ')  # replace non-breaking spaces with regular spaces
-        text = re.sub(' +', ' ', text)  # replace multiple spaces with a single space
-        text = re.sub(r'\s+([.,!?;:’])', r'\1', text)  # replace spaces before punctuation with nothing
-        return text
-    
+            
     def _extract_elements(self, parent, xpath, children):
         """
         Helper method to extract text and metadata from elements.
@@ -318,6 +297,23 @@ class Formex4Parser(XMLParser):
         return self.conclusions
         
 
+    def clean_text(self, element):
+        for sub_element in element.iter(): # Replace QUOT.START and QUOT.END elements with proper quotes
+            if sub_element.tag == 'QUOT.START':                    
+                sub_element.text = "‘"                    
+            elif sub_element.tag == 'QUOT.END':                    
+                sub_element.text = "’"
+                
+        text = "".join(element.itertext()).strip() # Join text content of element and its descendants
+        text = re.sub(r'^\(\d+\)', '', text).strip() # Remove leading numbers in parentheses`
+        text = text.replace('\n', '').replace('\t', '').replace('\r', '') # remove newline and tab characters
+        text = text.replace('\u00A0', ' ')  # replace non-breaking spaces with regular spaces
+        text = re.sub(' +', ' ', text)  # replace multiple spaces with a single space
+        text = re.sub(r'\s+([.,!?;:’])', r'\1', text)  # replace spaces before punctuation with nothing
+        
+        return text
+
+    
     def parse(self, file):
         """
         Parses a FORMEX XML document to extract its components, which are inherited from the XMLParser class.

{tulit-0.2.2 → tulit-0.2.4}/tulit/parsers/xml/xml.py

@@ -3,6 +3,10 @@ import os
 import re
 from tulit.parsers.parser import Parser
 
+import logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
 class XMLParser(Parser):
     """
     Base class for XML parsers.
@@ -437,67 +441,79 @@ class XMLParser(Parser):
             if self.valid == True:
                 try:
                     self.get_root(file)
-                    print("Root element loaded successfully.")
+                    logger.info(f"Root element loaded successfully.")                    
                 except Exception as e:
-                    print(f"Error in get_root: {e}")
+                    logger.error(f"Error in get_root: {e}")
+                    
                     
                 try:
                     self.get_preface()
-                    print(f"Preface parsed successfully. Preface: {self.preface}")
+                    logger.info(f"Preface element found. Preface: {self.preface}")                    
                 except Exception as e:
-                    print(f"Error in get_preface: {e}")
+                    logger.error(f"Error in get_preface: {e}")                    
                 
                 try:
                     self.get_preamble()
-                    print(f"Preamble element found.")
+                    logger.info(f"Preamble element found.")                    
                 except Exception as e:
-                    print(f"Error in get_preamble: {e}")
+                    logger.error(f"Error in get_preamble: {e}")                    
                 try:
                     self.get_formula()
-                    print(f"Formula parsed successfully.")
+                    logger.info(f"Formula element found. Formula: {self.formula}")                    
                 except Exception as e:
-                    print(f"Error in get_formula: {e}")
+                    logger.error(f"Error in get_formula: {e}")                    
                 try:
                     self.get_citations()
-                    print(f"Citations parsed successfully. Number of citations: {len(self.citations)}")
+                    logger.info(f"Citations parsed successfully. Number of citations: {len(self.citations)}")
+                    
                 except Exception as e:
-                    print(f"Error in get_citations: {e}")
+                    logger.error(f"Error in get_citations: {e}")
+                    
                 try:
                     self.get_recitals()
-                    print(f"Recitals parsed successfully. Number of recitals: {len(self.recitals)}")
+                    logger.info(f"Recitals parsed successfully. Number of recitals: {len(self.recitals)}")
+                    
                 except Exception as e:
-                    print(f"Error in get_recitals: {e}")
+                    logger.error(f"Error in get_recitals: {e}")
+                    
                 
                 try:
                     self.get_preamble_final()
-                    print(f"Preamble final parsed successfully.")
+                    logger.info(f"Preamble final parsed successfully.")
+                    
                 except Exception as e:
-                    print(f"Error in get_preamble_final: {e}")
+                    logger.error(f"Error in get_preamble_final: {e}")
+                    
                 
                 try:
                     self.get_body()
-                    print("Body element found.")
+                    logger.info(f"Body element found.")                    
                 except Exception as e:
-                    print(f"Error in get_body: {e}")
+                    logger.error(f"Error in get_body: {e}")
+                    
                 try:
                     self.get_chapters()
-                    print(f"Chapters parsed successfully. Number of chapters: {len(self.chapters)}")
+                    logger.info(f"Chapters parsed successfully. Number of chapters: {len(self.chapters)}")
+                    
                 except Exception as e:
-                    print(f"Error in get_chapters: {e}")
+                    logger.error(f"Error in get_chapters: {e}")
+                    
                 try:
                     self.get_articles()
-                    print(f"Articles parsed successfully. Number of articles: {len(self.articles)}")
-                    print(f"Total number of children in articles: {sum([len(list(article)) for article in self.articles])}")                        
+                    logger.info(f"Articles parsed successfully. Number of articles: {len(self.articles)}")
+                    logger.info(f"Total number of children in articles: {sum([len(list(article)) for article in self.articles])}")                    
                     
                 except Exception as e:
-                    print(f"Error in get_articles: {e}")
+                    logger.error(f"Error in get_articles: {e}")
+                                        
                 try:
                     self.get_conclusions()                    
-                    print(f"Conclusions parsed successfully. ")
+                    logger.info(f"Conclusions parsed successfully.")
+                    
                 except Exception as e:
-                    print(f"Error in get_conclusions: {e}")
+                    logger.error(f"Error in get_conclusions: {e}")                    
                 
             return self
                 
         except Exception as e:
-            print(f'Invalid {self.format} file: parsing may not work or work only partially: {e}')
+            logger.warn(f"Invalid {format} file: parsing may not work or work only partially: {e}")