drac-notifier 0.1.0__py3-none-any.whl

drac_notifier/clients/icat_plus.py

@@ -0,0 +1,99 @@
+import logging
+from typing import List
+from typing import Optional
+
+from icat_plus_client import ApiClient
+from icat_plus_client import CatalogueApi
+from icat_plus_client import Configuration
+from icat_plus_client import SessionApi
+from icat_plus_client.models import Credentials
+from icat_plus_client.models import Investigation
+from icat_plus_client.models import Investigationusers
+
+from drac_notifier.config import ICAT_PLUS_PASSWORD
+from drac_notifier.config import ICAT_PLUS_PLUGIN
+from drac_notifier.config import ICAT_PLUS_SERVER
+from drac_notifier.config import ICAT_PLUS_USERNAME
+
+logger = logging.getLogger(__name__)
+
+
+class IcatClient:
+    """Client to interact with ICAT+"""
+
+    def __init__(self):
+        self.configuration = Configuration(host=ICAT_PLUS_SERVER)
+        self.username = ICAT_PLUS_USERNAME
+        self.password = ICAT_PLUS_PASSWORD
+        self.plugin = ICAT_PLUS_PLUGIN
+        self.session_id: Optional[str] = None
+
+    def login(self) -> Optional[str]:
+        """Authenticate and store session_id"""
+        try:
+            with ApiClient(self.configuration) as api_client:
+                api_instance = SessionApi(api_client)
+                cred = Credentials(
+                    username=self.username,
+                    password=self.password,
+                    plugin=self.plugin,
+                )
+                response = api_instance.session_post(cred)
+                self.session_id = response.session_id
+                logger.info("Logged in to ICAT+, session_id obtained")
+                return self.session_id
+        except Exception as exc:
+            logger.exception("Unexpected error during login: %s", exc)
+        return None
+
+    def get_investigations(
+        self,
+        release_dates: Optional[str] = None,
+    ) -> List[Investigation]:
+        """Fetch investigations from ICAT+"""
+        if not self.session_id:
+            logger.error("No session_id. Please login first.")
+            return []
+
+        with ApiClient(self.configuration) as api_client:
+            api_instance = CatalogueApi(api_client)
+            try:
+                investigations = api_instance.catalogue_session_id_investigation_get(
+                    session_id=self.session_id,
+                    release_dates=release_dates,
+                )
+                logger.info(
+                    "Fetched %d investigations",
+                    len(investigations) if investigations else 0,
+                )
+                return investigations or []
+            except Exception as exc:
+                logger.exception("Unexpected error fetching investigations: %s", exc)
+        return []
+
+    def get_investigation_users(
+        self,
+        investigation_id: str,
+    ) -> List[Investigationusers]:
+        """Fetch investigation users from ICAT+"""
+        if not self.session_id:
+            logger.error("No session_id. Please login first.")
+            return []
+
+        with ApiClient(self.configuration) as api_client:
+            api_instance = CatalogueApi(api_client)
+            try:
+                users = api_instance.catalogue_session_id_investigation_id_investigation_id_investigationusers_get(
+                    session_id=self.session_id,
+                    investigation_id=investigation_id,
+                )
+                logger.info(
+                    "Fetched %d investigation users",
+                    len(users) if users else 0,
+                )
+                return users or []
+            except Exception as exc:
+                logger.exception(
+                    "Unexpected error fetching investigation users: %s", exc
+                )
+        return []

drac_notifier/clients/smis.py

