earthscope-sdk 0.2.0__py3-none-any.whl → 1.0.0__py3-none-any.whl

earthscope_sdk/config/settings.py

@@ -0,0 +1,295 @@
+from contextlib import suppress
+from functools import cached_property
+from typing import Annotated, Any, Type
+
+from pydantic import Field, TypeAdapter, ValidationError, field_validator
+from pydantic_settings import (
+    BaseSettings,
+    InitSettingsSource,
+    PydanticBaseSettingsSource,
+    SettingsConfigDict,
+    TomlConfigSettingsSource,
+)
+
+from earthscope_sdk.config._bootstrap import BootstrapEnvironmentSettingsSource
+from earthscope_sdk.config._compat import LegacyEarthScopeCLISettingsSource
+from earthscope_sdk.config._util import deep_merge, get_config_dir, slugify
+from earthscope_sdk.config.error import ProfileDoesNotExistError
+from earthscope_sdk.config.models import SdkBaseSettings, Tokens
+
+_BOOTSTRAP_ENV_VAR = "ES_BOOTSTRAP_SETTINGS"
+"""Environment variable for bootstrapping the SDK"""
+
+_DEFAULT_PROFILE = "default"
+"""Default profile name"""
+
+_LOCAL_APP_DIR = get_config_dir(app_name="earthscope")
+"""Local SDK application directory"""
+
+
+def _get_config_toml_path():
+    """
+    Local SDK configuration file
+    """
+    return _LOCAL_APP_DIR / "config.toml"
+
+
+def _get_profile_dir(profile_name: str):
+    """
+    Retrieve the local SDK directory for the named profile
+    """
+    return _LOCAL_APP_DIR / slugify(profile_name)
+
+
+def _get_profile_tokens_file(profile_name: str):
+    """
+    Retrieve the local SDK tokens file for the named profile
+    """
+    profile_dir = _get_profile_dir(profile_name)
+    return profile_dir / "tokens.json"
+
+
+class _SdkGlobalSettings(BaseSettings):
+    """
+    EarthScope SDK global settings; not for direct use.
+
+    This class only loads settings from config.toml.
+    """
+
+    defaults: Annotated[
+        SdkBaseSettings,
+        Field(validation_alias="default"),
+    ] = {}
+
+    profile_settings_by_name: Annotated[
+        dict[str, SdkBaseSettings],
+        Field(validation_alias="profile"),
+    ] = {}
+
+    model_config = SettingsConfigDict(
+        extra="ignore",
+        frozen=True,
+        nested_model_default_partial_update=True,
+        populate_by_name=True,
+    )
+
+    def get_merged(self, profile_name: str):
+        """
+        Get profile-specific settings merged with defaults
+        """
+        try:
+            p = self.profile_settings_by_name[profile_name]
+        except KeyError:
+            raise ProfileDoesNotExistError(f"Profile '{profile_name}' does not exist")
+
+        defaults = self.defaults.model_dump(
+            exclude_none=True,
+            exclude_unset=True,
+            exclude_defaults=True,
+        )
+        profile_specific = p.model_dump(
+            exclude_defaults=True,  # defer to top-level field defaults
+            exclude_unset=True,  # only keep explicitly set fields
+            exclude_none=True,
+        )
+
+        # order is imporant; profile-specific args override default args
+        return deep_merge(defaults, profile_specific, profile_name=profile_name)
+
+    @field_validator("profile_settings_by_name", mode="before")
+    @classmethod
+    def ensure_default_profile(cls, v: dict[str, dict]):
+        """
+        Ensure the default profile exists
+        """
+        v.setdefault(_DEFAULT_PROFILE, {})
+        return v
+
+    @classmethod
+    def settings_customise_sources(cls, settings_cls: Type[BaseSettings], **_):
+        """
+        Override the loading chain to exclusively check ~/.earthscope/config.toml
+        """
+        # we get the file path dynamically to allow monkeypatching for tests
+        toml_path = _get_config_toml_path()
+        toml_settings = TomlConfigSettingsSource(settings_cls, toml_path)
+
+        return (toml_settings,)
+
+
+class _GlobalSettingsSource(PydanticBaseSettingsSource):
+    """
+    This SettingsSource facilitates falling back to settings configured in config.toml
+    and state in tokens.json when loading the configuration chain in SdkSettings.
+
+    Consolidates merged profile state with state loaded from a profile's tokens.json file
+    """
+
+    def __init__(self, settings_cls, *keys: str):
+        super().__init__(settings_cls)
+        self._keys = keys
+
+    def __call__(self):
+        # Extract profile
+        profile_name = _DEFAULT_PROFILE
+        for k in self._keys:
+            with suppress(KeyError):
+                profile_name = self._current_state[k]
+                break
+
+        # Load global merged settings
+        merged = _SdkGlobalSettings().get_merged(profile_name)
+
+        # Load from tokens.json
+        tokens_json = {}
+        with suppress(FileNotFoundError, ValidationError):
+            raw = _get_profile_tokens_file(profile_name).read_bytes()
+            tokens = Tokens.model_validate_json(raw)
+            tokens_json = tokens.model_dump(
+                exclude_none=True,
+                exclude_unset=True,
+                exclude_defaults=True,
+            )
+
+        # order is imporant; init args override tokens.json args
+        return deep_merge({"oauth2": tokens_json}, merged)
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}()"
+
+    def get_field_value(self, *args, **kwargs): ...  # unused abstract method
+
+
+class _InitSettingsWithoutDefaultSource(InitSettingsSource):
+    """
+    InitSettingsSource behavior but excludes default values & unset fields
+    to allow values from lower-precedence settings sources to bubble up.
+    """
+
+    def __init__(self, other: InitSettingsSource):
+        super().__init__(
+            other.settings_cls,
+            other.init_kwargs,
+            other.nested_model_default_partial_update,
+        )
+        self.dict_adapter = TypeAdapter(dict[str, Any])
+
+    def __call__(self) -> dict[str, Any]:
+        return self.dict_adapter.dump_python(
+            self.init_kwargs,
+            exclude_defaults=True,
+            exclude_unset=True,
+        )
+
+
+class SdkSettings(SdkBaseSettings, BaseSettings):
+    """
+    EarthScope SDK settings.
+
+    Use `profile_name` to utilize a named profile from `~/.earthscope/config.toml`
+
+    Settings loading chain (order of precedence):
+    1. arguments passed to constructor
+    2. environment variables
+    3. dotenv variables
+    4. ~/.earthscope/config.toml
+    """
+
+    profile_name: Annotated[
+        str,
+        Field(validation_alias="es_profile"),
+        # NOTE: aliases do not include the env_prefix by default; add it explicitly
+    ]
+
+    model_config = SettingsConfigDict(
+        env_nested_delimiter="__",
+        env_prefix="ES_",
+        extra="ignore",
+        frozen=True,
+        nested_model_default_partial_update=True,
+        populate_by_name=True,
+    )
+
+    @cached_property
+    def profile_dir(self):
+        """
+        The path to the local SDK directory for the named profile
+        """
+        return _get_profile_dir(self.profile_name)
+
+    @cached_property
+    def tokens_file(self):
+        """
+        The path to the tokens file for the named profile
+        """
+        return _get_profile_tokens_file(self.profile_name)
+
+    def delete_tokens(self, missing_ok=False):
+        """
+        Delete tokens from this named profile's state
+
+        Args:
+            missing_ok: Whether or not to throw an error if the file does not exist
+
+        Returns:
+            this auth flow
+        """
+        self.tokens_file.unlink(missing_ok=missing_ok)
+        return self
+
+    def write_tokens(self, tokens: Tokens):
+        """
+        Write tokens to this named profile's state
+
+        Args:
+            tokens: the tokens to persist in local storage
+        """
+        body = tokens.model_dump_json(
+            include=Tokens.model_fields.keys(),
+            indent=2,
+            context="plaintext",  # write SecretStr's actual values in plaintext
+            exclude_none=True,
+        )
+        self.tokens_file.parent.mkdir(parents=True, exist_ok=True)
+        self.tokens_file.write_text(body)
+
+    @classmethod
+    def settings_customise_sources(
+        cls,
+        settings_cls: Type[BaseSettings],
+        init_settings: InitSettingsSource,
+        env_settings: PydanticBaseSettingsSource,
+        dotenv_settings: PydanticBaseSettingsSource,
+        **_,
+    ):
+        """
+        Override the loading chain to additionally check ~/.earthscope/config.toml
+        """
+
+        # Init settings, but without defaults & unset values
+        init_settings = _InitSettingsWithoutDefaultSource(init_settings)
+
+        # Check for all the ways profile name may be supplied
+        alias = SdkSettings.model_fields["profile_name"].validation_alias
+        global_settings = _GlobalSettingsSource(settings_cls, "profile_name", alias)
+
+        # Check for bootstrapping configuration
+        bootstrap_settings = BootstrapEnvironmentSettingsSource(
+            settings_cls,
+            _BOOTSTRAP_ENV_VAR,
+        )
+
+        # Compatibility with earthscope-cli v0.x.x state:
+        # If we find this file, we only care about the access and refresh tokens
+        keep_keys = {"access_token", "refresh_token"}
+        legacy_settings = LegacyEarthScopeCLISettingsSource(settings_cls, *keep_keys)
+
+        # Order of precedence
+        return (
+            init_settings,
+            env_settings,
+            dotenv_settings,
+            global_settings,
+            legacy_settings,
+            bootstrap_settings,
+        )

