pyhubblenetwork 0.0.2__tar.gz → 0.0.4__tar.gz

{pyhubblenetwork-0.0.2 → pyhubblenetwork-0.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyhubblenetwork
-Version: 0.0.2
+Version: 0.0.4
 Summary: Hubble SDK host-side tools
 Author-email: Paul Buckley <paul@hubble.com>
 License-Expression: Apache-2.0
@@ -84,9 +84,9 @@ pip install -e '.[dev]'
 ### Scan locally, then ingest to backend
 
 ```python
-from hubblenetwork import ble, Organization
+from hubblenetwork import ble, Organization, Credentials
 
-org = Organization(org_id="org_123", api_token="sk_XXX")
+org = Organization(Credentials(org_id="org_123", api_token="sk_XXX"))
 pkts = ble.scan(timeout=5.0)
 if len(pkts) > 0:
     org.ingest_packet(pkts[0])
@@ -97,9 +97,9 @@ else:
 ### Manage devices and query packets
 
 ```python
-from hubblenetwork import Organization
+from hubblenetwork import Organization, Credentials
 
-org = Organization(org_id="org_123", api_token="sk_XXX")
+org = Organization(Credentials(org_id="org_123", api_token="sk_XXX"))
 
 # Create a new device
 new_dev = org.register_device()

{pyhubblenetwork-0.0.2 → pyhubblenetwork-0.0.4}/README.md

@@ -61,9 +61,9 @@ pip install -e '.[dev]'
 ### Scan locally, then ingest to backend
 
 ```python
-from hubblenetwork import ble, Organization
+from hubblenetwork import ble, Organization, Credentials
 
-org = Organization(org_id="org_123", api_token="sk_XXX")
+org = Organization(Credentials(org_id="org_123", api_token="sk_XXX"))
 pkts = ble.scan(timeout=5.0)
 if len(pkts) > 0:
     org.ingest_packet(pkts[0])
@@ -74,9 +74,9 @@ else:
 ### Manage devices and query packets
 
 ```python
-from hubblenetwork import Organization
+from hubblenetwork import Organization, Credentials
 
-org = Organization(org_id="org_123", api_token="sk_XXX")
+org = Organization(Credentials(org_id="org_123", api_token="sk_XXX"))
 
 # Create a new device
 new_dev = org.register_device()

{pyhubblenetwork-0.0.2 → pyhubblenetwork-0.0.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "pyhubblenetwork"
-version = "0.0.2"
+version = "0.0.4"
 requires-python = ">=3.9"
 authors = [
   { name="Paul Buckley", email="paul@hubble.com" },

{pyhubblenetwork-0.0.2 → pyhubblenetwork-0.0.4}/src/hubblenetwork/__init__.py

@@ -11,6 +11,8 @@ from .packets import Location, EncryptedPacket, DecryptedPacket
 from .device import Device
 from .org import Organization
 from .crypto import decrypt
+from .errors import InvalidCredentialsError
+from .cloud import Credentials, Environment
 
 __all__ = [
     "ble",
@@ -21,4 +23,7 @@ __all__ = [
     "DecryptedPacket",
     "Device",
     "Organization",
+    "Credentials",
+    "Environment",
+    "InvalidCredentialsError",
 ]

{pyhubblenetwork-0.0.2 → pyhubblenetwork-0.0.4}/src/hubblenetwork/ble.py

@@ -1,9 +1,8 @@
 # hubblenetwork/ble.py
 from __future__ import annotations
-
 import asyncio
 from datetime import datetime, timezone
-from typing import Optional
+from typing import Optional, List
 import geocoder
 
 from bleak import BleakScanner
@@ -90,3 +89,68 @@ def scan(timeout: float) -> List[EncryptedPacket]:
             # Create a task and block until it’s done via a new Future
             return loop.run_until_complete(_scan_async(timeout))  # type: ignore[func-returns-value]
         return loop.run_until_complete(_scan_async(timeout))
+
+
+def scan_single(timeout: float) -> Optional[EncryptedPacket]:
+    """
+    Scan for a BLE advertisement that includes service data for UUID 0xFCA6 and
+    return it.
+    """
+
+    async def _scan_async(ttl: float) -> List[EncryptedPacket]:
+        done = asyncio.Event()
+        packet: Optional[EncryptedPacket] = None
+
+        def on_detect(device, adv_data) -> None:
+            nonlocal packet
+
+            # If we already found a packet, ignore further callbacks
+            if packet is not None:
+                return
+
+            # Normalize to a dict; bleak provides service_data as {uuid_str: bytes}
+            service_data = getattr(adv_data, "service_data", None) or {}
+            service_uuids = getattr(adv_data, "service_uuids", None) or []
+            payload = None
+
+            if _TARGET_UUID not in service_uuids:
+                return
+
+            # Keys are 128-bit UUID strings; compare lowercased
+            for uuid_str, data in service_data.items():
+                if (uuid_str or "").lower() == _TARGET_UUID:
+                    payload = bytes(data)
+                    break
+
+            if payload is None:
+                return
+
+            rssi = getattr(adv_data, "rssi", getattr(device, "rssi", 0)) or 0
+            packet = EncryptedPacket(
+                timestamp=int(datetime.now(timezone.utc).timestamp()),
+                location=_get_location(),
+                payload=payload,
+                rssi=int(rssi),
+            )
+            done.set()
+
+        # Start scanning and wait for first match or timeout
+        async with BleakScanner(detection_callback=on_detect):
+            try:
+                await asyncio.wait_for(done.wait(), timeout=ttl)
+            except asyncio.TimeoutError:
+                pass
+
+        return packet
+
+    # Run the async scanner. If there's already a running event loop (e.g., Jupyter),
+    # you can adapt this to use `await _scan_async(timeout)` instead.
+    try:
+        return asyncio.run(_scan_async(timeout))
+    except RuntimeError:
+        # Fallback for environments with an active loop (e.g., notebooks/async apps)
+        loop = asyncio.get_event_loop()
+        if loop.is_running():
+            # Create a task and block until it’s done via a new Future
+            return loop.run_until_complete(_scan_async(timeout))  # type: ignore[func-returns-value]
+        return loop.run_until_complete(_scan_async(timeout))

{pyhubblenetwork-0.0.2 → pyhubblenetwork-0.0.4}/src/hubblenetwork/cli.py

@@ -4,15 +4,16 @@ from __future__ import annotations
 import click
 import os
 import json
-import time
-import base64
 import sys
-from datetime import timezone, datetime
+import time
+from datetime import datetime
 from typing import Optional
 from hubblenetwork import Organization
 from hubblenetwork import Device, DecryptedPacket, EncryptedPacket
 from hubblenetwork import ble as ble_mod
 from hubblenetwork import decrypt
+from hubblenetwork import cloud
+from hubblenetwork import InvalidCredentialsError
 
 
 def _get_env_or_fail(name: str) -> str:
@@ -34,28 +35,53 @@ def _get_org_and_token(org_id, token) -> tuple[str, str]:
     return org_id, token
 
 
+def _print_packet_table_header() -> None:
+    click.echo(
+        "\nTIME                      RSSI   LAT         LON          PAYLOAD (B)"
+    )
+    click.echo(
+        "---------------------------------------------------------------------------"
+    )
+
+
+def _print_packet_table_row(pkt) -> None:
+    ts = datetime.fromtimestamp(pkt.timestamp).strftime("%c")
+    click.echo(
+        f"{ts}  {pkt.rssi}    {pkt.location.lat:.6f}   {pkt.location.lon:.6f}  ",
+        nl=False,
+    )
+    if isinstance(pkt, DecryptedPacket):
+        click.echo(f'payload: "{pkt.payload}"')
+    elif isinstance(pkt, EncryptedPacket):
+        click.echo(f"{pkt.payload.hex()} ({len(pkt.payload)} bytes)")
+
+
+def _print_packet_pretty(pkt) -> None:
+    ts = datetime.fromtimestamp(pkt.timestamp).strftime("%c")
+    loc = pkt.location
+    loc_str = (
+        f"{loc.lat:.6f},{loc.lon:.6f}"
+        if getattr(loc, "lat", None) is not None
+        else "unknown"
+    )
+    click.echo(click.style("=== BLE packet ===", bold=True))
+    click.echo(f"time:    {ts}")
+    click.echo(f"rssi:    {pkt.rssi} dBm")
+    click.echo(f"loc:     {loc_str}")
+    # Show both hex and length
+    if isinstance(pkt, DecryptedPacket):
+        click.echo(f'payload: "{pkt.payload}"')
+    elif isinstance(pkt, EncryptedPacket):
+        click.echo(f"payload: {pkt.payload.hex()} ({len(pkt.payload)} bytes)")
+
+
 def _print_packets_pretty(pkts) -> None:
     if len(pkts) == 0:
         click.echo("No packets!")
         return
     """Pretty-print an EncryptedPacket."""
     for pkt in pkts:
-        ts = datetime.fromtimestamp(pkt.timestamp).strftime("%c")
-        loc = pkt.location
-        loc_str = (
-            f"{loc.lat:.6f},{loc.lon:.6f}"
-            if getattr(loc, "lat", None) is not None
-            else "unknown"
-        )
-        click.echo(click.style("=== BLE packet ===", bold=True))
-        click.echo(f"time:    {ts}")
-        click.echo(f"rssi:    {pkt.rssi} dBm")
-        click.echo(f"loc:     {loc_str}")
-        # Show both hex and length
-        if isinstance(pkt, DecryptedPacket):
-            click.echo(f'payload: "{pkt.payload}"')
-        elif isinstance(pkt, EncryptedPacket):
-            click.echo(f"payload: {pkt.payload.hex()} ({len(pkt.payload)} bytes)")
+        _print_packet_pretty(pkt)
 
 
 def _print_packets_csv(pkts) -> None:
@@ -122,6 +148,36 @@ def cli() -> None:
     # top-level group; subcommands are added below
 
 
+@cli.command("validate-credentials")
+@click.option(
+    "--org-id",
+    "-o",
+    type=str,
+    envvar="HUBBLE_ORG_ID",
+    default=None,
+    show_default=False,
+    help="Organization ID (if not using HUBBLE_ORG_ID env var)",
+)
+@click.option(
+    "--token",
+    "-t",
+    type=str,
+    envvar="HUBBLE_API_TOKEN",
+    default=None,
+    show_default=False,
+    help="Token (if not using HUBBLE_API_TOKEN env var)",
+)
+def validate_credentials(org_id, token) -> None:
+    """Validate the given credentials"""
+    # subgroup for organization-related commands
+    credentials = cloud.Credentials(org_id, token)
+    env = cloud.get_env_from_credentials(credentials)
+    if env:
+        click.echo(f'Valid credentials (env="{env.name}")')
+    else:
+        click.secho("Invalid credentials!", fg="red", err=True)
+
+
 @cli.group()
 def ble() -> None:
     """BLE utilities."""
@@ -133,7 +189,6 @@ def ble() -> None:
     "--timeout",
     "-t",
     type=int,
-    default=5,
     show_default=False,
     help="Timeout when scanning",
 )
@@ -146,48 +201,44 @@ def ble() -> None:
     help="Attempt to decrypt any received packet with the given key",
 )
 @click.option("--ingest", is_flag=True)
-def ble_scan(timeout, ingest: bool = False, key: str = None) -> None:
+def ble_scan(
+    timeout: Optional(int) = None, ingest: bool = False, key: str = None
+) -> None:
     """
     Scan for UUID 0xFCA6 and print the first packet found within TIMEOUT seconds.
 
     Example:
       hubblenetwork ble scan 1
     """
-    click.secho(
-        f"[INFO] Scanning for Hubble devices (timeout={timeout}s)... ", nl=False
-    )
-    pkts = ble_mod.scan(timeout=timeout)
-    if len(pkts) == 0:
-        click.secho(f"[WARNING] No packet found within {timeout:.2f}s", fg="yellow")
-        raise SystemExit(1)
-    click.echo("[COMPLETE]")
-
-    click.echo("\n[INFO] Encrypted packets received:")
-    _print_packets(pkts)
-
-    # If we have a key, attempt to decrypt
-    if key:
-        key = bytearray(base64.b64decode(key))
-        decrypted_pkts = []
-        for pkt in pkts:
-            decrypted_pkt = decrypt(key, pkt)
-            if decrypted_pkt:
-                decrypted_pkts.append(decrypted_pkt)
-        if len(decrypted_pkts) > 0:
-            click.echo("\n[INFO] Locally decrypted packets:")
-            _print_packets(decrypted_pkts)
-        else:
-            click.secho("\n[WARNING] No locally decryptable packets found", fg="yellow")
+    click.secho("[INFO] Scanning for Hubble devices...")
+    _print_packet_table_header()
 
     if ingest:
-        click.echo("[INFO] Ingesting packet(s) into the backend... ", nl=False)
         org = Organization(
             org_id=_get_env_or_fail("HUBBLE_ORG_ID"),
             api_token=_get_env_or_fail("HUBBLE_API_TOKEN"),
         )
-        for pkt in pkts:
+
+    start = time.monotonic()
+    deadline = None if timeout is None else start + timeout
+
+    while deadline is None or time.monotonic() < deadline:
+        this_timeout = None if deadline is None else max(deadline - time.monotonic(), 0)
+
+        pkt = ble_mod.scan_single(timeout=this_timeout)
+        if not pkt:
+            break
+
+        # If we have a key, attempt to decrypt
+        if key:
+            decrypted_pkt = decrypt(key, pkt)
+            if decrypted_pkt:
+                _print_packet_table_row(pkt)
+        else:
+            _print_packet_table_row(pkt)
+
+        if ingest:
             org.ingest_packet(pkt)
-        click.echo("[SUCCESS]")
 
 
 pass_orgcfg = click.make_pass_decorator(Organization, ensure=True)
@@ -212,21 +263,14 @@ pass_orgcfg = click.make_pass_decorator(Organization, ensure=True)
     show_default=False,
     help="Token (if not using HUBBLE_API_TOKEN env var)",
 )
-@click.option(
-    "--url",
-    "-u",
-    type=str,
-    envvar="HUBBLE_BASE_URL",
-    default=None,
-    show_default=False,
-    help="Base URL to override production (if not using HUBBLE_BASE_URL env var)",
-)
 @click.pass_context
-def org(ctx, org_id, token, url) -> None:
+def org(ctx, org_id, token) -> None:
     """Organization utilities."""
     # subgroup for organization-related commands
-    ctx.obj = Organization(org_id=org_id, api_token=token)
-    ctx.obj.base_url = url
+    try:
+        ctx.obj = Organization(org_id=org_id, api_token=token)
+    except InvalidCredentialsError as e:
+        raise click.BadParameter(str(e))
 
 
 @org.command("info")
@@ -247,9 +291,19 @@ def list_devices(org: Organization) -> None:
 
 
 @org.command("register-device")
+@click.option(
+    "--encryption",
+    "-e",
+    type=str,
+    default=None,
+    show_default=False,  # show default in --help
+    help="Encryption type [AES-256-CTR, AES-128-CTR]",
+)
 @pass_orgcfg
-def register_device(org: Organization) -> None:
-    click.secho(str(org.register_device()))
+def register_device(org: Organization, encryption) -> None:
+    if encryption:
+        click.secho(f'[INFO] Overriding default encryption, using "{encryption}"')
+    click.secho(str(org.register_device(encryption=encryption)))
 
 
 @org.command("set-device-name")

{pyhubblenetwork-0.0.2 → pyhubblenetwork-0.0.4}/src/hubblenetwork/cloud.py

@@ -1,5 +1,6 @@
 # hubble/cloud_api.py
 from __future__ import annotations
+from dataclasses import dataclass
 import httpx
 import time
 import base64
@@ -13,11 +14,23 @@ from .errors import (
     raise_for_response,
 )
 
-ENVIRONMENTS = {
-    "PROD": "https://api.hubble.com",
-    "TESTING": "https://api-testing.hubblenetwork.io",
-}
-default_env_url = None
+
+@dataclass(frozen=True)
+class Environment:
+    name: str
+    url: str
+
+
+@dataclass(frozen=True)
+class Credentials:
+    org_id: str
+    api_token: str
+
+
+_ENVIRONMENTS = [
+    Environment("PROD", "https://api.hubble.com"),
+    Environment("TESTING", "https://api-testing.hubblenetwork.io"),
+]
 
 
 def _auth_headers(api_token: str) -> dict[str, str]:
@@ -28,69 +41,64 @@ def _auth_headers(api_token: str) -> dict[str, str]:
     }
 
 