@@ -0,0 +1,73 @@
+import logging
+from typing import Optional
+
+import requests
+from zeep import Client
+from zeep.exceptions import Fault
+from zeep.transports import Transport
+from zeep.wsse.username import UsernameToken
+
+from drac_notifier.config import SMIS_PASSWORD
+from drac_notifier.config import SMIS_SERVER
+from drac_notifier.config import SMIS_USERNAME
+
+logger = logging.getLogger(__name__)
+
+
+class SmisClient:
+    """Client to interact with UserPortal"""
+
+    def __init__(self):
+        self.server = SMIS_SERVER
+        self.username = SMIS_USERNAME
+        self.password = SMIS_PASSWORD
+
+        session = requests.Session()
+        session.auth = (self.username, self.password)
+        transport = Transport(session=session)
+
+        user_wsdl_url = f"{self.server}/SMISServer-ejb3/UserLookupWebService/UserLookupWebServiceBean?wsdl"
+        self.user_client = Client(
+            user_wsdl_url,
+            transport=transport,
+            wsse=UsernameToken(self.username, self.password),
+        )
+
+        smis_wsdl_url = (
+            f"{self.server}/SMISServer-ejb3/SMISWebService/SMISWebServiceBean?wsdl"
+        )
+        self.smis_client = Client(
+            smis_wsdl_url,
+            transport=transport,
+            wsse=UsernameToken(self.username, self.password),
+        )
+
+    def get_user_email(self, username: str) -> Optional[str]:
+        smis_username = username.split("/")[0]
+        try:
+            user_id = self.user_client.service.getUserIdForUserName(smis_username)
+
+            if not user_id:
+                logger.warning(f"No SMIS user ID found for {smis_username}")
+                return None
+
+            user_light_vo = self.smis_client.service.findUserByScientistPk(user_id)
+
+            if not user_light_vo:
+                logger.warning(f"No SMIS user found for ID {user_id}")
+                return None
+
+            email = getattr(user_light_vo, "scientistEmail", None)
+            return email
+
+        except Fault as fault:
+            logger.warning(
+                f"SMIS lookup failed for username={smis_username}: {fault.message}"
+            )
+            return None
+
+        except Exception:
+            logger.exception(
+                f"Unexpected error while retrieving email for {smis_username}"
+            )
+            return None

drac_notifier/config.py

@@ -0,0 +1,23 @@
+import os
+
+from dotenv import load_dotenv
+
+load_dotenv(override=True)  # loads .env
+
+
+def get_env(name: str) -> str:
+    value = os.environ.get(name)
+    if not value:
+        raise RuntimeError(f"Environment variable {name} is required but not set.")
+    return value
+
+
+ICAT_PLUS_SERVER = get_env("ICAT_PLUS_SERVER")
+ICAT_PLUS_USERNAME = get_env("ICAT_PLUS_USERNAME")
+ICAT_PLUS_PASSWORD = get_env("ICAT_PLUS_PASSWORD")
+ICAT_PLUS_PLUGIN = get_env("ICAT_PLUS_PLUGIN")
+SMIS_SERVER = get_env("SMIS_SERVER")
+SMIS_USERNAME = get_env("SMIS_USERNAME")
+SMIS_PASSWORD = get_env("SMIS_PASSWORD")
+BCC_EMAIL = get_env("BCC_EMAIL")
+SENDER_EMAIL = get_env("SENDER_EMAIL")

drac_notifier/email_notifier/service.py

