wavesimpro 0.9.0__py3-none-any.whl

wavesimpro/py.typed

@@ -0,0 +1,4 @@
+# Marker file for PEP 561
+# This indicates that this package supports type hints
+
+

wavesimpro/setup.py

@@ -0,0 +1,162 @@
+"""
+Setup wizard and credential management for wavesimPro_api.
+
+Global config lives at ~/.wavesimPro_api/.env and is written by run_setup().
+Credential resolution order:
+    1. configure() call
+    2. Local .env in the current working directory
+    3. ~/.wavesimPro_api/.env  (global, written by this wizard)
+    4. RAYFOS_API_KEY / RAYFOS_API_URL environment variables
+"""
+
+import getpass
+import os
+from pathlib import Path
+
+DEFAULT_API_URL = "https://server.rayfos.com"
+GLOBAL_CONFIG_DIR = Path.home() / ".wavesimPro_api"
+GLOBAL_CONFIG_FILE = GLOBAL_CONFIG_DIR / ".env"
+
+
+def load_global_config() -> dict:
+    """Load key/url from the global config file if it exists."""
+    result = {}
+    if GLOBAL_CONFIG_FILE.exists():
+        for line in GLOBAL_CONFIG_FILE.read_text(encoding="utf-8").splitlines():
+            line = line.strip()
+            if line and not line.startswith("#") and "=" in line:
+                k, _, v = line.partition("=")
+                result[k.strip()] = v.strip()
+    return result
+
+
+def save_global_config(api_key: str, api_url: str):
+    GLOBAL_CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    GLOBAL_CONFIG_FILE.write_text(
+        f"RAYFOS_API_KEY={api_key}\n"
+        f"RAYFOS_API_URL={api_url}\n",
+        encoding="utf-8",
+    )
+
+
+def resolve_credentials() -> tuple[str | None, str]:
+    """Return (api_key, api_url) from the first source that has them."""
+    from . import _defaults  # module-level configure() values
+
+    api_key = _defaults.get("api_key")
+    api_url = _defaults.get("api_url")
+    if api_key:
+        return api_key, api_url or DEFAULT_API_URL
+
+    # Local .env
+    local_env = Path(".env")
+    if local_env.exists():
+        from dotenv import dotenv_values
+        vals = dotenv_values(local_env)
+        api_key = api_key or vals.get("RAYFOS_API_KEY")
+        api_url = api_url or vals.get("RAYFOS_API_URL")
+    if api_key:
+        return api_key, api_url or DEFAULT_API_URL
+
+    # Global config
+    cfg = load_global_config()
+    api_key = api_key or cfg.get("RAYFOS_API_KEY")
+    api_url = api_url or cfg.get("RAYFOS_API_URL")
+    if api_key:
+        return api_key, api_url or DEFAULT_API_URL
+
+    # Environment variables
+    api_key = os.environ.get("RAYFOS_API_KEY")
+    api_url = api_url or os.environ.get("RAYFOS_API_URL")
+    return api_key, api_url or DEFAULT_API_URL
+
+
+def _test_connection(api_key: str, api_url: str) -> bool:
+    try:
+        import requests
+        resp = requests.get(
+            f"{api_url.rstrip('/')}/api/health",
+            headers={"Authorization": f"Bearer {api_key}"},
+            timeout=10,
+            verify=not ("localhost" in api_url or "127.0.0.1" in api_url),
+        )
+        return resp.status_code < 500
+    except Exception as e:
+        print(f"  Connection error: {e}")
+        return False
+
+
+def run_setup():
+    print()
+    print("wavesimPro_api — setup wizard")
+    print("=" * 40)
+
+    existing = load_global_config()
+    existing_key = existing.get("RAYFOS_API_KEY", "")
+    existing_url = existing.get("RAYFOS_API_URL", DEFAULT_API_URL)
+
+    if existing_key:
+        masked = existing_key[:6] + "..." + existing_key[-4:]
+        print(f"Existing config found at: {GLOBAL_CONFIG_FILE}")
+        print(f"  API key : {masked}")
+        print(f"  Server  : {existing_url}")
+        print()
+        overwrite = input("Overwrite? [y/N]: ").strip().lower()
+        if overwrite != "y":
+            print("Keeping existing config.")
+            return
+
+    print()
+    api_key = getpass.getpass("API key (input hidden): ").strip()
+    if not api_key:
+        print("No API key entered. Aborting.")
+        return
+
+    url_prompt = f"Server URL [{DEFAULT_API_URL}]: "
+    api_url = input(url_prompt).strip() or DEFAULT_API_URL
+
+    print()
+    print("Testing connection...")
+    ok = _test_connection(api_key, api_url)
+    if ok:
+        print("  Connection successful.")
+    else:
+        print("  Could not reach server — saving anyway (check URL/key later).")
+
+    save_global_config(api_key, api_url)
+    print()
+    print(f"Config saved to: {GLOBAL_CONFIG_FILE}")
+    print("You're all set. Import wavesimPro_api in any project without extra setup.")
+    print()
+
+
+def run_status():
+    print()
+    print("wavesimPro_api — current configuration")
+    print("=" * 40)
+
+    api_key, api_url = resolve_credentials()
+
+    if not api_key:
+        print("No credentials found.")
+        print(f"Run: python -m wavesimPro_api setup")
+        return
+
+    masked = api_key[:6] + "..." + api_key[-4:] if len(api_key) > 10 else "***"
+    print(f"API key : {masked}")
+    print(f"Server  : {api_url}")
+
+    # Show source
+    cfg = load_global_config()
+    if cfg.get("RAYFOS_API_KEY") == api_key:
+        print(f"Source  : {GLOBAL_CONFIG_FILE}")
+    elif Path(".env").exists():
+        print("Source  : local .env")
+    else:
+        print("Source  : environment variable")
+
+    print()
+    print("Testing connection...")
+    ok = _test_connection(api_key, api_url)
+    print("  OK" if ok else "  Failed — check your API key and server URL")
+    print()