-def _list_devices_endpoint(org_id: str) -> str:
-    return f"/org/{org_id}/devices"
+def _list_devices_endpoint(credentials: Credentials) -> str:
+    return f"/org/{credentials.org_id}/devices"
 
 
-def _register_device_endpoint(org_id: str) -> str:
-    return f"/v2/org/{org_id}/devices"
+def _register_device_endpoint(credentials: Credentials) -> str:
+    return f"/v2/org/{credentials.org_id}/devices"
 
 
-def _retrieve_org_packets_endpoint(org_id: str) -> str:
-    return f"/org/{org_id}/packets"
+def _retrieve_org_packets_endpoint(credentials: Credentials) -> str:
+    return f"/org/{credentials.org_id}/packets"
 
 
-def _ingest_packets_endpoint(org_id: str) -> str:
-    return f"/org/{org_id}/packets"
+def _ingest_packets_endpoint(credentials: Credentials) -> str:
+    return f"/org/{credentials.org_id}/packets"
 
 
-def _update_device_endpoint(org_id: str, device_id: str) -> str:
-    return f"/org/{org_id}/devices/{device_id}"
+def _update_device_endpoint(credentials: Credentials, device_id: str) -> str:
+    return f"/org/{credentials.org_id}/devices/{device_id}"
 
 
-def _retrive_org_metadata_endpoint(org_id: str) -> str:
-    return f"/org/{org_id}"
+def _retrieve_org_metadata_endpoint(credentials: Credentials) -> str:
+    return f"/org/{credentials.org_id}"
 
 
-def set_env(env: str) -> None:
-    default_env_url = env
+def _validate_key_endpoint(credentials: Credentials) -> str:
+    return f"/org/{credentials.org_id}/check"
 
 
 def cloud_request(
+    *,
     method: str,
     path: str,
-    *,
-    api_token: Optional[str] = None,
+    env: Environment,
+    credentials: Optional[Credentials] = None,
     json: Any = None,
     timeout_s: float = 10.0,
     params: Optional[MutableMapping[str, Any]] = None,
-    base_url: Optional[str] = None,
 ) -> Any:
     """
     Make a single HTTP request to the Hubble Cloud API and return parsed JSON.
 
     - `method`: "GET", "POST", etc.
     - `path`: endpoint path (e.g., "/devices" or "orgs/{id}/devices")
-    - `api_token`: API token for auth (optional, but recommended)
-    - `org_id`: if provided, will be added as query param `orgId=<org_id>`
-               (skip or embed in `path` if your endpoint uses a path param instead)
+    - `credentials`: Credentials to use for this call
+    - `env`: Environment to call into (typically prod or testing)
     - `json`: request JSON body (for POST/PUT/PATCH)
     - `timeout_s`: request timeout in seconds
     - `params`: optional HTTP request parameters
-    - `base_url`: URL to use in place of default production URL
     """