@@ -0,0 +1,67 @@
+import logging
+import smtplib
+from email.mime.multipart import MIMEMultipart
+from email.mime.text import MIMEText
+from typing import List
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+
+class EmailService:
+    def __init__(
+        self,
+        smtp_host: str,
+        sender: str,
+        reply_to: str,
+        bcc: Optional[str] = None,
+        mode: str = "normal",
+    ):
+        if mode not in {"normal", "dry-run", "test"}:
+            raise ValueError(f"Invalid mode: {mode}")
+        self.mode = mode
+        self.smtp_host = smtp_host
+        self.sender = sender
+        self.reply_to = reply_to
+        self.bcc = bcc
+
+    def send_html_email(
+        self, subject: str, html_body: str, to_emails: List[str]
+    ) -> None:
+        if not to_emails:
+            logger.warning("[EMAIL][SKIP] No recipients")
+            return
+        recipients = list(dict.fromkeys(to_emails))
+        if self.mode == "dry-run":
+            logger.info(
+                f"[EMAIL][DRY_RUN] subject='{subject}' intended_recipients={recipients}"
+            )
+            return
+        msg = MIMEMultipart()
+        msg["Subject"] = subject
+        msg["From"] = self.sender
+        msg["Reply-To"] = self.reply_to
+        if self.mode == "test":
+            if not self.bcc:
+                logger.warning("[EMAIL][TEST_MODE] No BCC specified, skipping")
+                return
+            send_list = [self.bcc]
+            msg["To"] = self.bcc
+            logger.info(
+                f"[EMAIL][TEST] subject='{subject}' redirected_to_bcc={self.bcc} original_recipients={recipients}"
+            )
+        else:
+            send_list = recipients.copy()
+            msg["To"] = ", ".join(recipients)
+            if self.bcc:
+                send_list.append(self.bcc)
+        msg.attach(MIMEText(html_body, "html"))
+        try:
+            with smtplib.SMTP(self.smtp_host) as server:
+                server.sendmail(self.sender, send_list, msg.as_string())
+
+            logger.info(
+                f"[EMAIL][SENT] subject='{subject}' to={recipients} bcc={self.bcc}"
+            )
+        except Exception:
+            logger.exception("[EMAIL][ERROR] Failed to send email")

drac_notifier/email_notifier/templates/end_embargo.py

@@ -0,0 +1,41 @@
+EMBARGO_TEMPLATE = """
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <title>End of embargo email</title>
+    <style>
+      .text-footer {{
+        font-size: 0.8em;
+        color: #666;
+      }}
+    </style>
+  </head>
+  <body>
+    <p>You are receiving this email because you have access to the ESRF data concerned.</p>
+
+    <p>
+      According to the <a href="{data_policy}">ESRF data policy</a>, the data concerned by the following experiment session will become public on the {release_date} given below:
+    </p>
+
+    <ul>
+      <li><b>Proposal ID:</b> {proposal}</li>
+      <li><b>Beamline:</b> {beamline}</li>
+      <li><b>Start date:</b> {start_date}</li>
+      <li><b>End date:</b> {end_date}</li>
+      <li><b>End of embargo date:</b> {release_date}</li>
+    </ul>
+
+    <p>
+      On this date, the data and metadata, including the electronic logbook and experiment session report, will all be made public via the session DOI landing page: 
+      <a href="{doi_link}">{doi_link}</a>
+    </p>
+    <p>
+      You, as part of the proposal team (PI, CIs, and Users for this session), are responsible for the content of the data and metadata that will be made public. Please ensure that any sensitive and/or personal data  are removed before this date, tidy the logbook and update the experiment report if required. 
+    </p>
+    <p>
+      If an extension of the 3-year embargo period is required, the Principal Investigator must make the request by email to the Office of the Directors of Research (<a href="{mailto_link}">doroffice@esrf.fr</a>), clearly justifying the length of extension requested and why it is needed.
+    </p>
+    <p class="text-footer"><i>This email was automatically generated by the Data Portal.</i></p>
+  </body>
+</html>
+"""

drac_notifier/email_notifier/templates/templates.py

@@ -0,0 +1,38 @@
+from datetime import datetime
+from typing import Tuple
+from urllib.parse import quote
+
+from icat_plus_client.models import Investigation
+
+from .end_embargo import EMBARGO_TEMPLATE
+
+
+def build_embargo_email(inv: Investigation) -> Tuple[str, str]:
+    start_date = _format_date(inv.start_date)
+    end_date = _format_date(inv.end_date)
+    proposal = inv.name
+    beamline = inv.instrument.name
+    release_date = _format_date(inv.release_date)
+    proposal_subject = f"{proposal} on {beamline} From {start_date} to {end_date}"
+    mailto_subject = f"Embargo extension: {proposal_subject}"
+    mailto_subject_encoded = quote(mailto_subject)
+    mailto_link = f"mailto:doroffice@esrf.fr?subject={mailto_subject_encoded}"
+    subject = f"ESRF data end of embargo: {proposal_subject}"
+
+    html = EMBARGO_TEMPLATE.format(
+        proposal=proposal,
+        beamline=beamline,
+        start_date=start_date,
+        end_date=end_date,
+        release_date=release_date,
+        doi_link=f"https://doi.org/{inv.doi}",
+        data_policy="https://www.esrf.fr/files/live/sites/www/files/Infrastructure/Computing/ESRF-data-policy_20240101.pdf",
+        mailto_link=mailto_link,
+    )
+
+    return subject, html
+
+
+def _format_date(date_str: str) -> str:
+    dt = datetime.fromisoformat(date_str)
+    return dt.strftime("%Y-%m-%d")