wavesimpro/simulate.py

@@ -0,0 +1,162 @@
+"""
+Remote simulate — drop-in replacement for wavesim.simulate() that executes via the Rayfos API.
+
+To switch an example from local to remote, change only the import:
+    from wavesim.simulate import simulate       # local GPU
+    from wavesimPro_api import simulate         # Rayfos cloud
+
+Credentials are resolved automatically — run the setup wizard once on each machine:
+    python -m wavesimPro_api setup
+
+Call configure() to override programmatically.
+"""
+
+from typing import Callable, Optional, Sequence
+
+import numpy as np
+
+from .execute import execute_via_api
+
+# Module-level defaults — overridden by configure() or per-call kwargs
+_defaults = {
+    "api_key": None,
+    "api_url": None,
+    "description": "Wavesim Python API",
+    "poll_interval": 10.0,
+    "engine_preference": "Any",
+    "use_gpu": None,
+}
+
+
+def configure(
+    *,
+    api_key: Optional[str] = None,
+    api_url: Optional[str] = None,
+    description: Optional[str] = None,
+    poll_interval: Optional[float] = None,
+    engine_preference: Optional[str] = None,
+    use_gpu: Optional[bool] = None,
+):
+    """Set module-level defaults for remote execution.
+
+    Call once at the top of a script to avoid repeating credentials on every
+    simulate() call.  Any value left as None keeps its current default.
+
+    Args:
+        api_key: Rayfos API key (overrides RAYFOS_API_KEY env var).
+        api_url: Rayfos API base URL (overrides RAYFOS_API_URL env var).
+        description: Job label shown in the Rayfos dashboard.
+        poll_interval: Status polling interval in seconds.
+        engine_preference: 'Any' (default), 'Python', or 'Cpp'.
+        use_gpu: None (auto), True (require GPU), False (force CPU).
+    """
+    if api_key is not None:
+        _defaults["api_key"] = api_key
+    if api_url is not None:
+        _defaults["api_url"] = api_url
+    if description is not None:
+        _defaults["description"] = description
+    if poll_interval is not None:
+        _defaults["poll_interval"] = poll_interval
+    if engine_preference is not None:
+        _defaults["engine_preference"] = engine_preference
+    if use_gpu is not None:
+        _defaults["use_gpu"] = use_gpu
+
+
+def simulate(
+    permittivity: np.ndarray,
+    sources: Sequence[tuple],
+    wavelength: float,
+    pixel_size: float,
+    boundary_width: float = 1.0,
+    periodic: tuple = (False, False, False),  # forwarded to PeriodicX/Y/Z in JSON
+    use_gpu=None,                              # forwarded to API (None = auto)
+    n_domains=None,          # local only — accepted and ignored
+    max_iterations: int = 100000,
+    threshold: float = 1.0e-6,
+    alpha: float = 0.75,     # local only — accepted and ignored
+    full_residuals: bool = False,  # local only — accepted and ignored
+    crop_boundaries: bool = True,  # local only — accepted and ignored
+    callback: Optional[Callable] = None,
+    **kwargs,
+):
+    """Execute a Wavesim simulation remotely via the Rayfos API.
+
+    Identical signature to wavesim.simulate() — swap the import, nothing else changes.
+    Local-only parameters (periodic, n_domains, alpha, full_residuals, crop_boundaries)
+    are silently ignored.
+
+    Credentials are resolved in this order:
+        1. configure() call
+        2. Local .env in the current working directory
+        3. ~/.wavesimPro_api/.env (written by: python -m wavesimPro_api setup)
+        4. RAYFOS_API_KEY / RAYFOS_API_URL environment variables
+
+    Returns:
+        u: np.ndarray, output field (same shape as wavesim.simulate()).
+        iterations: int or None, last reported iteration count.
+        residual_norm: float or None, last reported residual norm.
+    """
+    from .setup import resolve_credentials
+    _api_key, _api_url = resolve_credentials()
+    api_key = _defaults["api_key"] or _api_key
+    api_url = _defaults["api_url"] or _api_url
+    if not api_key:
+        raise RuntimeError(
+            "No API key found. Run the setup wizard once:\n"
+            "    python -m wavesimPro_api setup\n"
+            "Or set RAYFOS_API_KEY in your environment / .env file."
+        )
+    description = _defaults["description"]
+    poll_interval = _defaults["poll_interval"]
+    engine_preference = _defaults["engine_preference"]
+    effective_use_gpu = use_gpu if use_gpu is not None else _defaults["use_gpu"]
+
+    is_vectorial = any(len(s[1]) == 4 for s in sources)
+    boundary_width_px = int(np.round(boundary_width / pixel_size))
+
+    api_sources = []
+    for src_array, src_pos in sources:
+        pos = list(src_pos)
+        if is_vectorial:
+            pol_1based = int(pos[0]) + 1
+            api_pos = [pos[1] * pixel_size, pos[2] * pixel_size, pos[3] * pixel_size, pol_1based]
+            src_field = (src_array[0] if src_array.ndim == 4 else src_array).astype(np.complex64)
+        else:
+            api_pos = [pos[0] * pixel_size, pos[1] * pixel_size, pos[2] * pixel_size]
+            src_field = src_array.astype(np.complex64)
+        api_sources.append({"Es": src_field, "position": api_pos})
+
+    _last = {"iteration": None, "residual_norm": None}
+
+    def _progress_cb(info: dict):
+        _last["iteration"] = info.get("iteration", _last["iteration"])
+        _last["residual_norm"] = info.get("residual_norm", _last["residual_norm"])
+        if callback is not None:
+            extra = {k: v for k, v in info.items() if k not in ("iteration", "residual_norm")}
+            # Mirror the Richardson callback signature so existing callbacks work unchanged:
+            # callback(domain, iteration, x, residual_norm, **kwargs)
+            callback(None, _last["iteration"], None, _last["residual_norm"], **extra)
+
+    E, _ = execute_via_api(
+        refractive_index=permittivity,
+        source=api_sources,
+        wavelength=wavelength,
+        pixel_size=pixel_size,
+        boundary_width=boundary_width_px,
+        is_vectorial=is_vectorial,
+        data_type="Permittivity",
+        max_iterations=max_iterations,
+        threshold=threshold,
+        periodic=periodic,
+        api_key=api_key,
+        api_url=api_url,
+        description=description,
+        poll_interval=poll_interval,
+        engine_preference=engine_preference,
+        use_gpu=effective_use_gpu,
+        progress_callback=_progress_cb,
+    )
+
+    return E, _last["iteration"], _last["residual_norm"]

