pydpm_xl 0.2.6__tar.gz → 0.2.8__tar.gz

{pydpm_xl-0.2.6/pydpm_xl.egg-info → pydpm_xl-0.2.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydpm_xl
-Version: 0.2.6
+Version: 0.2.8
 Summary: Python library for DPM-XL data processing and analysis
 Author-email: "MeaningfulData S.L." <info@meaningfuldata.eu>
 License: GPL-3.0-or-later

{pydpm_xl-0.2.6 → pydpm_xl-0.2.8}/py_dpm/__init__.py

@@ -41,7 +41,7 @@ Available packages:
 - pydpm.api: Main APIs for migration, syntax, and semantic analysis
 """
 
-__version__ = "0.2.6"
+__version__ = "0.2.8"
 __author__ = "MeaningfulData S.L."
 __email__ = "info@meaningfuldata.eu"
 __license__ = "GPL-3.0-or-later"

{pydpm_xl-0.2.6 → pydpm_xl-0.2.8}/py_dpm/api/dpm/data_dictionary.py

@@ -50,7 +50,10 @@ class DataDictionaryAPI:
     """
 
     def __init__(
-        self, database_path: Optional[str] = None, connection_url: Optional[str] = None
+        self,
+        database_path: Optional[str] = None,
+        connection_url: Optional[str] = None,
+        pool_config: Optional[Dict[str, Any]] = None,
     ):
         """
         Initialize the Data Dictionary API.
@@ -58,8 +61,14 @@ class DataDictionaryAPI:
         Args:
             database_path: Path to SQLite database (optional)
             connection_url: SQLAlchemy connection URL for PostgreSQL (optional)
+            pool_config: Connection pool configuration for PostgreSQL/MySQL (optional)
+                Supported keys: pool_size, max_overflow, pool_timeout, pool_recycle, pool_pre_ping.
         """
-        engine = get_engine(database_path=database_path, connection_url=connection_url)
+        engine = get_engine(
+            database_path=database_path,
+            connection_url=connection_url,
+            pool_config=pool_config
+        )
         self.session = get_session()
 
     # ==================== Release Query Methods ====================

{pydpm_xl-0.2.6 → pydpm_xl-0.2.8}/py_dpm/api/dpm_xl/ast_generator.py

@@ -48,6 +48,7 @@ class ASTGeneratorAPI:
 
     def __init__(self, database_path: Optional[str] = None,
                  connection_url: Optional[str] = None,
+                 pool_config: Optional[Dict[str, Any]] = None,
                  compatibility_mode: str = "auto",
                  enable_semantic_validation: bool = False):
         """
@@ -56,13 +57,19 @@ class ASTGeneratorAPI:
         Args:
             database_path: Optional path to SQLite data dictionary database
             connection_url: Optional SQLAlchemy connection URL for PostgreSQL
+            pool_config: Connection pool configuration for PostgreSQL/MySQL
             compatibility_mode: "auto", "3.1.0", "4.0.0", or "current"
             enable_semantic_validation: Enable semantic validation (requires database)
         """
         self.syntax_api = SyntaxAPI()
-        self.semantic_api = SemanticAPI(database_path=database_path, connection_url=connection_url) if enable_semantic_validation else None
+        self.semantic_api = SemanticAPI(
+            database_path=database_path,
+            connection_url=connection_url,
+            pool_config=pool_config
+        ) if enable_semantic_validation else None
         self.database_path = database_path
         self.connection_url = connection_url
+        self.pool_config = pool_config
         self.compatibility_mode = compatibility_mode
         self.enable_semantic = enable_semantic_validation
 

{pydpm_xl-0.2.6 → pydpm_xl-0.2.8}/py_dpm/api/dpm_xl/operation_scopes.py

@@ -100,7 +100,10 @@ class OperationScopesAPI:
     """
 
     def __init__(
-        self, database_path: Optional[str] = None, connection_url: Optional[str] = None
+        self,
+        database_path: Optional[str] = None,
+        connection_url: Optional[str] = None,
+        pool_config: Optional[Dict[str, Any]] = None,
     ):
         """
         Initialize the Operation Scopes API.
@@ -109,9 +112,12 @@ class OperationScopesAPI:
             database_path (Optional[str]): Path to SQLite database. If None, uses default from environment.
             connection_url (Optional[str]): Full SQLAlchemy connection URL (e.g., postgresql://user:pass@host:port/db).
                                           Takes precedence over database_path.
+            pool_config (Optional[Dict[str, Any]]): Connection pool configuration for PostgreSQL/MySQL.
+                Supported keys: pool_size, max_overflow, pool_timeout, pool_recycle, pool_pre_ping.
         """
         self.database_path = database_path
         self.connection_url = connection_url
+        self.pool_config = pool_config
 
         if connection_url:
             # Create isolated engine and session for the provided connection URL
@@ -119,7 +125,7 @@ class OperationScopesAPI:
             from py_dpm.dpm.utils import create_engine_from_url
 
             # Create engine for the connection URL (supports SQLite, PostgreSQL, MySQL, etc.)
-            self.engine = create_engine_from_url(connection_url)
+            self.engine = create_engine_from_url(connection_url, pool_config=pool_config)
             session_maker = sessionmaker(bind=self.engine)
             self.session = session_maker()
 

{pydpm_xl-0.2.6 → pydpm_xl-0.2.8}/py_dpm/api/dpm_xl/semantic.py

@@ -44,7 +44,10 @@ class SemanticAPI:
     """
 
     def __init__(
-        self, database_path: Optional[str] = None, connection_url: Optional[str] = None
+        self,
+        database_path: Optional[str] = None,
+        connection_url: Optional[str] = None,
+        pool_config: Optional[Dict[str, Any]] = None,
     ):
         """
         Initialize the Semantic API.
@@ -53,9 +56,12 @@ class SemanticAPI:
             database_path (Optional[str]): Path to SQLite database. If None, uses default from environment.
             connection_url (Optional[str]): Full SQLAlchemy connection URL (e.g., postgresql://user:pass@host:port/db).
                                           Takes precedence over database_path.
+            pool_config (Optional[Dict[str, Any]]): Connection pool configuration for PostgreSQL/MySQL.
+                Supported keys: pool_size, max_overflow, pool_timeout, pool_recycle, pool_pre_ping.
         """
         self.database_path = database_path
         self.connection_url = connection_url
+        self.pool_config = pool_config
         # Store last parsed AST for consumers that need it (e.g. complete AST generation)
         self.ast = None
 
@@ -65,7 +71,7 @@ class SemanticAPI:
             from py_dpm.dpm.utils import create_engine_from_url
 
             # Create engine for the connection URL (supports SQLite, PostgreSQL, MySQL, etc.)
-            self.engine = create_engine_from_url(connection_url)
+            self.engine = create_engine_from_url(connection_url, pool_config=pool_config)
             session_maker = sessionmaker(bind=self.engine)
             self.session = session_maker()
 

{pydpm_xl-0.2.6 → pydpm_xl-0.2.8}/py_dpm/dpm/utils.py

@@ -84,7 +84,7 @@ sessionMakerObject = None
 _current_engine_url = None
 
 
-def create_engine_from_url(connection_url):
+def create_engine_from_url(connection_url, pool_config=None):
     """
     Create SQLAlchemy engine from a connection URL with appropriate pooling parameters.
 
@@ -96,6 +96,12 @@ def create_engine_from_url(connection_url):
 
     Args:
         connection_url (str): SQLAlchemy connection URL (e.g., 'sqlite:///path.db', 'postgresql://user:pass@host/db')
+        pool_config (dict, optional): Custom pool configuration. Supported keys:
+            - pool_size (int): Maximum number of connections to maintain in the pool (default: 20)
+            - max_overflow (int): Maximum overflow connections beyond pool_size (default: 10)
+            - pool_timeout (int): Seconds to wait before giving up on getting a connection (default: 30)
+            - pool_recycle (int): Seconds before recycling connections (default: 180)
+            - pool_pre_ping (bool): Health check connections before using from pool (default: True)
 
     Returns:
         sqlalchemy.engine.Engine: Configured database engine
@@ -103,12 +109,21 @@ def create_engine_from_url(connection_url):
     Examples:
         >>> engine = create_engine_from_url('sqlite:///database.db')
         >>> engine = create_engine_from_url('postgresql://user:pass@localhost/mydb')
+        >>> engine = create_engine_from_url('postgresql://user:pass@localhost/mydb',
+        ...                                   pool_config={'pool_size': 5, 'max_overflow': 10})
     """
     global engine, sessionMakerObject, _current_engine_url
 
     # Detect database type from URL scheme
     is_sqlite = connection_url.startswith("sqlite://")
 
+    # For PostgreSQL, ensure ISO datestyle if not already set
+    # This prevents date parsing errors when PostgreSQL returns dates in locale format
+    is_postgres = connection_url.startswith("postgresql://")
+    if is_postgres and "datestyle" not in connection_url.lower():
+        separator = "&" if "?" in connection_url else "?"
+        connection_url = f"{connection_url}{separator}options=-c%20datestyle%3DISO"
+
     # For SQLite URLs, always create a fresh engine to avoid
     # surprising cross-test or cross-call state sharing, especially
     # for in-memory databases. For server-based databases, reuse the
@@ -123,12 +138,22 @@ def create_engine_from_url(connection_url):
         engine = create_engine(connection_url, pool_pre_ping=True)
     else:
         # Server-based databases (PostgreSQL, MySQL, etc.) with connection pooling
+        # Default pool configuration
+        default_pool_config = {
+            'pool_size': 20,
+            'max_overflow': 10,
+            'pool_timeout': 30,
+            'pool_recycle': 180,
+            'pool_pre_ping': True,
+        }
+
+        # Merge custom pool_config with defaults
+        if pool_config:
+            default_pool_config.update(pool_config)
+
         engine = create_engine(
             connection_url,
-            pool_size=20,
-            max_overflow=10,
-            pool_recycle=180,
-            pool_pre_ping=True,
+            **default_pool_config
         )
 
     # Initialize global sessionMakerObject
@@ -149,6 +174,14 @@ def create_engine_object(url):
     # Detect database type from URL scheme (not from environment variables)
     is_sqlite = url_str.startswith("sqlite://")
 
+    # For PostgreSQL, ensure ISO datestyle if not already set
+    # This prevents date parsing errors when PostgreSQL returns dates in locale format
+    is_postgres = url_str.startswith("postgresql://")
+    if is_postgres and "datestyle" not in url_str.lower():
+        separator = "&" if "?" in url_str else "?"
+        url_str = f"{url_str}{separator}options=-c%20datestyle%3DISO"
+        url = url_str  # Use modified URL for engine creation
+
     # Only reuse engines for non-SQLite URLs. SQLite (especially in-memory)
     # should create independent engines to avoid leaking state between calls.
     if not is_sqlite and engine is not None and _current_engine_url == url_str:
@@ -170,7 +203,7 @@ def create_engine_object(url):
     return engine
 
 
-def get_engine(owner=None, database_path=None, connection_url=None):
+def get_engine(owner=None, database_path=None, connection_url=None, pool_config=None):
     """
     Get database engine based on configuration or explicit parameters.
 
@@ -184,13 +217,14 @@ def get_engine(owner=None, database_path=None, connection_url=None):
         owner: Owner for SQL Server databases (EBA/EIOPA) - legacy support
         database_path: Explicit SQLite database path
         connection_url: Explicit SQLAlchemy connection URL (e.g., for PostgreSQL)
+        pool_config: Connection pool configuration dict (for PostgreSQL/MySQL)
 
     Returns:
         SQLAlchemy Engine
     """
     # Priority 1: If explicit connection URL is provided, use it directly
     if connection_url:
-        return create_engine_from_url(connection_url)
+        return create_engine_from_url(connection_url, pool_config=pool_config)
 
     # Priority 2: If explicit database_path is provided, use SQLite with that path
     if database_path:
@@ -211,6 +245,7 @@ def get_engine(owner=None, database_path=None, connection_url=None):
                 port = db_port or "5432"
                 connection_url = (
                     f"postgresql://{db_user}:{db_password}@{db_host}:{port}/{db_name}"
+                    "?options=-c%20datestyle%3DISO"
                 )
                 return create_engine_object(connection_url)
             else:
@@ -258,6 +293,7 @@ def get_engine(owner=None, database_path=None, connection_url=None):
             connection_url = (
                 f"postgresql://{postgres_user}:{postgres_pass}@"
                 f"{postgres_host}:{postgres_port}/{postgres_db}"
+                "?options=-c%20datestyle%3DISO"
             )
             return create_engine_object(connection_url)
 

{pydpm_xl-0.2.6 → pydpm_xl-0.2.8/pydpm_xl.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydpm_xl
-Version: 0.2.6
+Version: 0.2.8
 Summary: Python library for DPM-XL data processing and analysis
 Author-email: "MeaningfulData S.L." <info@meaningfuldata.eu>
 License: GPL-3.0-or-later

{pydpm_xl-0.2.6 → pydpm_xl-0.2.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pydpm_xl"
-version = "0.2.6"
+version = "0.2.8"
 description = "Python library for DPM-XL data processing and analysis"
 authors = [
     {name = "MeaningfulData S.L.", email = "info@meaningfuldata.eu"}
@@ -52,7 +52,7 @@ exclude = []
 
 [tool.poetry]
 name = "pydpm_xl"
-version = "0.2.5"
+version = "0.2.8"
 description = "Python library for DPM-XL data processing and analysis"
 authors = ["MeaningfulData S.L. <info@meaningfuldata.eu>"]
 readme = "README.md"