gcp-platforms-auto 0.8.4__py3-none-any.whl → 0.8.5__py3-none-any.whl

gcp_platforms_auto/db.py

@@ -4,27 +4,95 @@ import sqlalchemy
 from sqlalchemy.orm import sessionmaker, scoped_session, declarative_base
 from sqlalchemy import text
 
+import google.auth
+from google.cloud.sql.connector import Connector, IPTypes
+
 # Configure the logger
 logger = logging.getLogger("uvicorn")
 logger.setLevel(logging.INFO)
 
 Base = declarative_base()
 
-def get_sql_engine(db_host, db_user, db_pass, db_name, db_port=5432) -> sqlalchemy.engine.base.Engine:
-    """Initializes a TCP connection pool for a Cloud SQL instance of Postgres.
-    
+
+def get_sql_engine(
+    db_host=None,
+    db_user=None,
+    db_pass=None,
+    db_name=None,
+    db_port=5432,
+    instance_connection_name=None,
+) -> sqlalchemy.engine.base.Engine:
+    """Initializes a connection pool for a Cloud SQL instance.
+
+    If instance_connection_name is provided (or found in INSTANCE_CONNECTION_NAME env var),
+    it uses the Cloud SQL Python Connector with IAM authentication.
+    Otherwise, it falls back to a TCP connection.
+
     Args:
         db_host: Database host address (e.g., '127.0.0.1')
-        db_user: Database username
-        db_pass: Database password
-        db_name: Database name
+        db_user: Database username (for IAM, defaults to detecting the service account email)
+        db_pass: Database password (not used for IAM)
+        db_name: Database name (defaults to DB_NAME env var)
         db_port: Database port (default: 5432)
-    
+        instance_connection_name: Cloud SQL instance connection name (PROJECT:REGION:INSTANCE)
+
     Returns:
         SQLAlchemy Engine instance
     """
+    # Try to get defaults from environment if not provided
+    instance_connection_name = instance_connection_name or os.getenv(
+        "INSTANCE_CONNECTION_NAME"
+    )
+    db_name = db_name or os.getenv("DB_NAME")
+
+    if instance_connection_name:
+        # If db_user is not provided, try to detect the service account email
+        if not db_user:
+            try:
+                credentials, _ = google.auth.default()
+                if hasattr(credentials, "service_account_email"):
+                    # For Postgres IAM, the user is the service account email without .gserviceaccount.com
+                    sa_email = credentials.service_account_email
+                    db_user = sa_email.replace(".gserviceaccount.com", "")
+                    logger.info(
+                        f"Auto-detected service account for IAM auth: {db_user}"
+                    )
+                elif hasattr(credentials, "signer_email"):
+                    # Fallback for some credential types
+                    db_user = credentials.signer_email.replace(
+                        ".gserviceaccount.com", ""
+                    )
+                    logger.info(f"Auto-detected service account from signer: {db_user}")
+            except Exception as e:
+                logger.warning(f"Could not auto-detect service account email: {e}")
+
+        logger.info(
+            f"Connecting to Cloud SQL instance '{instance_connection_name}' using IAM auth as user '{db_user}'."
+        )
+
+        # initialize Connector object
+        connector = Connector()
+
+        def getconn():
+            conn = connector.connect(
+                instance_connection_name,
+                "pg8000",
+                user=db_user,
+                db=db_name,
+                enable_iam_auth=True,
+                ip_type=IPTypes.PRIVATE,
+            )
+            return conn
+
+        pool = sqlalchemy.create_engine(
+            "postgresql+pg8000://",
+            creator=getconn,
+        )
+        logger.info("Successfully created Cloud SQL connector connection pool.")
+        return pool
+
     logger.info(f"Connecting to database '{db_name}' at {db_host}:{db_port}")
-    
+
     try:
         pool = sqlalchemy.create_engine(
             # Equivalent URL:
@@ -38,32 +106,34 @@ def get_sql_engine(db_host, db_user, db_pass, db_name, db_port=5432) -> sqlalche
                 database=db_name,
             ),
         )
-        logger.info("Successfully created database connection pool.")
+        logger.info("Successfully created TCP database connection pool.")
         return pool
     except Exception as e:
         logger.exception(f"Error connecting to database: {str(e)}")
         raise e
 
+
 def get_session(engine):
     """Creates and returns a new session for the provided engine.
