email-code-finder 0.1.0__py3-none-any.whl

email_code_finder/__init__.py

@@ -0,0 +1,17 @@
+"""email-code-finder: read one-time 2FA/OTP codes from an IMAP mailbox.
+
+Public API::
+
+    from email_code_finder import EmailCodeFinder
+
+    finder = EmailCodeFinder(config_path="config.json", notify_callback=print)
+    code = finder.wait_for_code()
+"""
+
+from __future__ import annotations
+
+from .client import ImapEmailClient
+from .finder import EmailCodeFinder
+
+__all__ = ["EmailCodeFinder", "ImapEmailClient"]
+__version__ = "0.1.0"

email_code_finder/client.py

@@ -0,0 +1,167 @@
+"""IMAP client used to search and read one-time authentication codes.
+
+This module intentionally avoids any destructive mailbox operation. Messages
+are never deleted; once a code is extracted the message is only flagged as
+``\\Seen`` (read), so the user keeps a record of the email.
+"""
+
+from __future__ import annotations
+
+import email
+import imaplib
+import logging
+import re
+import ssl
+from email.message import Message
+from typing import List, Optional
+
+log = logging.getLogger(__name__)
+
+# Default IMAP host/port for the most common providers. Any provider not listed
+# here falls back to ``imap.<domain>`` derived from the user's email address.
+DEFAULT_IMAP_PORT = 993
+KNOWN_IMAP_SERVERS = {
+    "gmail": "imap.gmail.com",
+    "outlook": "outlook.office365.com",
+    "office365": "outlook.office365.com",
+    "yahoo": "imap.mail.yahoo.com",
+    "icloud": "imap.mail.me.com",
+    "kinghost": "imap.kinghost.net",
+}
+
+
+class ImapEmailClient:
+    """Thin wrapper around :mod:`imaplib` for reading authentication codes.
+
+    Args:
+        user_email: Full email address used to authenticate.
+        password: Account or app-specific password. Prefer app passwords; see
+            the security notes in the project README.
+        provider: Optional provider key (``gmail``, ``outlook``, ``yahoo``,
+            ``icloud``, ...). When omitted or unknown, the IMAP host is derived
+            from the email domain as ``imap.<domain>``.
+        imap_server: Explicit IMAP host. Overrides ``provider`` detection.
+        port: IMAP-over-SSL port. Defaults to 993.
+    """
+
+    def __init__(
+        self,
+        user_email: str,
+        password: str,
+        provider: Optional[str] = None,
+        imap_server: Optional[str] = None,
+        port: int = DEFAULT_IMAP_PORT,
+    ) -> None:
+        self.user_email = user_email
+        self.password = password
+        self.provider = provider.lower() if provider else None
+        self.port = port
+        self.imap_server = imap_server or self._resolve_imap_server()
+        self.mail: Optional[imaplib.IMAP4_SSL] = None
+
+    def _resolve_imap_server(self) -> str:
+        """Return the IMAP host for the configured provider/email domain."""
+        if self.provider and self.provider in KNOWN_IMAP_SERVERS:
+            return KNOWN_IMAP_SERVERS[self.provider]
+        try:
+            domain = self.user_email.split("@", 1)[1].lower()
+        except IndexError as exc:
+            raise ValueError(
+                f"Invalid email address, missing domain: {self.user_email!r}"
+            ) from exc
+        return f"imap.{domain}"
+
+    def connect(self) -> None:
+        """Open an authenticated IMAP-over-SSL session and select the inbox."""
+        context = ssl.create_default_context()
+        self.mail = imaplib.IMAP4_SSL(self.imap_server, self.port, ssl_context=context)
+        self.mail.login(self.user_email, self.password)
+        # readonly=False is required so processed messages can be flagged \Seen.
+        self.mail.select("INBOX", readonly=False)
+
+    def get_max_uid(self) -> int:
+        """Return the highest UID currently in the inbox (0 if empty).
+
+        Used as a baseline: only messages with a UID greater than this value are
+        considered "new", so codes received before the wait started are ignored.
+        """
+        self._require_connection()
+        status, data = self.mail.uid("SEARCH", None, "ALL")
+        if status != "OK":
+            raise RuntimeError(f"Failed to read inbox baseline: {status}")
+        uids = data[0].split()
+        return max((int(uid) for uid in uids), default=0)
+
+    def search_unread_by_subject(self, subject: str) -> List[bytes]:
+        """Return UIDs of unread messages whose subject matches ``subject``.
+
+        Both the exact subject and a ``Fwd:`` forwarded variant are matched.
+        """
+        self._require_connection()
+        subject_fwd = f"Fwd: {subject}"
+        criteria = '(OR (SUBJECT "{}") (SUBJECT "{}"))'.format(
+            subject, subject_fwd
+        ).encode("utf-8")
+        status, messages = self.mail.uid(
+            "SEARCH", "CHARSET", "UTF-8", "UNSEEN", criteria
+        )
+        if status != "OK":
+            raise RuntimeError(f"Failed to search emails: {status}")
+        return messages[0].split()
+
+    def fetch_body(self, message_uid: bytes) -> str:
+        """Fetch and decode the textual body (HTML preferred) of a message."""
+        self._require_connection()
+        status, data = self.mail.uid("FETCH", message_uid, "(RFC822)")
+        if status != "OK" or not data or data[0] is None:
+            raise RuntimeError(
+                f"Failed to fetch email UID {message_uid.decode(errors='ignore')}"
+            )
+        email_message = email.message_from_bytes(data[0][1])
+        return self._extract_text(email_message)
+
+    @staticmethod
+    def _extract_text(email_message: Message) -> str:
+        """Return the best textual representation of the email body."""
+        html_body = ""
+        plain_body = ""
+        for part in email_message.walk():
+            if part.get_content_maintype() == "multipart":
+                continue
+            content_type = part.get_content_type()
+            payload = part.get_payload(decode=True)
+            if not payload:
+                continue
+            charset = part.get_content_charset() or "utf-8"
+            text = payload.decode(charset, errors="ignore")
+            if content_type == "text/html":
+                html_body = text
+            elif content_type == "text/plain":
+                plain_body = text
+        # Prefer HTML (codes are usually inside markup); fall back to plain text.
+        return html_body or plain_body
+
+    @staticmethod
+    def extract_code(body: str, pattern: str) -> Optional[str]:
+        """Return the first capture group matched by ``pattern`` in ``body``."""
+        if not pattern:
+            raise ValueError("A non-empty regex pattern is required to extract the code.")
+        match = re.search(pattern, body, re.DOTALL)
+        return match.group(1) if match else None
+
+    def mark_as_read(self, message_uid: bytes) -> None:
+        """Flag a message as read (``\\Seen``). The message is NOT deleted."""
+        self._require_connection()
+        self.mail.uid("STORE", message_uid, "+FLAGS", "(\\Seen)")
+
+    def logout(self) -> None:
+        """Close the IMAP session if one is open."""
+        if self.mail is not None:
+            try:
+                self.mail.logout()
+            finally:
+                self.mail = None
+
+    def _require_connection(self) -> None:
+        if self.mail is None:
+            raise RuntimeError("Not connected. Call connect() first.")