wavesimpro/validate.py

@@ -0,0 +1,251 @@
+"""
+Parameter validation for Wavesim simulations
+
+Ported from MATLAB validateParameters.m. Validates all simulation parameters
+before uploading files to the server, providing detailed error/warning messages.
+"""
+
+import math
+import logging
+from typing import List, Dict, Any, Optional, Tuple
+
+import numpy as np
+
+logger = logging.getLogger(__name__)
+
+
+class ParameterValidationError(Exception):
+    """Raised when parameter validation fails with one or more errors."""
+
+    def __init__(self, errors: List[str], warnings: List[str] = None):
+        self.errors = errors
+        self.warnings = warnings or []
+        msg = f"Parameter validation failed with {len(errors)} error(s):\n  - " + "\n  - ".join(errors)
+        super().__init__(msg)
+
+
+def validate_parameters(
+    refractive_index: np.ndarray,
+    sources: List[Dict[str, Any]],
+    wavelength: float,
+    pixel_size: float,
+    threshold: float = 1e-2,
+    max_iterations: int = 1000,
+    boundary_width: int = 0,
+    is_vectorial: bool = True,
+) -> List[str]:
+    """
+    Validate simulation parameters before upload.
+
+    Args:
+        refractive_index: [nx, ny, nz] array (refractive index or permittivity)
+        sources: List of source dicts with 'field', 'position', 'polarization' keys
+        wavelength: Wavelength in micrometers
+        pixel_size: Pixel size in micrometers
+        threshold: Convergence threshold
+        max_iterations: Maximum iterations
+        boundary_width: Boundary width in pixels
+        is_vectorial: True for Maxwell, False for Helmholtz
+
+    Returns:
+        List of warning strings (empty if no warnings)
+
+    Raises:
+        ParameterValidationError: If any parameter is invalid
+    """
+    errors: List[str] = []
+    warnings: List[str] = []
+
+    logger.info("Validating simulation parameters...")
+
+    # 1. Validate refractive index / permittivity array
+    if refractive_index is None or refractive_index.size == 0:
+        errors.append("Refractive index array is empty")
+    else:
+        shape = refractive_index.shape
+        # Pad to 3D
+        while len(shape) < 3:
+            shape = shape + (1,)
+        nx, ny, nz = shape[0], shape[1], shape[2]
+
+        if nx < 2 or ny < 2 or nz < 2:
+            errors.append(f"Domain too small: [{nx}, {ny}, {nz}]. Minimum is [2, 2, 2]")
+
+        if np.any(np.isnan(refractive_index)):
+            errors.append("Refractive index contains NaN values")
+        if np.any(np.isinf(refractive_index)):
+            errors.append("Refractive index contains Inf values")
+
+        min_real = float(np.min(np.real(refractive_index)))
+        max_real = float(np.max(np.real(refractive_index)))
+        if min_real <= 0:
+            warnings.append(f"Refractive index has non-positive real values (min={min_real:.4f}). This may cause issues.")
+        if max_real > 10:
+            warnings.append(f"Refractive index has very high values (max={max_real:.4f}). Verify this is correct.")
+
+        logger.info(f"  Domain: [{nx} x {ny} x {nz}]")
+
+    # 2. Validate wavelength
+    if wavelength is None:
+        errors.append("Wavelength is required")
+    elif wavelength <= 0:
+        errors.append(f"Wavelength must be positive (got {wavelength:.4f})")
+    elif wavelength < 0.1 or wavelength > 100:
+        warnings.append(f"Unusual wavelength: {wavelength:.4f} um. Typical range is 0.1-100 um.")
+
+    # 3. Validate pixel size
+    if pixel_size is None:
+        errors.append("Pixel size is required")
+    elif pixel_size <= 0:
+        errors.append(f"Pixel size must be positive (got {pixel_size:.4f})")
+    elif refractive_index is not None and refractive_index.size > 0 and wavelength and wavelength > 0:
+        n_max = float(np.max(np.real(refractive_index)))
+        if n_max > 0:
+            nyquist_limit = wavelength / (2 * n_max)
+            if pixel_size > nyquist_limit:
+                warnings.append(
+                    f"Pixel size ({pixel_size:.4f} um) exceeds Nyquist limit "
+                    f"({nyquist_limit:.4f} um for n_max={n_max:.2f}). Results may be inaccurate."
+                )
+            pixels_per_wavelength = wavelength / (n_max * pixel_size)
+            if pixels_per_wavelength < 10:
+                warnings.append(
+                    f"Only {pixels_per_wavelength:.1f} pixels per wavelength in "
+                    f"highest-index medium. Recommend >= 10."
+                )
+
+    # 4. Validate threshold
+    if threshold is None:
+        errors.append("Threshold must be numeric")
+    elif threshold <= 0:
+        errors.append(f"Threshold must be positive (got {threshold:.2e})")
+    elif threshold > 1:
+        warnings.append(f"Threshold ({threshold:.2e}) is very high. Typical range is 1e-9 to 1e-2.")
+    elif threshold < 1e-12:
+        warnings.append(f"Threshold ({threshold:.2e}) is very low. May not converge within max iterations.")
+
+    # 5. Validate max iterations
+    if max_iterations is None:
+        errors.append("Max iterations must be numeric")
+    elif max_iterations < 1:
+        errors.append(f"Max iterations must be >= 1 (got {max_iterations})")
+    elif max_iterations < 100:
+        warnings.append(f"Max iterations ({max_iterations}) is low. May not converge.")
+    elif max_iterations > 100000:
+        warnings.append(f"Max iterations ({max_iterations}) is very high. Simulation may take a long time.")
+
+    # 6. Validate boundary width
+    if boundary_width is not None:
+        if boundary_width < 0:
+            errors.append(f"Boundary width must be >= 0 (got {boundary_width})")
+        elif boundary_width > 0 and refractive_index is not None and refractive_index.size > 0:
+            shape = refractive_index.shape
+            while len(shape) < 3:
+                shape = shape + (1,)
+            dims = shape[:3]
+            dim_names = ("x", "y", "z")
+            exceeded = []
+            for i in range(3):
+                max_allowed = dims[i] // 2
+                if boundary_width > max_allowed:
+                    exceeded.append(f"{dim_names[i]} ({dims[i]}->{max_allowed})")
+            if exceeded:
+                warnings.append(
+                    f"Boundary width ({boundary_width} pixels) exceeds maximum for "
+                    f"dimension(s): {', '.join(exceeded)}. Backend will clamp boundary width per dimension."
+                )
+
+    # 7. Validate GPU memory requirements
+    if refractive_index is not None and refractive_index.size > 0:
+        shape = refractive_index.shape
+        while len(shape) < 3:
+            shape = shape + (1,)
+        nx, ny, nz = shape[0], shape[1], shape[2]
+
+        total_nx = nx + 2 * boundary_width
+        total_ny = ny + 2 * boundary_width
+        total_nz = nz + 2 * boundary_width
+        total_voxels = total_nx * total_ny * total_nz
+
+        bytes_per_voxel = 120 if is_vectorial else 40
+        gpu_memory_gb = (total_voxels * bytes_per_voxel) / (1024 ** 3)
+
+        GPU_MEMORY_OK_GB = 16
+        GPU_MEMORY_MAX_GB = 65
+
+        logger.info(f"  GPU memory estimate: {gpu_memory_gb:.2f} GB ({'Vectorial' if is_vectorial else 'Scalar'})")
+
+        if gpu_memory_gb > GPU_MEMORY_MAX_GB:
+            errors.append(
+                f"Domain size too large for GPU. Estimated memory: {gpu_memory_gb:.2f} GB "
+                f"exceeds maximum {GPU_MEMORY_MAX_GB:.0f} GB. Reduce domain size or pixel count."
+            )
+        elif gpu_memory_gb > GPU_MEMORY_OK_GB:
+            warnings.append(
+                f"GPU memory {gpu_memory_gb:.2f} GB exceeds standard {GPU_MEMORY_OK_GB:.0f} GB. "
+                f"Will use advanced GPU instance."
+            )
+
+    # 8. Validate sources
+    if not sources:
+        errors.append("At least one source is required")
+    else:
+        ri_shape = refractive_index.shape if refractive_index is not None else (0, 0, 0)
+        while len(ri_shape) < 3:
+            ri_shape = ri_shape + (1,)
+        nx, ny, nz = ri_shape[0], ri_shape[1], ri_shape[2]
+
+        for i, src in enumerate(sources):
+            src_field = src.get("field")
+            if src_field is None or (isinstance(src_field, np.ndarray) and src_field.size == 0):
+                errors.append(f"Source {i + 1}: field is empty")
+            elif isinstance(src_field, np.ndarray):
+                if np.any(np.isnan(src_field)):
+                    errors.append(f"Source {i + 1}: field contains NaN values")
+                if np.any(np.isinf(src_field)):
+                    errors.append(f"Source {i + 1}: field contains Inf values")
+
+                src_shape = src_field.shape
+                while len(src_shape) < 3:
+                    src_shape = src_shape + (1,)
+                if src_shape[0] > nx or src_shape[1] > ny or src_shape[2] > nz:
+                    errors.append(
+                        f"Source {i + 1}: field size [{src_shape[0]},{src_shape[1]},{src_shape[2]}] "
+                        f"exceeds domain [{nx},{ny},{nz}]"
+                    )
+
+                if np.all(src_field == 0):
+                    warnings.append(f"Source {i + 1}: field is all zeros")
+
+            # Check position
+            pos = src.get("position")
+            if pos is None or len(pos) < 3:
+                errors.append(f"Source {i + 1}: position must have at least 3 elements [x, y, z]")
+            elif pixel_size and pixel_size > 0:
+                domain_x = nx * pixel_size
+                domain_y = ny * pixel_size
+                domain_z = nz * pixel_size
+                if pos[0] < 0 or pos[0] > domain_x:
+                    warnings.append(f"Source {i + 1}: x position ({pos[0]:.2f} um) outside domain [0, {domain_x:.2f}]")
+                if pos[1] < 0 or pos[1] > domain_y:
+                    warnings.append(f"Source {i + 1}: y position ({pos[1]:.2f} um) outside domain [0, {domain_y:.2f}]")
+                if pos[2] < 0 or pos[2] > domain_z:
+                    warnings.append(f"Source {i + 1}: z position ({pos[2]:.2f} um) outside domain [0, {domain_z:.2f}]")
+
+            # Check polarization for vectorial
+            pol = src.get("polarization")
+            if pol is not None and is_vectorial and pol not in (0, 1, 2):
+                warnings.append(f"Source {i + 1}: invalid polarization {pol} for vectorial simulation (expected 0=x, 1=y, 2=z)")
+
+    # Report warnings
+    for w in warnings:
+        logger.warning(f"  [!] {w}")
+
+    # Raise on errors
+    if errors:
+        for e in errors:
+            logger.error(f"  [X] {e}")
+        raise ParameterValidationError(errors, warnings)
+
+    logger.info("  All parameters validated successfully")
+    return warnings