-    
+
     Args:
         engine: SQLAlchemy Engine instance
-    
+
     Returns:
         SQLAlchemy Session instance
     """
     Session = sessionmaker(bind=engine)
     return Session()
 
+
 def execute_query(engine, query_str: str, params: dict = None):
     """Executes a raw SQL query.
-    
+
     Args:
         engine: SQLAlchemy Engine instance
         query_str: SQL query string
         params: Dictionary of query parameters (optional)
-    
+
     Returns:
         Query result
     """
@@ -81,9 +151,10 @@ def execute_query(engine, query_str: str, params: dict = None):
     finally:
         session.close()
 
+
 def create_tables(engine, base_class=Base):
     """Creates all tables defined in the SQLAlchemy Base metadata.
-    
+
     Args:
         engine: SQLAlchemy Engine instance
         base_class: SQLAlchemy declarative base class (default: Base)
@@ -96,13 +167,14 @@ def create_tables(engine, base_class=Base):
         logger.exception(f"Error creating tables: {str(e)}")
         raise e
 
+
 def save_model(engine, model_instance):
     """Saves a single model instance to the database.
-    
+
     Args:
         engine: SQLAlchemy Engine instance
         model_instance: SQLAlchemy model instance to save
-    
+
     Returns:
         The saved model instance with refreshed data
     """
@@ -121,13 +193,14 @@ def save_model(engine, model_instance):
     finally:
         session.close()
 
+
 def get_all(engine, model_class):
     """Retrieves all records for a given model class.
-    
+
     Args:
         engine: SQLAlchemy Engine instance
         model_class: SQLAlchemy model class
-    
+
     Returns:
         List of all records for the model
     """
@@ -143,14 +216,15 @@ def get_all(engine, model_class):
     finally:
         session.close()
 
+
 def get_by_id(engine, model_class, record_id):
     """Retrieves a single record by its primary key ID.
-    
+
     Args:
         engine: SQLAlchemy Engine instance
         model_class: SQLAlchemy model class
         record_id: Primary key value to search for
-    
+
     Returns:
         Model instance if found, None otherwise
     """
@@ -169,14 +243,15 @@ def get_by_id(engine, model_class, record_id):
     finally:
         session.close()
 
+
 def get_by_filter(engine, model_class, **filters):
     """Retrieves records matching the provided filter criteria.
-    
+
     Args:
         engine: SQLAlchemy Engine instance
         model_class: SQLAlchemy model class
         **filters: Keyword arguments for filtering (e.g., name="John", age=30)
-    
+
     Returns:
         List of matching records
     """
@@ -192,20 +267,23 @@ def get_by_filter(engine, model_class, **filters):
     finally:
         session.close()
 
+
 def get_one(engine, model_class, **filters):
     """Retrieves a single record matching the provided filter criteria.
-    
+
     Args:
         engine: SQLAlchemy Engine instance
         model_class: SQLAlchemy model class
         **filters: Keyword arguments for filtering (e.g., email="user@example.com")
-    
+
     Returns:
         First matching model instance if found, None otherwise
     """
     session = get_session(engine)
     try:
-        logger.info(f"Retrieving single {model_class.__name__} with criteria: {filters}")
+        logger.info(
+            f"Retrieving single {model_class.__name__} with criteria: {filters}"
+        )
         result = session.query(model_class).filter_by(**filters).first()
         if result:
             logger.info(f"Found matching record.")
@@ -218,13 +296,14 @@ def get_one(engine, model_class, **filters):
     finally:
         session.close()
 