drac_notifier/main.py

@@ -0,0 +1,46 @@
+import argparse
+import logging
+from datetime import datetime
+
+from drac_notifier.notifications.end_embargo import send_embargo_notifications
+
+logging.basicConfig(level=logging.INFO, format="%(levelname)s:%(name)s:%(message)s")
+logger = logging.getLogger(__name__)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="DRAC Notifier tasks",
+        epilog="Example: python -m drac_notifier.main embargo 2026-02-01 --mode dry-run",
+    )
+    parser.add_argument("task", choices=["embargo"], help="Task to run")
+    parser.add_argument(
+        "date",
+        nargs="?",
+        default=None,
+        help="Reference date in YYYY-MM-DD format (optional)",
+    )
+    parser.add_argument(
+        "--mode",
+        choices=["normal", "dry-run", "test"],
+        default="normal",
+        help="Email sending mode: normal (send), dry-run (no send), test (send only to bcc)",
+    )
+
+    args = parser.parse_args()
+
+    if args.date:
+        try:
+            datetime.strptime(args.date, "%Y-%m-%d")
+        except ValueError:
+            logger.error("Invalid date format: %s. Expected YYYY-MM-DD", args.date)
+            return
+
+    if args.task == "embargo":
+        send_embargo_notifications(reference_date=args.date, mode=args.mode)
+    else:
+        logger.error("Unknown task: %s", args.task)
+
+
+if __name__ == "__main__":
+    main()

drac_notifier/notifications/end_embargo.py