wavesimpro-0.9.0.dist-info/METADATA

@@ -0,0 +1,21 @@
+Metadata-Version: 2.4
+Name: wavesimpro
+Version: 0.9.0
+Summary: WavesimPro Python API — cloud execution client for the Rayfos simulation platform
+Author: Rayfos
+Project-URL: Repository, https://github.com/rayfos/wavesimpro
+Keywords: wavesim,simulation,electromagnetic,rayfos,api
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.20.0
+Requires-Dist: requests>=2.28.0
+Requires-Dist: python-dotenv>=1.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"

wavesimpro-0.9.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+wavesimpro/__init__.py,sha256=Xs16Y1JTqnR7U1v2iIL2JdDyrFx2np8enuAA9BmW2Ms,2637
+wavesimpro/__main__.py,sha256=bFC1Az6fsX2Rov-z90K-Dqcl8X74RXgIG_RudRBfO1k,600
+wavesimpro/binary_utils.py,sha256=CF8ucmPdcK2tlvogDRO-PJKJo7PCoq5OPcSKIvGzgic,35106
+wavesimpro/client.py,sha256=qm60X3PWOYQk-8GRs49KcHWwnEZarVIOa2Gh-_Al7iI,55654
+wavesimpro/config.py,sha256=MVghdqd5rxsvAhiR3qipzZnPbSDfDjeD27ypyV1Ia6s,4442
+wavesimpro/exceptions.py,sha256=yb4XN52Z4rf5MMANV01nexfH4udC9X_aorC9j4H5pG4,903
+wavesimpro/execute.py,sha256=Uu4qkHylfWyXSyW_6adiMlgcWWHP0r34dSb424FtHrM,18451
+wavesimpro/json_helper.py,sha256=OOdnVyMU4WwLAdUtiOPtHjrS-4hZ0GCfwQzM8gAtC70,23416
+wavesimpro/py.typed,sha256=nJJj1nmMhDHzYPOcAJC53joZRqpJr7vghugcsQrE09s,87
+wavesimpro/setup.py,sha256=XIUAbfxaamXo5mSZdb9rXBxaPMe3dAzZCZkd9GUP_M4,5071
+wavesimpro/simulate.py,sha256=4ZReFDnKndyacpg_rkJDq__8tqSa6ho6BV0QvKSwzJE,6290
+wavesimpro/validate.py,sha256=d4WdTwCBqZsU0xbYxRd02OF4GBvSdPazqMS0bgCm2EY,10759
+wavesimpro-0.9.0.dist-info/METADATA,sha256=kWukzFa_Y0gXVvv3oXjzASXM4Xu1uOQRnTz43IaNJss,843
+wavesimpro-0.9.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+wavesimpro-0.9.0.dist-info/top_level.txt,sha256=n0QlP2w8juE34aE4Pl_np97zcVWNCpa-LxmypLNvZLQ,11
+wavesimpro-0.9.0.dist-info/RECORD,,

wavesimpro-0.9.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
+

wavesimpro-0.9.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+wavesimpro