+
 def update_model(engine, model_instance):
     """Updates an existing model instance in the database.
-    
+
     Args:
         engine: SQLAlchemy Engine instance
         model_instance: SQLAlchemy model instance with updated values
-    
+
     Returns:
         The updated model instance with refreshed data
     """
@@ -242,9 +321,10 @@ def update_model(engine, model_instance):
     finally:
         session.close()
 
+
 def delete_model(engine, model_instance):
     """Deletes a model instance from the database.
-    
+
     Args:
         engine: SQLAlchemy Engine instance
         model_instance: SQLAlchemy model instance to delete
@@ -262,9 +342,10 @@ def delete_model(engine, model_instance):
     finally:
         session.close()
 
+
 def cleanup_connector(engine):
     """Disposes the connection pool for the provided engine.
-    
+
     Args:
         engine: SQLAlchemy Engine instance to dispose
     """

{gcp_platforms_auto-0.8.4.dist-info → gcp_platforms_auto-0.8.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gcp_platforms_auto
-Version: 0.8.4
+Version: 0.8.5
 Summary: A brief description of your package
 Author-email: ofir4858 <ofirshasha10@gmail.com>
 License: MIT
@@ -17,5 +17,11 @@ Requires-Dist: gitpython
 Requires-Dist: sqlalchemy
 Requires-Dist: pg8000
 Requires-Dist: pydantic
+Requires-Dist: fastapi
+Requires-Dist: uvicorn
+Requires-Dist: pydantic-settings
+Requires-Dist: google-cloud-storage
+Requires-Dist: google-cloud-pubsub
+Requires-Dist: cloud-sql-python-connector[pg8000]
 
 # gcp_sdk

{gcp_platforms_auto-0.8.4.dist-info → gcp_platforms_auto-0.8.5.dist-info}/RECORD

@@ -1,9 +1,9 @@
 gcp_platforms_auto/__init__.py,sha256=pKouDuMclA8r93k5H9TjGbxNsFwqIYfymjO-owuGGws,526
-gcp_platforms_auto/db.py,sha256=jE5nwmqVHcxT4m6-meUgUz4V4DM8M_sMmeTpvKr2Z2Y,8768
+gcp_platforms_auto/db.py,sha256=N9VNJgJklvbI1hkVjIt2oMlF-klvhfTqjURNOQgiKuk,11346
 gcp_platforms_auto/git.py,sha256=NnLDfRzzrzbm9yekepc-qgu8ejYmjNxQ4VDlW46gG2o,5508
 gcp_platforms_auto/iam.py,sha256=wnMZ_jl2YM5dLY8LqtPfEyh_0Osqs1ypsxakJGmwHVw,11614
 gcp_platforms_auto/models.py,sha256=mVg8NKV25kqdTuazqenAp7Ay03N5D8GIh3F_TWP0zyI,853
-gcp_platforms_auto-0.8.4.dist-info/METADATA,sha256=UU0EYfRtyhRgQW_1867j05FBs16hAAan5w_UWKQn15w,600
-gcp_platforms_auto-0.8.4.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-gcp_platforms_auto-0.8.4.dist-info/top_level.txt,sha256=4q-ofPMmvBaTnIbAzs-Wp_OwheAVxxmJ1fW9vl3-kyE,19
-gcp_platforms_auto-0.8.4.dist-info/RECORD,,
+gcp_platforms_auto-0.8.5.dist-info/METADATA,sha256=KlHmSF84Vk2FGVpYwupOdOWxAhOAvRs4yuWbg0xCP-w,800
+gcp_platforms_auto-0.8.5.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+gcp_platforms_auto-0.8.5.dist-info/top_level.txt,sha256=4q-ofPMmvBaTnIbAzs-Wp_OwheAVxxmJ1fW9vl3-kyE,19
+gcp_platforms_auto-0.8.5.dist-info/RECORD,,