earthscope_sdk/model/secret.py

@@ -0,0 +1,29 @@
+from typing import Annotated
+
+from pydantic import PlainSerializer, SerializationInfo
+from pydantic import SecretStr as _SecretStr
+
+
+def _dump_secret_plaintext(secret: _SecretStr, info: SerializationInfo):
+    """
+    A special field serializer to dump the actual secret value.
+
+    Only writes secret in plaintext when `info.context == "plaintext".
+
+    See [Pydantic docs](https://docs.pydantic.dev/latest/concepts/serialization/#serialization-context)
+    """
+
+    if info.context == "plaintext":
+        return secret.get_secret_value()
+
+    return str(secret)
+
+
+SecretStr = Annotated[
+    _SecretStr,
+    PlainSerializer(
+        _dump_secret_plaintext,
+        return_type=str,
+        when_used="json-unless-none",
+    ),
+]

{earthscope_sdk-0.2.0.dist-info → earthscope_sdk-1.0.0.dist-info}/METADATA

@@ -1,9 +1,9 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: earthscope-sdk
-Version: 0.2.0
+Version: 1.0.0
 Summary: An SDK for EarthScope API
-Author-email: EarthScope <software@unavco.org>
-License: Apache License
+Author-email: EarthScope <data-help@earthscope.org>
+License:                                  Apache License
                                    Version 2.0, January 2004
                                 http://www.apache.org/licenses/
         