email_code_finder/finder.py

@@ -0,0 +1,170 @@
+"""High-level API to wait for and extract a regex-matched value from email.
+
+The most common use case is a one-time authentication code (2FA/OTP), but the
+extraction is fully generic: whatever ``regex_pattern`` captures is returned,
+be it a code, a confirmation link, a tracking number, or any other text.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import time
+from datetime import datetime
+from typing import Callable, Optional
+
+from .client import ImapEmailClient
+
+log = logging.getLogger(__name__)
+
+# Configuration keys that must be present for the finder to operate.
+REQUIRED_CONFIG_KEYS = (
+    "user_email",
+    "password",
+    "subject_to_find",
+    "regex_pattern",
+)
+
+# Defaults applied when the corresponding key is absent from the config.
+DEFAULT_MAX_WAIT_SECONDS = 180
+DEFAULT_CHECK_INTERVAL_SECONDS = 6
+
+
+class EmailCodeFinder:
+    """Poll an IMAP inbox until an email matching your regex arrives.
+
+    Returns whatever ``regex_pattern`` captures (group 1) — typically a 2FA/OTP
+    code, but any regex-matchable value works.
+
+    The finder is non-destructive: it never deletes emails. To avoid returning a
+    value from an older email, it records the highest inbox UID when the wait
+    starts and only considers messages received afterwards. The matched message
+    is flagged as read (``\\Seen``) once its value is extracted.
+
+    Timing note: the UID baseline is taken when the wait starts, so trigger the
+    action that sends the email *after* (or while) calling ``wait_for_code()`` —
+    an email already in the inbox is treated as stale and ignored.
+
+    Configuration (dict or JSON file)::
+
+        {
+            "provider": "gmail",
+            "user_email": "user@gmail.com",
+            "password": "app-password",
+            "subject_to_find": "Your verification code",
+            "regex_pattern": "(?s)token-2fa-text\\"?>.*?<b>(.*?)</b>.*?</div>",
+            "max_wait_time_seconds": 180,
+            "check_interval_seconds": 6
+        }
+
+    Args:
+        config: Configuration dict. If ``None``, it is loaded from ``config_path``.
+        config_path: Path to a JSON config file. Used only when ``config`` is None.
+        notify_callback: Optional ``Callable(message: str)`` invoked for
+            user-facing events (waiting, code found, timeout, error). Must be
+            thread-safe. When ``None``, events are only logged.
+    """
+
+    def __init__(
+        self,
+        config: Optional[dict] = None,
+        config_path: str = "config.json",
+        notify_callback: Optional[Callable[[str], None]] = None,
+    ) -> None:
+        self.notify_callback = notify_callback
+        self.config = config if config is not None else self._load_config(config_path)
+        self._validate_config(self.config)
+
+        self.client = ImapEmailClient(
+            user_email=self.config["user_email"],
+            password=self.config["password"],
+            provider=self.config.get("provider"),
+            imap_server=self.config.get("imap_server"),
+        )
+
+    @staticmethod
+    def _load_config(path: str) -> dict:
+        """Load configuration from a JSON file."""
+        with open(path, "r", encoding="utf-8") as handle:
+            return json.load(handle)
+
+    @staticmethod
+    def _validate_config(config: dict) -> None:
+        """Raise ``ValueError`` if any required configuration key is missing."""
+        missing = [key for key in REQUIRED_CONFIG_KEYS if not config.get(key)]
+        if missing:
+            raise ValueError(
+                "Missing required configuration key(s): " + ", ".join(missing)
+            )
+
+    def _notify(self, message: str) -> None:
+        """Log a message and forward it to ``notify_callback`` when present."""
+        log.info(message)
+        if self.notify_callback is not None:
+            try:
+                self.notify_callback(message)
+            except Exception as exc:  # never let a UI callback break the flow
+                log.debug("notify_callback raised an exception: %s", exc)
+
+    def wait_for_code(self) -> Optional[str]:
+        """Wait for and return the authentication code received by email.
+
+        Returns:
+            The extracted code, or ``None`` if the timeout elapses first.
+        """
+        max_wait = self.config.get("max_wait_time_seconds", DEFAULT_MAX_WAIT_SECONDS)
+        interval = self.config.get(
+            "check_interval_seconds", DEFAULT_CHECK_INTERVAL_SECONDS
+        )
+        subject = self.config["subject_to_find"]
+        regex_pattern = self.config["regex_pattern"]
+
+        code: Optional[str] = None
+        start_time = datetime.now()
+
+        try:
+            self.client.connect()
+            # Baseline: ignore every code that already exists in the inbox.
+            baseline_uid = self.client.get_max_uid()
+            self._notify("Connected to the mail server. Waiting for the email...")
+
+            while (datetime.now() - start_time).total_seconds() < max_wait:
+                for msg_uid in self.client.search_unread_by_subject(subject):
+                    if int(msg_uid) <= baseline_uid:
+                        continue  # message predates this wait; skip it
+                    body = self.client.fetch_body(msg_uid)
+                    if not body:
+                        continue
+                    code = self.client.extract_code(body, regex_pattern)
+                    if code:
+                        self.client.mark_as_read(msg_uid)
+                        log.debug("Email UID %s processed.", msg_uid.decode())
+                        break
+                if code:
+                    break
+
+                elapsed = (datetime.now() - start_time).total_seconds()
+                progress = int((elapsed / max_wait) * 100)
+                self._notify(
+                    f"Waiting for the email... {progress}% ({elapsed:.0f}s)"
+                )
+                time.sleep(interval)
+
+            if code:
+                self._notify("Matching email received; value extracted.")
+                log.info("Value found.")
+            else:
+                self._notify(
+                    f"Timed out. No matching email found within {max_wait}s."
+                )
+                log.warning("Timed out (%ss). No value found.", max_wait)
+
+            return code
+
+        except Exception as exc:
+            self._notify(f"Error while waiting for the email: {exc}")
+            log.error("Error in wait_for_code: %s", exc, exc_info=True)
+            return None
+        finally:
+            self.client.logout()
+            log.info("Disconnected from the mail server.")

email_code_finder-0.1.0.dist-info/METADATA

@@ -0,0 +1,253 @@
+Metadata-Version: 2.4
+Name: email-code-finder
+Version: 0.1.0
+Summary: Extract any regex-matchable value (2FA/OTP codes, links, tokens, text) from an IMAP mailbox without deleting messages.
+Author-email: Erik Melias <erikmelias@phac.com.br>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/erikmelias/email-code-finder
+Project-URL: Repository, https://github.com/erikmelias/email-code-finder
+Project-URL: Issues, https://github.com/erikmelias/email-code-finder/issues
+Keywords: imap,email,regex,extract,scraping,2fa,otp,authentication,token,code
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Communications :: Email
+Classifier: Topic :: Security
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+
+# email-code-finder
+
+[![PyPI](https://img.shields.io/pypi/v/email-code-finder.svg)](https://pypi.org/project/email-code-finder/)
+[![Python](https://img.shields.io/pypi/pyversions/email-code-finder.svg)](https://pypi.org/project/email-code-finder/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
+Wait for an email to arrive in an IMAP mailbox and extract **any value you can
+describe with a regular expression** — a 2FA/OTP code, a confirmation link, a
+tracking number, an order ID, a token, or any piece of text. The library
+connects over IMAP, waits for the message whose subject you specify, runs your
+regex against the body, and returns the captured value — **without ever deleting
+your messages.**
+
+> **Not just 2FA.** One-time codes are the most common use case, but the engine
+> is generic: if the value is somewhere in the email body and a regex can
+> capture it, this library can fetch it. The `regex_pattern` you provide is the
+> only thing that decides *what* gets extracted.
+
+Examples of what you can extract:
+
+| Goal | Example `subject_to_find` | Example `regex_pattern` |
+| --- | --- | --- |
+| 2FA / OTP code | `Your verification code` | `\b(\d{6})\b` |
+| Confirmation link | `Confirm your email` | `href="(https://[^"]*/confirm[^"]*)"` |
+| Order / tracking ID | `Your order shipped` | `Tracking:\s*([A-Z0-9]{10,})` |
+| Arbitrary text | `Your invoice` | `Invoice No\.\s*(\S+)` |
+
+- **No third-party dependencies** — standard library only.
+- **Non-destructive** — emails are flagged as read, never deleted.
+- **Provider-aware** — Gmail, Outlook/Office 365, Yahoo, iCloud, or any custom
+  IMAP host.
+- **Pluggable notifications** — pass a callback to surface progress in your UI.
+
+---
+
+## Installation
+
+```bash
+pip install email-code-finder
+```
+
+Requires Python 3.8+.
+
+## Quick start
+
+```python
+from email_code_finder import EmailCodeFinder
+
+config = {
+    "provider": "gmail",
+    "user_email": "user@example.com",
+    "password": "your-app-specific-password",
+    "subject_to_find": "Your verification code",
+    "regex_pattern": r"(?s)token-2fa-text\"?>.*?<b>(.*?)</b>.*?</div>",
+    "max_wait_time_seconds": 180,
+    "check_interval_seconds": 6,
+}
+
+finder = EmailCodeFinder(config=config, notify_callback=print)
+code = finder.wait_for_code()
+
+if code:
+    print(f"Got the code: {code}")
+else:
+    print("Timed out without receiving a code.")
+```
+
+Or load the configuration from a JSON file:
+
+```python
+finder = EmailCodeFinder(config_path="config.json")
+code = finder.wait_for_code()
+```
+
+A runnable example lives in [`examples/basic_usage.py`](examples/basic_usage.py).
+
+## Configuration
+
+Configuration can be passed as a `dict` or stored in a JSON file (see
+[`examples/config.example.json`](examples/config.example.json)).
+
+| Key | Type | Required | Description |
+| --- | --- | --- | --- |
+| `user_email` | str | ✅ | Full email address used to authenticate. |
+| `password` | str | ✅ | Account or **app-specific** password (see Security). |
+| `subject_to_find` | str | ✅ | Subject line of the email carrying the code. A `Fwd:` variant is matched too. |
+| `regex_pattern` | str | ✅ | Regex whose **first capture group** is the code. |
+| `provider` | str | ➖ | `gmail`, `outlook`, `office365`, `yahoo`, `icloud`, `kinghost`. If omitted, the host is derived from your email domain (`imap.<domain>`). |
+| `imap_server` | str | ➖ | Explicit IMAP host; overrides `provider` detection. |
+| `max_wait_time_seconds` | int | ➖ | How long to wait before giving up. Default `180`. |
+| `check_interval_seconds` | int | ➖ | Delay between inbox polls. Default `6`. |
+
+### Writing the regex
+
+`regex_pattern` is matched with `re.DOTALL`; the value returned is **capture
+group 1**. For a code wrapped in `<b>123456</b>` you might use:
+
+```text
+<b>(\d{6})</b>
+```
+
+Test your pattern against a real email body before relying on it.
+
+## API
+
+### `EmailCodeFinder(config=None, config_path="config.json", notify_callback=None)`
+
+- `config` — configuration dict. When `None`, it is loaded from `config_path`.
+- `config_path` — path to a JSON config file (used only when `config` is `None`).
+- `notify_callback` — optional `Callable(message: str)` invoked for user-facing
+  events (waiting, code found, timeout, error). Must be thread-safe.
+
+Missing required keys raise `ValueError`.
+
+#### `wait_for_code() -> Optional[str]`
+
+Connects, polls the inbox until the code arrives or the timeout elapses, and
+returns the code (or `None`). On success the matching email is flagged as read.
+The connection is always closed when the call returns.
+
+### `ImapEmailClient`
+
+Lower-level IMAP wrapper exposed for advanced use (`connect`, `get_max_uid`,
+`search_unread_by_subject`, `fetch_body`, `extract_code`, `mark_as_read`,
+`logout`). It performs **no destructive operations**.
+
+## How matching works: timing & the UID baseline
+
+Understanding the sequence is important to use the library correctly.
+
+1. **Baseline.** The moment `wait_for_code()` connects, it reads the highest
+   existing message UID in the inbox and stores it as a *baseline*. IMAP UIDs
+   only ever increase, so this is a precise "everything up to here is old" mark.
+2. **Polling.** Every `check_interval_seconds` it searches the inbox for
+   **unread** messages whose subject matches `subject_to_find` (a `Fwd:`
+   variant is matched too).
+3. **New-only filter.** Any match with a UID **less than or equal to** the
+   baseline is skipped — it was already there before you started waiting, so it
+   is treated as stale. Only genuinely new messages are inspected.
+4. **Extraction.** The regex runs against the body of each new match. The first
+   message that yields a capture group wins: that value is returned and the
+   message is flagged as read.
+5. **Timeout.** If nothing matches within `max_wait_time_seconds`, the call
+   returns `None`.
+
+This UID baseline replaces the old, dangerous behaviour of *deleting* the inbox
+to "clean up" previous codes. Your existing emails are never touched.
+
+### ⏱️ Critical: start waiting *before* the email is sent
+
+Because the baseline is taken at the start, an email that arrives **before** you
+call `wait_for_code()` will be at or below the baseline and therefore ignored.
+Trigger the action that generates the email **after** (or concurrently with)
+starting the wait:
+
+```python
+import threading
+from email_code_finder import EmailCodeFinder
+
+finder = EmailCodeFinder(config=config)
+
+# Run wait_for_code() first (in a thread), THEN trigger the email.
+result = {}
+waiter = threading.Thread(target=lambda: result.update(code=finder.wait_for_code()))
+waiter.start()
+
+trigger_login()   # the action that makes the provider send the email
+waiter.join()
+print(result["code"])
+```
+
+### Tuning the delays
+
+| Setting | What it controls | Guidance |
+| --- | --- | --- |
+| `max_wait_time_seconds` | Total time to wait before giving up. | Set it above the worst-case email delivery time. Mail can take anywhere from a few seconds to a couple of minutes; `180` (3 min) is a safe default. |
+| `check_interval_seconds` | Pause between inbox polls. | Lower = the code is picked up sooner, but more IMAP requests. `6` is a good balance. Avoid going below `2–3` so you don't hit provider rate limits or get your IP throttled. |
+
+The call returns **as soon as** a matching code is found — the interval is only
+the upper bound on how long after arrival you notice it, not a fixed wait.
+
+## Security
+
+> ⚠️ **This library handles mailbox credentials. Read this section.**
+
+- **Use app-specific passwords**, not your main account password. Gmail,
+  Outlook, Yahoo and iCloud all support them and most require them when 2FA is
+  enabled on the account.
+- **Never commit `config.json`.** It is listed in `.gitignore`. Prefer loading
+  secrets from environment variables or a secret manager in production, e.g.:
+
+  ```python
+  import os
+  config["password"] = os.environ["EMAIL_PASSWORD"]
+  ```
+
+- **Connections use TLS** (`IMAP4_SSL` on port 993) with certificate
+  verification via `ssl.create_default_context()`. Do not disable verification.
+- **Least privilege.** If your provider supports it, use a dedicated mailbox or
+  an account scoped only to receiving these codes.
+- **Logging.** Extracted codes are written to logs at `DEBUG`/`INFO` level for
+  troubleshooting. Keep your log level and log storage appropriately restricted,
+  and avoid `DEBUG` in production if logs are shared.
+- **Regex from untrusted input.** If `regex_pattern` ever comes from an
+  untrusted source, beware of catastrophic backtracking (ReDoS). Prefer simple,
+  anchored patterns.
+
+## Limitations
+
+- IMAP only; POP3 and provider-specific APIs are not supported.
+- Reads from `INBOX` only.
+- The code must be extractable from the email body via a single regex group.
+
+## Development
+
+```bash
+git clone https://github.com/erikmelias/email-code-finder.git
+cd email-code-finder
+pip install -e ".[dev]"
+pytest
+```
+
+Tests use a mocked IMAP client and make no network connections.
+
+## License
+
+[MIT](LICENSE) © Erik Melias

email_code_finder-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+email_code_finder/__init__.py,sha256=OGgg2_dgVwIoMpUeJ0b0Ft2LA1KtqMhJymvUCinmpsk,436
+email_code_finder/client.py,sha256=1YDUHuyeJS19pC48fW_jp_JxERMhQmD7YyF0UEHMp4Y,6657
+email_code_finder/finder.py,sha256=QRxzMYw9u3vGIgNcqrNpW0l7gzrUcUNdsLsdyM9Ox6Y,6582
+email_code_finder/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+email_code_finder-0.1.0.dist-info/METADATA,sha256=cEZo1KeSeDyaHUhV-60FNd-ycr-yX1y2SV8LjeAa6jM,10500
+email_code_finder-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+email_code_finder-0.1.0.dist-info/top_level.txt,sha256=cb9vapanMPCv8AEe75_iLRuhJ0qg_wyLvLzoRLwftwk,18
+email_code_finder-0.1.0.dist-info/RECORD,,

email_code_finder-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
+

email_code_finder-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+email_code_finder