@@ -0,0 +1,121 @@
+import logging
+from datetime import date
+from datetime import datetime
+from typing import List
+from typing import Optional
+from typing import Set
+
+from dateutil.relativedelta import relativedelta
+from icat_plus_client.models import Investigation
+from icat_plus_client.models import Investigationusers
+
+from drac_notifier.clients.icat_plus import IcatClient
+from drac_notifier.clients.smis import SmisClient
+from drac_notifier.config import BCC_EMAIL
+from drac_notifier.config import SENDER_EMAIL
+from drac_notifier.email_notifier.service import EmailService
+from drac_notifier.email_notifier.templates.templates import build_embargo_email
+
+logger = logging.getLogger(__name__)
+
+
+def send_embargo_notifications(
+    reference_date: Optional[str], mode: str = "normal"
+) -> None:
+    logger.info("START EMBARGO NOTIFICATIONS")
+    client = IcatClient()
+    client.login()
+    smis_client = SmisClient()
+    email_service = EmailService(
+        smtp_host="localhost",
+        sender=SENDER_EMAIL,
+        reply_to=SENDER_EMAIL,
+        bcc=BCC_EMAIL,
+        mode=mode,
+    )
+
+    target_dates = _calculate_target_dates(reference_date)
+    release_dates = ",".join(target_dates)
+    logger.info(f"Release dates: {release_dates}")
+
+    investigations = client.get_investigations(release_dates=release_dates)
+    for inv in investigations:
+        logger.info(
+            f"[INVESTIGATION] id={inv.id} name={inv.name} release_date={inv.release_date}"
+        )
+        users = client.get_investigation_users(inv.id)
+        emails = set()
+        missing_users = []
+        for user in users:
+            email = smis_client.get_user_email(user.name)
+
+            if email:
+                emails.add(email)
+                logger.info(
+                    f"[USER][OK] inv_id={inv.id} user={user.name} role={user.role} email={email}"
+                )
+            else:
+                missing_users.append(user.name)
+                logger.warning(
+                    f"[USER][NO_EMAIL] inv_id={inv.id} user={user.name} role={user.role}"
+                )
+        # summary
+        skip = _log_summary_investigation(inv, users, emails, missing_users)
+        if skip:
+            continue
+
+        try:
+            subject, html = build_embargo_email(inv)
+        except Exception:
+            logger.exception(
+                f"[EMAIL][ERROR] Failed to build email for inv_id={inv.id}"
+            )
+            continue
+        logger.info(f"[EMAIL][PREPARE] inv_id={inv.id} recipients={len(emails)}")
+        email_service.send_html_email(
+            subject=subject,
+            html_body=html,
+            to_emails=list(emails),
+        )
+
+        logger.info("=" * 60)
+
+    logger.info("END Embargo notifications sent successfully")
+
+
+def _log_summary_investigation(
+    inv: Investigation,
+    users: List[Investigationusers],
+    emails: Set[str],
+    missing_users: List[str],
+) -> bool:
+    logger.info(
+        f"[SUMMARY] inv_id={inv.id} total_users={len(users)} "
+        f"emails_found={len(emails)} missing={len(missing_users)}"
+    )
+    if missing_users:
+        logger.warning(
+            f"[SUMMARY][MISSING_EMAILS] inv_id={inv.id} users={missing_users}"
+        )
+    if not emails:
+        logger.warning(f"[SKIP] No emails for investigation {inv.id} name={inv.name}")
+        return True
+    return False
+
+
+def _calculate_target_dates(reference_date: Optional[str] = None) -> List[str]:
+    """
+    Returns the target dates for embargo notifications:
+      - 1 month after reference_date
+      - 3 months after reference_date
+
+    If reference_date is None, use today.
+    """
+    if reference_date:
+        ref_date = datetime.strptime(reference_date, "%Y-%m-%d").date()
+    else:
+        ref_date = date.today()
+    one_month_date = ref_date + relativedelta(months=1)
+    three_month_date = ref_date + relativedelta(months=3)
+
+    return [one_month_date.isoformat(), three_month_date.isoformat()]

drac_notifier/tests/test_release_date.py

@@ -0,0 +1,22 @@
+from datetime import date
+
+from drac_notifier.notifications.end_embargo import _calculate_target_dates
+
+
+def test_calculate_target_dates_with_given_date():
+    result = _calculate_target_dates("2026-03-23")
+    assert result[0] == "2026-04-23"
+    assert result[1] == "2026-06-23"
+
+
+def test_calculate_target_dates_with_default_today(monkeypatch):
+    class FakeDate(date):
+        @classmethod
+        def today(cls):
+            return cls(2026, 3, 23)
+
+    monkeypatch.setattr("drac_notifier.notifications.end_embargo.date", FakeDate)
+
+    result = _calculate_target_dates()
+    assert result[0] == "2026-04-23"
+    assert result[1] == "2026-06-23"

drac_notifier-0.1.0.dist-info/METADATA