@@ -210,138 +210,162 @@ Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.7
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: pyjwt (>=2.4.0)
-Requires-Dist: requests (>=2.27.1)
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: pydantic-settings[toml]>=2.8.0
+Requires-Dist: stamina>=24.3.0
 Provides-Extra: dev
-Requires-Dist: black ; extra == 'dev'
-Requires-Dist: bumpver ; extra == 'dev'
-Requires-Dist: build ; extra == 'dev'
-Requires-Dist: pytest ; extra == 'dev'
-Requires-Dist: twine ; extra == 'dev'
-Requires-Dist: pip-tools ; extra == 'dev'
+Requires-Dist: bumpver; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Requires-Dist: pip-tools; extra == "dev"
+Requires-Dist: pre-commit; extra == "dev"
+Requires-Dist: pytest-httpx; extra == "dev"
+Requires-Dist: pytest-asyncio; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Dynamic: license-file
 
 # EarthScope SDK
 
-An SDK for authenticating with the EarthScope API
+An SDK for interacting with EarthScope's APIs
 
 ## Getting Started
 
-### USAGE
+### Installation
 
-1. **(Optional) Suggest setting up and activating a python virtual environment so as not to clutter your system python**
+Install from PyPI
 
-   ```shell
-   python3 -m venv venv
-   . venv/bin/activate
+```shell
+pip install earthscope-sdk
+```
+
+### Usage
+
+For detailed usage info and examples, visit [our SDK docs](https://docs.earthscope.org/projects/SDK).
+
+```py
+# Import and create a client
+from earthscope_sdk import EarthScopeClient
+
+client = EarthScopeClient()
+
+# Example client method usage; retrieve your user profile
+profile = client.user.get_profile()
+print(profile)
+
+# Client cleanup
+client.close()
+```
+
+#### Async Usage
+
+There is also an `async` client available
+
+```py
+import asyncio
+from earthscope_sdk import AsyncEarthScopeClient
+
+async def main():
+    client = AsyncEarthScopeClient()
+
+    profile = await client.user.get_profile()
+    print(profile)
+
+    await client.close()
+
+asyncio.run(main())
+```
+
+#### Context Managers
+
+Client classes can also be used as context managers to ensure resource cleanup occurs.
+
+```py
+# sync
+with EarthScopeClient() as client:
+   client.user.get_profile()
+
+# async
+async with AsyncEarthScopeClient() as client:
+   await client.user.get_profile()
+```
+
+## Bootstrapping Authentication
+
+There are a few methods of bootstrapping authentication for the SDK.
+
+Once refreshable credentials are available to the SDK, it will transparently handle access token refresh on your behalf.
+
+### Same host
+
+If you have the [EarthScope CLI](https://docs.earthscope.org/projects/CLI) installed on the same host that is running your application which uses `earthscope-sdk`, you can simply log in using the CLI. The CLI shares credentials and configuration with this SDK (when running on the same host).
+
+Running `es login` will open your browser and prompt you to log in to your EarthScope account.
+
+```console
+$ es login
+Attempting to automatically open the SSO authorization page in your default browser.
+If the browser does not open or you wish to use a different device to authorize this request, open the following URL:
+
+https://login.earthscope.org/activate?user_code=ABCD-EFGH
+
+Successful login! Access token expires at 2024-12-27 18:50:37+00:00
+```
+
+Now when you run your application, `earthscope-sdk` will find your credentials.
+
+### Different hosts
+
+Sometimes your workload runs on different hosts than your main workstation and you cannot feasibly "log in" on all of them. For example, maybe you're running many containers in your workload.
+
+You can still use the [EarthScope CLI](https://docs.earthscope.org/projects/CLI) to facilitate auth for applications on other machines.
+
+1. Use the CLI on your primary workstation [as described above](#same-host) to log in.
+
+1. Use the CLI to retrieve your refresh token.
+
+   ```console
+   $ es user get-refresh-token
+   <your-refresh-token>
    ```
 
-2. **Install earthscope-sdk**
+   > **Note: your refresh token should be treated as a secret credential. Anyone with a valid refresh token can use it to continually retrieve new access tokens on your behalf**.
+
+1. Pass this refresh token to all the hosts needing auth for the `earthscope-sdk`. For example, inject the `ES_OAUTH2__REFRESH_TOKEN` environment variable on these hosts.
 
    ```shell
