srx-lib-azure 0.1.2__py3-none-any.whl

srx_lib_azure/__init__.py

@@ -0,0 +1,6 @@
+from .blob import AzureBlobService
+from .email import EmailService
+from .table import AzureTableService
+
+__all__ = ["AzureBlobService", "EmailService", "AzureTableService"]
+

srx_lib_azure/blob.py

@@ -0,0 +1,113 @@
+import os
+from datetime import datetime, timedelta, timezone
+from typing import Optional, BinaryIO, Tuple
+
+from azure.storage.blob import BlobServiceClient, BlobSasPermissions, generate_blob_sas
+from fastapi import UploadFile
+
+from loguru import logger
+
+
+class AzureBlobService:
+    """Minimal Azure Blob helper with SAS URL generation."""
+
+    def __init__(self) -> None:
+        self.container_name = os.getenv("AZURE_BLOB_CONTAINER", "uploads")
+        self.connection_string = os.getenv("AZURE_STORAGE_CONNECTION_STRING")
+        self.account_key = os.getenv("AZURE_STORAGE_ACCOUNT_KEY")
+        self.sas_token = os.getenv("AZURE_SAS_TOKEN")
+        self.base_blob_url = os.getenv("AZURE_BLOB_URL")
+
+        if not self.connection_string:
+            logger.warning(
+                "Azure Storage connection string not configured; blob operations will fail."
+            )
+
+    def _get_blob_service(self) -> BlobServiceClient:
+        if not self.connection_string:
+            raise RuntimeError("AZURE_STORAGE_CONNECTION_STRING not configured")
+        clean = self.connection_string.strip().strip('"').strip("'")
+        return BlobServiceClient.from_connection_string(clean)
+
+    def _parse_account_from_connection_string(self) -> Tuple[Optional[str], Optional[str]]:
+        if not self.connection_string:
+            return None, None
+        try:
+            clean = self.connection_string.strip().strip('"').strip("'")
+            parts = dict(
+                seg.split("=", 1) for seg in clean.split(";") if "=" in seg
+            )
+            account_name = parts.get("AccountName")
+            account_key = parts.get("AccountKey") or self.account_key
+            return account_name, account_key
+        except Exception:
+            return None, None
+
+    def _ensure_container(self, client: BlobServiceClient) -> None:
+        try:
+            client.create_container(self.container_name)
+        except Exception:
+            pass
+
+    def _generate_sas_url(self, blob_name: str, expiry_days: int = 730) -> str:
+        account_name, account_key = self._parse_account_from_connection_string()
+        if not account_name:
+            try:
+                client = self._get_blob_service()
+                account_name = getattr(client, "account_name", None)
+            except Exception:
+                account_name = None
+
+        account_key = account_key or self.account_key
+        if not account_name or not account_key:
+            raise RuntimeError("Azure Storage account name/key not configured; cannot generate SAS")
+
+        start_time = datetime.now(timezone.utc) - timedelta(minutes=5)
+        expiry_time = start_time + timedelta(days=expiry_days)
+        sas = generate_blob_sas(
+            account_name=account_name,
+            container_name=self.container_name,
+            blob_name=blob_name,
+            account_key=account_key,
+            permission=BlobSasPermissions(read=True),
+            start=start_time,
+            expiry=expiry_time,
+            protocol="https",
+        )
+
+        if self.base_blob_url:
+            base_url = self.base_blob_url.strip().strip('"').strip("'").rstrip("/")
+            return f"{base_url}/{blob_name}?{sas}"
+        return f"https://{account_name}.blob.core.windows.net/{self.container_name}/{blob_name}?{sas}"
+
+    async def upload_file(self, file: UploadFile, blob_path: str) -> Optional[str]:
+        if not self.connection_string:
+            logger.error("Azure Storage connection string not configured")
+            return None
+        try:
+            client = self._get_blob_service()
+            self._ensure_container(client)
+            container = client.get_container_client(self.container_name)
+            content = await file.read()
+            blob_client = container.get_blob_client(blob_path)
+            blob_client.upload_blob(content, overwrite=True, content_type=file.content_type or "application/octet-stream")
+            return self._generate_sas_url(blob_path)
+        except Exception as e:
+            logger.error(f"Failed to upload file {file.filename}: {e}")
+            return None
+
+    async def upload_stream(self, stream: BinaryIO, blob_path: str, content_type: str = "application/octet-stream") -> Optional[str]:
+        if not self.connection_string:
+            logger.error("Azure Storage connection string not configured")
+            return None
+        try:
+            client = self._get_blob_service()
+            self._ensure_container(client)
+            container = client.get_container_client(self.container_name)
+            blob_client = container.get_blob_client(blob_path)
+            blob_client.upload_blob(stream, overwrite=True, content_type=content_type)
+            return self._generate_sas_url(blob_path)
+        except Exception as e:
+            logger.error(f"Failed to upload stream to {blob_path}: {e}")
+            return None
+