-    path = path.lstrip("/")
-    base_url = base_url if base_url is not None else default_env_url
-    base_url = base_url.rstrip("/")
-    url = f"{base_url}/api/{path}"
+    url = f"{env.url.rstrip('/')}/api/{path.lstrip('/')}"
 
     # headers
     headers: MutableMapping[str, str] = {
         "Accept": "application/json",
         "Content-Type": "application/json",
     }
-    if api_token:
-        headers["Authorization"] = f"Bearer {api_token}"
+    if credentials:
+        headers["Authorization"] = f"Bearer {credentials.api_token}"
 
     try:
         with httpx.Client(timeout=timeout_s) as client:
@@ -118,31 +126,44 @@ def cloud_request(
         raise BackendError(f"Non-JSON response from {url}") from e
 
 
+def get_env_from_credentials(credentials: Credentials) -> Optional[Environment]:
+    for env in _ENVIRONMENTS:
+        try:
+            # If this call fails then we know we don't have the
+            # credentials for this environment
+            cloud_request(
+                method="GET",
+                path=_validate_key_endpoint(credentials),
+                credentials=credentials,
+                env=env,
+            )
+            return env
+        except:
+            pass
+    return None
+
+
 def register_device(
-    *,
-    org_id: str,
-    api_token: str,
-    base_url: Optional[str] = None,
+    *, credentials: Credentials, env: Environment, encryption: str = "AES-256-CTR"
 ) -> Any:
     """Create a new device and return it."""
     data = {
         "n_devices": 1,
-        "encryption": "AES-256-CTR",
+        "encryption": "AES-256-CTR" if not encryption else encryption,
     }
     return cloud_request(
         method="POST",
-        path=_register_device_endpoint(org_id),
-        api_token=api_token,
+        env=env,
+        path=_register_device_endpoint(credentials),
+        credentials=credentials,
         json=data,
-        base_url=base_url,
     )
 
 
 def update_device(
     *,
-    org_id: str,
-    api_token: str,
-    base_url: Optional[str] = None,
+    credentials: Credentials,
+    env: Environment,
     name: str,
     device_id: str,
 ) -> Any:
@@ -153,15 +174,17 @@ def update_device(
     }
     return cloud_request(
         method="PATCH",
-        path=_update_device_endpoint(org_id, device_id),
-        api_token=api_token,
+        env=env,
+        path=_update_device_endpoint(credentials, device_id),
+        credentials=credentials,
         json=data,
-        base_url=base_url,
     )
 
 
 def list_devices(
-    *, org_id: str, api_token: str, base_url: Optional[str] = None
+    *,
+    credentials: Credentials,
+    env: Environment,
 ) -> list[Any]:
     """
     List devices for the org (keys typically omitted).
@@ -172,19 +195,18 @@ def list_devices(
     """
     return cloud_request(
         method="GET",
-        path=_list_devices_endpoint(org_id),
-        api_token=api_token,
-        base_url=base_url,
+        env=env,
+        path=_list_devices_endpoint(credentials),
+        credentials=credentials,
     )
 
 
 def retrieve_packets(
     *,
-    org_id: str,
-    api_token: str,
-    device_id: Optional[str] = None,
+    credentials: Credentials,
+    env: Environment,
+    device_id: str,
     days: int = 7,
-    base_url: Optional[str] = None,
 ) -> Any:
     """Fetch decrypted packets for a device."""
     params = {"start": (int(time.time()) - (days * 24 * 60 * 60))}
@@ -192,19 +214,18 @@ def retrieve_packets(
         params["device_id"] = device_id
     return cloud_request(
         method="GET",
-        path=_retrieve_org_packets_endpoint(org_id),
-        api_token=api_token,
+        env=env,
+        path=_retrieve_org_packets_endpoint(credentials),
+        credentials=credentials,
         params=params,
-        base_url=base_url,
     )
 
 
 def ingest_packet(
     *,
-    org_id: str,
-    api_token: str,
+    credentials: Credentials,
+    env: Environment,
     packet: EncryptedPacket,
-    base_url: Optional[str] = None,
 ) -> Any:
     body = {
         "ble_locations": [
@@ -229,18 +250,17 @@ def ingest_packet(
     }
     return cloud_request(
         method="POST",
-        path=_ingest_packets_endpoint(org_id),
-        api_token=api_token,
+        env=env,
+        path=_ingest_packets_endpoint(credentials),
+        credentials=credentials,
         json=body,
-        base_url=base_url,
     )
 
 
 def retrieve_org_metadata(
     *,
-    org_id: str,
-    api_token: str,
-    base_url: Optional[str] = None,
+    credentials: Credentials,
+    env: Environment,
 ) -> Any:
     """
     Get organizational metadata
@@ -251,7 +271,7 @@ def retrieve_org_metadata(
     """
     return cloud_request(
         method="GET",
-        path=_retrive_org_metadata_endpoint(org_id),
-        api_token=api_token,
-        base_url=base_url,
+        env=env,
+        path=_retrieve_org_metadata_endpoint(credentials),
+        credentials=credentials,
     )

{pyhubblenetwork-0.0.2 → pyhubblenetwork-0.0.4}/src/hubblenetwork/crypto.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+from typing import Optional
 from Crypto.Cipher import AES
 from Crypto.Hash import CMAC
 from Crypto.Protocol.KDF import SP800_108_Counter
@@ -57,10 +58,8 @@ def decrypt(
 ) -> Optional[DecryptedPacket]:
     ble_adv = encrypted_pkt.payload
     seq_no = int.from_bytes(ble_adv[0:2], "big") & 0x3FF
-    device_id = ble_adv[2:6].hex()
     auth_tag = ble_adv[6:10]
     encrypted_payload = ble_adv[10:]
-    day_offset = 0
 
     time_counter = int(datetime.now(timezone.utc).timestamp()) // 86400
 
@@ -69,8 +68,7 @@ def decrypt(
         tag = _get_auth_tag(daily_key, encrypted_payload)
 
         if tag == auth_tag:
-            day_offset = t
-            nonce = _get_nonce(key, time_counter, seq_no)
+            nonce = _get_nonce(key, time_counter + t, seq_no)
             decrypted_payload = _aes_decrypt(daily_key, nonce, encrypted_payload)
             return DecryptedPacket(
                 timestamp=encrypted_pkt.timestamp,

{pyhubblenetwork-0.0.2 → pyhubblenetwork-0.0.4}/src/hubblenetwork/device.py

@@ -2,7 +2,6 @@
 from __future__ import annotations
 from dataclasses import dataclass
 from typing import Dict, List, Optional
-from .packets import EncryptedPacket, DecryptedPacket
 
 
 @dataclass

{pyhubblenetwork-0.0.2 → pyhubblenetwork-0.0.4}/src/hubblenetwork/errors.py

@@ -40,6 +40,10 @@ class APITimeout(BackendError):
     """The API call exceeded its allowed timeout."""
 
 
+class InvalidCredentialsError(BackendError):
+    """Invalid credentials passed in"""
+
+
 # Request/response semantics
 class ValidationError(BackendError):
     """The request was invalid (schema/semantics)."""

{pyhubblenetwork-0.0.2 → pyhubblenetwork-0.0.4}/src/hubblenetwork/org.py

@@ -1,12 +1,11 @@
 # hubble/org.py
 from __future__ import annotations
-from dataclasses import dataclass
 from typing import Optional, List
 
 from . import cloud
-from .packets import DecryptedPacket, Location
+from .packets import DecryptedPacket, EncryptedPacket, Location
 from .device import Device
-from .errors import BackendError
+from .errors import InvalidCredentialsError
 
 
 class Organization:
@@ -15,42 +14,35 @@ class Organization:
     Used to manage devices and fetch decrypted packets from the backend.
     """
 
-    org_id: str
-    api_token: str
-
-    api_base_url: str
-    env: str
     name: str
 
-    def __init__(self, org_id: str, api_token: str) -> str:
-        self.org_id = org_id
-        self.api_token = api_token
+    credentials: cloud.Credentials
+    env: cloud.Environment
 
-        # Attempt to resolve environment (testing or prod)
-        resp = None
-        for env, url in cloud.ENVIRONMENTS.items():
-            try:
-                resp = cloud.retrieve_org_metadata(
-                    org_id=self.org_id, api_token=self.api_token, base_url=url
-                )
-                self.api_base_url = url
-                self.env = env
-                break
-            except:
-                pass
-        if not resp:
-            raise BackendError(f"Unable to determine environment")
-        self.name = resp["name"]
+    def __init__(
+        self,
+        org_id: Optional(str) = None,
+        api_token: Optional(str) = None,
+        credentials: Optional(cloud.Credentials) = None,
+    ) -> str:
+        if credentials:
+            self.credentials = credentials
+        else:
+            self.credentials = cloud.Credentials(org_id, api_token)
+        self.env = cloud.get_env_from_credentials(self.credentials)
+        if not self.env:
+            raise InvalidCredentialsError("Invalid credentials passed in.")
+        self.name = cloud.retrieve_org_metadata(
+            credentials=self.credentials, env=self.env
+        )["name"]
 
-    def register_device(self) -> Device:
+    def register_device(self, encryption: Optional[str] = None) -> Device:
         """
         Register a new device in this organization and return it.
         Returned Device will have an ID and provisioned key.
         """
         resp = cloud.register_device(
-            org_id=self.org_id,
-            api_token=self.api_token,
-            base_url=self.api_base_url,
+            credentials=self.credentials, env=self.env, encryption=encryption
         )
         # Currently, only registering a single device and taking the
         # first in the returned list
@@ -63,11 +55,10 @@ class Organization:
         Returned Device will have an ID and provisioned key.
         """
         resp = cloud.update_device(
-            org_id=self.org_id,
-            api_token=self.api_token,
+            credentials=self.credentials,
+            env=self.env,
             name=name,
             device_id=device_id,
-            base_url=self.api_base_url,
         )
         return Device(id=resp["id"], name=resp["name"])
 
@@ -79,9 +70,7 @@ class Organization:
             list[Device]
         """
 
-        payload = cloud.list_devices(
-            org_id=self.org_id, api_token=self.api_token, base_url=self.api_base_url
-        )
+        payload = cloud.list_devices(credentials=self.credentials, env=self.env)
         raw_list = payload["devices"]
 
         # Turn each JSON object into a Device
@@ -96,11 +85,10 @@ class Organization:
         or None if none exists.
         """
         resp = cloud.retrieve_packets(
-            org_id=self.org_id,
-            api_token=self.api_token,
+            credentials=self.credentials,
+            env=self.env,
             device_id=device.id,
             days=days,
-            base_url=self.api_base_url,
         )
         packets = []
         for packet in resp["packets"]:
@@ -108,9 +96,9 @@ class Organization:
                 DecryptedPacket(
                     timestamp=int(packet["device"]["timestamp"]),
                     device_id=packet["device"]["id"],
-                    device_name=packet["device"]["name"]
-                    if "name" in packet["device"]
-                    else "",
+                    device_name=(
+                        packet["device"]["name"] if "name" in packet["device"] else ""
+                    ),
                     location=Location(
                         lat=packet["location"]["latitude"],
                         lon=packet["location"]["longitude"],
@@ -126,8 +114,7 @@ class Organization:
 
     def ingest_packet(self, packet: EncryptedPacket) -> None:
         cloud.ingest_packet(
-            org_id=self.org_id,
-            api_token=self.api_token,
+            credentials=self.credentials,
+            env=self.env,
             packet=packet,
-            base_url=self.api_base_url,
         )

{pyhubblenetwork-0.0.2 → pyhubblenetwork-0.0.4}/src/hubblenetwork/packets.py

@@ -1,7 +1,6 @@
 # hubble/packets.py
 from __future__ import annotations
 from dataclasses import dataclass
-from datetime import datetime
 from typing import Optional, Dict