-   pip install earthscope-sdk
+   export ES_OAUTH2__REFRESH_TOKEN="<your-refresh-token>"
    ```
-   For developers:
-   ```bash
-   pip -e install earthscope-sdk[dev]
-   ```
-   
-3. **Create/Use required subclasses**
-   \
-   To use the **Device Authorization Flow** you will need to create a subclass of the DeviceCodeFlow class. Similarly, to use
-   the **Machine-to-Machine Client Credentials Flow** you will need to create a subclass of the ClientCredientialFlow class.
-
-   Simple subclasses exist for your use that you can import and use which will allow for locally loading and saving access tokens:
-   *DeviceCodeFlowSimple* and *ClientCredentialsFlowSimple* (see below for examples on useage)
-   <br/><br/>
-   Creating your own subclass:
-    \
-   Implementing the following methods in the subclass is required:
-   * `load_tokens` should implement the ability to load saved tokens
-   * `save_tokens` should implement the ability to save tokens locally
-   
-   additionally for DeviceCodeFlow only:
-   * `prompt_user` should provide the user with the SSO authorization uri
-
-   You will need to instantiate your subclass with the following instance attributes:
-
-   For DeviceCodeFlow:
-   * `audience`, `domain`, `client_id`, and `scope`.
-
-   For ClientCredentialsFlow:
-   * `audience`, `client_credentials`, and `domain`.
-   
-      where client_credentials contains the machine-to-machine `client_id` and `client_secret`.
-
-   These values are all obtained from [Auth0](https://manage.auth0.com/).
-   <br/><br/>
-4. **Use the SDK**
-   \
-   You can now use the subclasses to define actions such as logging in/out, retrieving or refreshing access tokens, etc...
-   \
-   **NOTE: Never share your access token or refresh tokens**
-   
-   Additionally, once the subclasses have been instantiated, you can pass your access token as a parameter to retrieve
-   your user/anonymous user information using the earthscope_sdk.user.user *get_user* and *lookup_anon* functions.
-  
- 
-5. **Example useages:**
-   \
-   Note: To see an example of an application using this SDK (and creating custom subclass), check out the [EarthScope CLI Repository](https://gitlab.com/earthscope/public/earthscope-cli).
-   <br/><br/>
-   How to use the existing simple subclass for device code flow:
-   \
-   *simple example python code*:
-    ```
-    import requests
-    from pathlib import Path
-     
-    from earthscope_sdk.auth.device_code_flow import DeviceCodeFlowSimple
-    from earthscope_sdk.auth.auth_flow import NoTokensError
-    
-   # choose where you want the token saved - the default file name is sso_tokens.json
-   # if you want to keep the default name, set the path to a directory. Include a file name to rename. 
-   token_path = "/Users/my_user/token_dir"
-   
-   url = "https://data-idm.unavco.org/path/to/data_file"
-   # example: "https://data-idm.unavco.org/archive/gnss/rinex/obs/2022/298/ar272980.22d.Z"
-   
-    # instantiate the device code flow subclass
-    device_flow = DeviceCodeFlowSimple(Path(token_path))
-    try:
-        # get access token from local path
-        device_flow.get_access_token_refresh_if_necessary()
-    except NoTokensError:
-        # if no token was found locally, do the device code flow
-        device_flow.do_flow()
-    token = device_flow.access_token
-     
-    # request a file and provide the token in the Authorization header
-   file_name = Path(url).name
-   directory_to_save_file = Path.cwd() # where you want to save the downloaded file 
-   
-    r = requests.get(url, headers={"authorization": f"Bearer {token}"})
-    if r.status_code == requests.codes.ok:
-        # save the file
-        with open(Path(directory_to_save_file / file_name), 'wb') as f:
-            for data in r:
-                f.write(data)
-    else:
-        #problem occured
-        print(f"failure: {r.status_code}, {r.reason}")
-     ```
-   
-   Instantiate the subclass and set the token_path where you want to load/save the token. 
-   If you provide only a directory, the file will be saved as sso_tokens.json. 
-   We hard-code this variable in this simple example, but we recommend setting this path as an environment variable and 
-   reading the environment varibale in your code.
-
-
-   the **get_access_token_refresh_if_necessary** method will retrieve the token and refresh the token if it is expired. 
-   If there is no token, then the **do_flow** method will begin the device code flow and once you complete the flow, 
-   the token will be saved at the token_path. You can use the **requests** library to download the file you want 
-   (or files in a loop) and pass in the access token in the Authorization header. 
-   
-Learn more about [data access methods](https://www.unavco.org/data/gps-gnss/data-access-methods/data-access-methods.html).
+
+## SDK Settings
+
+SDK Settings are provided via the following methods (in order of precedence):
+
+1. initialization arguments (e.g. via class constructors)
+1. environment variables
+1. dotenv file (.env) variables
+1. user's home directory settings files
+   1. `~/.earthscope/config.toml` (for configuration)
+   1. `~/.earthscope/<profile-name>/tokens.json` (for tokens)
+1. legacy EarthScope CLI v0 credentials
+1. default settings
+
+SDK configuration is managed by the `SdkSettings` class, and calling the constructor performs this settings loading chain.
+
+```py
+from earthscope_sdk.config.settings import SdkSettings
+
+settings = SdkSettings()  # loads settings via loading chain
+```
+
+For more details on SDK configuration, including what options are available, see [our settings docs](docs/settings.md).
+
+## Contributing
+
+For details on contributing to the EarthScope SDK, please see:
+
+- [design docs](docs/design.md)
+- [development docs](docs/development.md)

earthscope_sdk-1.0.0.dist-info/RECORD

@@ -0,0 +1,30 @@
+earthscope_sdk/__init__.py,sha256=8qd3PtsEHX-Z-goRaemVsakbxNxhyhOjHDKrom-E3CA,154
+earthscope_sdk/auth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+earthscope_sdk/auth/auth_flow.py,sha256=gxJmCr5TAhMEss7RskYFCv6-D3A5h0Zw2ejeLJJ_9aI,10352
+earthscope_sdk/auth/client_credentials_flow.py,sha256=GAvskuoEd6qHe-BtfGwYQisMedmSkDhagy4aRPVPri4,2494
+earthscope_sdk/auth/device_code_flow.py,sha256=p53pgRQraToFwONPBj3O3DHAa4x4rE6rvygo_Bbj5_U,8394
+earthscope_sdk/auth/error.py,sha256=eC33Bw1HaBEJE7-eI2krtE__5PxStc3EyiYO12v0kVw,693
+earthscope_sdk/client/__init__.py,sha256=JotTr5oTiiOsUc0RTg82EVCUSg_-u80Qu_R0-crCXkY,139
+earthscope_sdk/client/_client.py,sha256=ai7WdsTOYglA6bLkT-Wntvxlke6nSaGHwqrtg5PEy80,833
+earthscope_sdk/client/user/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+earthscope_sdk/client/user/_base.py,sha256=8dn4pfQMwVDpF0E6dl6P6HJuNVvozUzfgUGefnPXMnw,1076
+earthscope_sdk/client/user/_service.py,sha256=wRktOZF5GXajXXxij3Nkule6wvuWOV0vn4QsA1IXVHc,3063
+earthscope_sdk/client/user/models.py,sha256=drZAMwOYC1NVCzBZQhNL-pPTB28SURKfoZF8HdjlIj8,1214
+earthscope_sdk/common/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+earthscope_sdk/common/_sync_runner.py,sha256=h_A2pSEjZCLj7ov50M6cWHVoX6eXVmGzz5nX0MwLWDY,4131
+earthscope_sdk/common/client.py,sha256=g5ZTNhFm33H68J9pWD5fDu760Yd5cBdfQmsbU3t8D_4,2156
+earthscope_sdk/common/context.py,sha256=vrCB_Ez-98Ir7c0GrCe-g7DuRCgc9vPaoRWFYf5q8Ko,5138
+earthscope_sdk/common/service.py,sha256=SCUZVJA3jFaEPeFrOf0v9osf2UpqldhlFmirOYWJjxM,1506
+earthscope_sdk/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+earthscope_sdk/config/_bootstrap.py,sha256=BvDSRccvFPFRnLS4MlE7OMLGYEgxY7znxFZ6AYgxvOE,1243
+earthscope_sdk/config/_compat.py,sha256=P3F5y_Kf5zp9m9uOhl1Bp3ke6expxq4Sm9AeVaBbAHk,4610
+earthscope_sdk/config/_util.py,sha256=RZ6zvKrvjUkO7i69s7AVoIDhamRg4x71CAZLnucr9QM,1249
+earthscope_sdk/config/error.py,sha256=jh25q-b317lAvp32WwQw0zdYoV-MxZtg-n5FgZOMymI,95
+earthscope_sdk/config/models.py,sha256=CqCLF2m7cGcypsQxvrXK7BCsyv6QB3a9XmaqxYeMfaM,8684
+earthscope_sdk/config/settings.py,sha256=kGsoqAgoUS2xrI0rvdqbLEsI2M0Mpbm73oEDLpJG4_Q,9205
+earthscope_sdk/model/secret.py,sha256=QTyWCqXvf9ZYWaVVQcGzdt3rGtyU3sx13AlzkNE3gaU,731
+earthscope_sdk-1.0.0.dist-info/licenses/LICENSE,sha256=E_MrVXxRaMQNpvZhsDuz_J9N_ux7dlL_WpYSsE391HU,11349
+earthscope_sdk-1.0.0.dist-info/METADATA,sha256=9bnVpBEpd7_5IalOpORWP9cXUZVMH8ygTCK3tA-9lpA,18122
+earthscope_sdk-1.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+earthscope_sdk-1.0.0.dist-info/top_level.txt,sha256=zTtIT9yN3JPJF7TqmTzqQcAvZZe4pAm907DLoGa5T_E,15
+earthscope_sdk-1.0.0.dist-info/RECORD,,

{earthscope_sdk-0.2.0.dist-info → earthscope_sdk-1.0.0.dist-info}/WHEEL

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