srx_lib_azure/email.py

@@ -0,0 +1,41 @@
+import os
+from azure.communication.email.aio import EmailClient
+
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class EmailService:
+    """Thin wrapper over Azure Communication Services EmailClient."""
+
+    def __init__(self):
+        self.connection_string = os.getenv("ACS_CONNECTION_STRING")
+        self.sender_address = os.getenv("EMAIL_SENDER")
+        if not self.connection_string or not self.sender_address:
+            raise ValueError("Missing ACS_CONNECTION_STRING or EMAIL_SENDER in environment variables")
+        self.email_client = EmailClient.from_connection_string(self.connection_string)
+
+    async def send_notification(self, recipient: str, subject: str, body: str, html: bool = False):
+        message = {
+            "content": {"subject": subject},
+            "recipients": {"to": [{"address": recipient}]},
+            "senderAddress": self.sender_address,
+        }
+        if html:
+            message["content"]["html"] = body
+        else:
+            message["content"]["plainText"] = body
+        try:
+            poller = await self.email_client.begin_send(message)
+            result = await poller.result()
+            message_id = result.get("id")
+            if message_id:
+                logger.info("Email sent to %s with Message ID: %s", recipient, message_id)
+                return {"status": "success", "message": "Email sent successfully", "message_id": message_id}
+            logger.error("Failed to send email. Result: %s", result)
+            return {"status": "error", "message": f"Failed to send email: {result}"}
+        except Exception as e:
+            logger.error("Email send exception: %s", e)
+            return {"status": "error", "message": str(e)}
+

srx_lib_azure/table.py

@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from typing import Any, Dict, Iterable, Optional
+
+from loguru import logger
+
+try:
+    from azure.data.tables import TableServiceClient
+except Exception:  # pragma: no cover
+    TableServiceClient = None  # type: ignore
+
+
+def _now_iso() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+@dataclass
+class AzureTableService:
+    connection_string: Optional[str] = os.getenv("AZURE_STORAGE_CONNECTION_STRING")
+
+    def _get_client(self) -> "TableServiceClient":
+        if not self.connection_string:
+            raise RuntimeError("AZURE_STORAGE_CONNECTION_STRING not configured")
+        if TableServiceClient is None:
+            raise RuntimeError("azure-data-tables not installed; install to use table operations")
+        clean = self.connection_string.strip().strip('"').strip("'")
+        return TableServiceClient.from_connection_string(conn_str=clean)
+
+    def ensure_table(self, table_name: str) -> None:
+        client = self._get_client()
+        try:
+            client.create_table_if_not_exists(table_name=table_name)
+        except Exception as e:
+            logger.warning("ensure_table(%s) warning: %s", table_name, e)
+
+    def put_entity(self, table_name: str, entity: Dict[str, Any]) -> Dict[str, Any]:
+        client = self._get_client()
+        table = client.get_table_client(table_name)
+        res = table.create_entity(entity=entity)
+        logger.info(
+            "Inserted entity into %s: PK=%s RK=%s",
+            table_name,
+            entity.get("PartitionKey"),
+            entity.get("RowKey"),
+        )
+        return {"etag": getattr(res, "etag", None), "ts": _now_iso()}
+
+    def upsert_entity(self, table_name: str, entity: Dict[str, Any]) -> Dict[str, Any]:
+        client = self._get_client()
+        table = client.get_table_client(table_name)
+        res = table.upsert_entity(entity=entity, mode="merge")
+        logger.info(
+            "Upserted entity into %s: PK=%s RK=%s",
+            table_name,
+            entity.get("PartitionKey"),
+            entity.get("RowKey"),
+        )
+        return {"etag": getattr(res, "etag", None), "ts": _now_iso()}
+
+    def delete_entity(self, table_name: str, partition_key: str, row_key: str) -> bool:
+        client = self._get_client()
+        table = client.get_table_client(table_name)
+        try:
+            table.delete_entity(partition_key=partition_key, row_key=row_key)
+            logger.info("Deleted entity in %s (%s/%s)", table_name, partition_key, row_key)
+            return True
+        except Exception as exc:
+            logger.error("Failed to delete entity in %s: %s", table_name, exc)
+            return False
+
+    def query(self, table_name: str, filter_query: str) -> Iterable[Dict[str, Any]]:
+        client = self._get_client()
+        table = client.get_table_client(table_name)
+        for entity in table.query_entities(filter=filter_query):
+            yield dict(entity)
+