@@ -0,0 +1,61 @@
+Metadata-Version: 2.4
+Name: drac-notifier
+Version: 0.1.0
+Summary: Service for sending user notifications from ICAT based on data lifecycle events
+Author-email: ESRF <marjolaine.bodin@esrf.fr>
+License: # MIT License
+        
+        **Copyright (c) 2026 European Synchrotron Radiation Facility**
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy of
+        this software and associated documentation files (the "Software"), to deal in
+        the Software without restriction, including without limitation the rights to
+        use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+        the Software, and to permit persons to whom the Software is furnished to do so,
+        subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+        FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+        COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+        IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+        CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+        
+Project-URL: Homepage, https://gitlab.esrf.fr/icat/drac-notifier/
+Project-URL: Documentation, https://drac-notifier.readthedocs.io/
+Project-URL: Repository, https://gitlab.esrf.fr/icat/drac-notifier/
+Project-URL: Issues, https://gitlab.esrf.fr/icat/drac-notifier/issues
+Project-URL: Changelog, https://gitlab.esrf.fr/icat/drac-notifier/-/blob/main/CHANGELOG.md
+Keywords: icat
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Requires-Dist: icat-plus-client
+Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: zeep
+Provides-Extra: test
+Requires-Dist: pytest>=7; extra == "test"
+Provides-Extra: dev
+Requires-Dist: drac-notifier[test]; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Provides-Extra: doc
+Requires-Dist: drac-notifier[test]; extra == "doc"
+Requires-Dist: sphinx>=4.5; extra == "doc"
+Requires-Dist: sphinx-autodoc-typehints>=1.16; extra == "doc"
+Requires-Dist: pydata-sphinx-theme; extra == "doc"
+Requires-Dist: sphinx-copybutton; extra == "doc"
+Dynamic: license-file
+
+# drac-notifier
+
+Service for sending user notifications from ICAT based on data lifecycle events.
+
+## End of embargo email
+
+An email is sent to all users linked to an experiment session to notify them of the end of the embargo period, 3 months and 1 month before the end date.

drac_notifier-0.1.0.dist-info/RECORD

@@ -0,0 +1,20 @@
+drac_notifier/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+drac_notifier/config.py,sha256=ijXpFDodK3jganEp1sMPupidgBRfVGWqcaQFzwcvJtY,658
+drac_notifier/main.py,sha256=bENRWl2neZq0Kht6oRpSp_O9qIIm4phFBKzwXwWwYWE,1353
+drac_notifier/clients/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+drac_notifier/clients/icat_plus.py,sha256=qOnNPOZhcjI9qPTWGTdlXpcsZ6DVGsi_1heg_kynwXs,3667
+drac_notifier/clients/smis.py,sha256=KOmk-_8e5XMKE-fkyttymVmPEDTtSaVOktlK_cn06WQ,2290
+drac_notifier/email_notifier/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+drac_notifier/email_notifier/service.py,sha256=8Dpk19G6Ben9c_VWsrFvN00J4A2ozKSg7LVSVFsvtFw,2196
+drac_notifier/email_notifier/templates/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+drac_notifier/email_notifier/templates/end_embargo.py,sha256=q8tfruYfBKSOgxYkad6Msp4UxzRjq4QI9RoUurKjSTI,1754
+drac_notifier/email_notifier/templates/templates.py,sha256=jCW-aKd_vanLq1Itr3i_6AwdhtvrjwnrtVPCYZieXwY,1320
+drac_notifier/notifications/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+drac_notifier/notifications/end_embargo.py,sha256=7W3MEFfj5SAJEUeOalPFVKY-5v8m2ijxTREupVpPCTQ,3925
+drac_notifier/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+drac_notifier/tests/test_release_date.py,sha256=x4Xx4VVC3qo_BBlLjPlGIOJxxyOMqYLMtGtBareTxQo,652
+drac_notifier-0.1.0.dist-info/licenses/LICENSE.md,sha256=jhnnemwVcGW_Dc_FbaaD12x2Vz9mIqjX_MtyKrjw3gQ,1102
+drac_notifier-0.1.0.dist-info/METADATA,sha256=CkB62rh4Bt_Oqj67qVuCM3MoivUIP-hcgXDzqZeqOYs,2912
+drac_notifier-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+drac_notifier-0.1.0.dist-info/top_level.txt,sha256=Bdg8lupC6ATzXJikNnOMJga8kpIx1-3FXlUj6i31cPI,14
+drac_notifier-0.1.0.dist-info/RECORD,,

drac_notifier-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

drac_notifier-0.1.0.dist-info/licenses/LICENSE.md

@@ -0,0 +1,20 @@
+# MIT License
+
+**Copyright (c) 2026 European Synchrotron Radiation Facility**
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

drac_notifier-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+drac_notifier