srx_lib_azure-0.1.2.dist-info/METADATA

@@ -0,0 +1,70 @@
+Metadata-Version: 2.4
+Name: srx-lib-azure
+Version: 0.1.2
+Summary: Azure helpers for SRX services: Blob, Email, Table
+Author-email: SRX <dev@srx.id>
+Requires-Python: >=3.12
+Requires-Dist: azure-communication-email>=1.0.0
+Requires-Dist: azure-data-tables>=12.7.0
+Requires-Dist: azure-storage-blob>=12.22.0
+Requires-Dist: loguru>=0.7.2
+Description-Content-Type: text/markdown
+
+# srx-lib-azure
+
+Lightweight wrappers over Azure SDKs used across SRX services.
+
+What it includes:
+- Blob: upload/download helpers, SAS URL generation
+- Email (Azure Communication Services): simple async sender
+- Table: simple CRUD helpers
+
+## Install
+
+PyPI (public):
+
+- `pip install srx-lib-azure`
+
+uv (pyproject):
+```
+[project]
+dependencies = ["srx-lib-azure>=0.1.0"]
+```
+
+## Usage
+
+Blob:
+```
+from srx_lib_azure.blob import AzureBlobService
+blob = AzureBlobService()
+url = await blob.upload_file(upload_file, "documents/report.pdf")
+```
+
+Email:
+```
+from srx_lib_azure.email import EmailService
+svc = EmailService()
+await svc.send_notification("user@example.com", "Subject", "Hello", html=False)
+```
+
+Table:
+```
+from srx_lib_azure.table import AzureTableService
+store = AzureTableService()
+store.ensure_table("events")
+store.upsert_entity("events", {"PartitionKey":"p","RowKey":"r","EventType":"x"})
+```
+
+## Environment Variables
+
+- Blob & Table: `AZURE_STORAGE_CONNECTION_STRING` (required)
+- Email (ACS): `ACS_CONNECTION_STRING`, `EMAIL_SENDER`
+- Optional: `AZURE_STORAGE_ACCOUNT_KEY`, `AZURE_BLOB_URL`, `AZURE_SAS_TOKEN`
+
+## Release
+
+Tag `vX.Y.Z` to publish to GitHub Packages via Actions.
+
+## License
+
+Proprietary © SRX

srx_lib_azure-0.1.2.dist-info/RECORD

@@ -0,0 +1,7 @@
+srx_lib_azure/__init__.py,sha256=K0UCmkKw7HWJMshp6Xv3SxD4y26r7bdcPtb_2aRc2rs,174
+srx_lib_azure/blob.py,sha256=Y720DmrfYkyZIXLSGDwp_fPmU0ZKa-cAxM5-KdeWC5Q,4886
+srx_lib_azure/email.py,sha256=H8KCnYFuQ2dKzpWx3BsKv9tVCV-pEmm7vXUJkOnpVh4,1719
+srx_lib_azure/table.py,sha256=_5DCsk1SLqCc27F7469hxnRASS3XeffqK_MsJE1cD7Y,3022
+srx_lib_azure-0.1.2.dist-info/METADATA,sha256=9ZxUBkAXwWgHejaGse890yA5i9dWpvTu1qthrfn7IaA,1600
+srx_lib_azure-0.1.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+srx_lib_azure-0.1.2.dist-info/RECORD,,

srx_lib_azure-0.1.2.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any