@nasa-terra/components 0.0.178 → 0.0.179

package/README.md

@@ -46,11 +46,11 @@ Install the `uv` package manager (https://github.com/astral-sh/uv), it's a light
 
 Then run the following:
 
--   `uv venv` - create a virtual environment (only have to do this the first time)
--   `source .venv/bin/activate` - activate it
--   `uv pip install -e ".[dev]"` - install dependencies (see pyproject.toml)
--   open base.py and point dependencies to localhost (do not commit these changes) TODO: fix this so we auto-detect local development
--   `npm run start:python` - spins up Jupyter lab and should open the browser for you
+- `uv venv` - create a virtual environment (only have to do this the first time)
+- `source .venv/bin/activate` - activate it
+- `uv pip install -e ".[dev]"` - install dependencies (see pyproject.toml)
+- open base.py and point dependencies to localhost (do not commit these changes) TODO: fix this so we auto-detect local development
+- `npm run start:python` - spins up Jupyter lab and should open the browser for you
 
 For an example of how to use the components in a Jupyter Notebook, open the `/notebooks/playground.ipynb` notebook in Jupyter Lab.
 

package/cdn/apis/__tests__/fixtures/all-services.d.ts

@@ -0,0 +1,80 @@
+export declare const allServices: {
+    conceptId: string;
+    shortName: string;
+    summary: {
+        subsetting: {
+            bbox: boolean;
+            dimension: boolean;
+            shape: boolean;
+            temporal: boolean;
+            variable: boolean;
+        };
+        reprojection: {
+            supported: boolean;
+            supportedProjections: never[];
+            interpolationMethods: never[];
+        };
+        averaging: {
+            time: boolean;
+            area: boolean;
+        };
+        concatenation: boolean;
+        outputFormats: string[];
+    };
+    services: ({
+        name: string;
+        href: string;
+        capabilities: {
+            subsetting: {
+                temporal: boolean;
+                variable: boolean;
+                multiple_variable: boolean;
+                bbox?: undefined;
+                dimension?: undefined;
+                shape?: undefined;
+            };
+            outputFormats: string[];
+            averaging?: undefined;
+        };
+    } | {
+        name: string;
+        href: string;
+        capabilities: {
+            subsetting: {
+                temporal: boolean;
+                bbox: boolean;
+                dimension: boolean;
+                shape: boolean;
+                variable: boolean;
+                multiple_variable?: undefined;
+            };
+            outputFormats: string[];
+            averaging?: undefined;
+        };
+    } | {
+        name: string;
+        href: string;
+        capabilities: {
+            subsetting: {
+                bbox: boolean;
+                temporal: boolean;
+                variable: boolean;
+                multiple_variable: boolean;
+                dimension?: undefined;
+                shape?: undefined;
+            };
+            averaging: {
+                time: boolean;
+                area: boolean;
+            };
+            outputFormats: string[];
+        };
+    })[];
+    variables: {
+        conceptId: string;
+        name: string;
+        href: string;
+    }[];
+    configuredOutputFormats: never[];
+    capabilitiesVersion: string;
+};

package/cdn/apis/__tests__/fixtures/giovanni-and-netcdf-services.d.ts

@@ -0,0 +1,80 @@
+export declare const giovanniAndNetcdf: {
+    conceptId: string;
+    shortName: string;
+    summary: {
+        subsetting: {
+            bbox: boolean;
+            dimension: boolean;
+            shape: boolean;
+            temporal: boolean;
+            variable: boolean;
+        };
+        reprojection: {
+            supported: boolean;
+            supportedProjections: never[];
+            interpolationMethods: never[];
+        };
+        averaging: {
+            time: boolean;
+            area: boolean;
+        };
+        concatenation: boolean;
+        outputFormats: string[];
+    };
+    services: ({
+        name: string;
+        href: string;
+        capabilities: {
+            subsetting: {
+                temporal: boolean;
+                variable: boolean;
+                multiple_variable: boolean;
+                bbox?: undefined;
+                dimension?: undefined;
+                shape?: undefined;
+            };
+            outputFormats: string[];
+            averaging?: undefined;
+        };
+    } | {
+        name: string;
+        href: string;
+        capabilities: {
+            subsetting: {
+                temporal: boolean;
+                bbox: boolean;
+                dimension: boolean;
+                shape: boolean;
+                variable: boolean;
+                multiple_variable?: undefined;
+            };
+            outputFormats: string[];
+            averaging?: undefined;
+        };
+    } | {
+        name: string;
+        href: string;
+        capabilities: {
+            subsetting: {
+                bbox: boolean;
+                temporal: boolean;
+                variable: boolean;
+                multiple_variable: boolean;
+                dimension?: undefined;
+                shape?: undefined;
+            };
+            averaging: {
+                time: boolean;
+                area: boolean;
+            };
+            outputFormats: string[];
+        };
+    })[];
+    variables: {
+        conceptId: string;
+        name: string;
+        href: string;
+    }[];
+    configuredOutputFormats: never[];
+    capabilitiesVersion: string;
+};

package/cdn/apis/__tests__/fixtures/only-giovanni-services.d.ts

@@ -0,0 +1,61 @@
+export declare const onlyGiovanniServices: {
+    conceptId: string;
+    shortName: string;
+    summary: {
+        subsetting: {
+            bbox: boolean;
+            dimension: boolean;
+            shape: boolean;
+            temporal: boolean;
+            variable: boolean;
+        };
+        reprojection: {
+            supported: boolean;
+            supportedProjections: never[];
+            interpolationMethods: never[];
+        };
+        averaging: {
+            time: boolean;
+            area: boolean;
+        };
+        concatenation: boolean;
+        outputFormats: string[];
+    };
+    services: ({
+        name: string;
+        href: string;
+        capabilities: {
+            subsetting: {
+                temporal: boolean;
+                variable: boolean;
+                multiple_variable: boolean;
+                bbox?: undefined;
+            };
+            outputFormats: string[];
+            averaging?: undefined;
+        };
+    } | {
+        name: string;
+        href: string;
+        capabilities: {
+            subsetting: {
+                bbox: boolean;
+                temporal: boolean;
+                variable: boolean;
+                multiple_variable: boolean;
+            };
+            averaging: {
+                time: boolean;
+                area: boolean;
+            };
+            outputFormats: string[];
+        };
+    })[];
+    variables: {
+        conceptId: string;
+        name: string;
+        href: string;
+    }[];
+    configuredOutputFormats: never[];
+    capabilitiesVersion: string;
+};

package/cdn/apis/__tests__/fixtures/only-netcdf-service.d.ts

@@ -0,0 +1,45 @@
+export declare const onlyNetcdf: {
+    conceptId: string;
+    shortName: string;
+    summary: {
+        subsetting: {
+            bbox: boolean;
+            dimension: boolean;
+            shape: boolean;
+            temporal: boolean;
+            variable: boolean;
+        };
+        reprojection: {
+            supported: boolean;
+            supportedProjections: never[];
+            interpolationMethods: never[];
+        };
+        averaging: {
+            time: boolean;
+            area: boolean;
+        };
+        concatenation: boolean;
+        outputFormats: string[];
+    };
+    services: {
+        name: string;
+        href: string;
+        capabilities: {
+            subsetting: {
+                temporal: boolean;
+                bbox: boolean;
+                variable: boolean;
+                shape: boolean;
+                dimension: boolean;
+            };
+            outputFormats: string[];
+        };
+    }[];
+    variables: {
+        conceptId: string;
+        name: string;
+        href: string;
+    }[];
+    configuredOutputFormats: never[];
+    capabilitiesVersion: string;
+};

package/cdn/apis/cmr.api.d.ts

@@ -0,0 +1,61 @@
+import { type RequestOptions } from '../lib/api.client.js';
+import type { MapEventDetail } from '../components/map/type.js';
+import type { UmmC } from './types/cmr/umm-c.js';
+import type { UmmVar } from './types/cmr/umm-var.js';
+import type { UmmG } from './types/cmr/umm-g.js';
+export interface UmmResponse<T> {
+    hits: number;
+    items: Array<UmmResult<T>>;
+}
+export interface UmmResult<T> {
+    meta: UmmMeta;
+    umm: T;
+}
+/**
+ * meta information from the CMR search endpoint
+ * there are quite a few more fields available but we're only using what we need
+ */
+export interface UmmMeta {
+    'concept-id': string;
+    'native-id': string;
+    'provider-id': string;
+    'granule-count'?: number;
+}
+export type SearchParams = {
+    pageSize?: number;
+    pageNum?: number;
+    offset?: number;
+    sortBy?: string;
+    sortDirection?: 'asc' | 'desc' | string;
+    search?: string;
+    searchFields?: string[];
+};
+export type SearchGranulesParams = SearchParams & {
+    collectionEntryId?: string;
+    collectionConceptId?: string;
+    startDate?: string;
+    endDate?: string;
+    location?: MapEventDetail | null;
+    cloudCover?: {
+        min?: number;
+        max?: number;
+    };
+};
+export type SearchVariablesParams = SearchParams & {
+    collectionConceptId?: string;
+};
+declare class CmrApi {
+    #private;
+    getCollection(shortName: string, version: string, options?: RequestOptions): Promise<UmmResult<UmmC>>;
+    getCollectionByEntryId(collectionEntryId?: string, options?: RequestOptions): Promise<UmmResult<UmmC>>;
+    searchVariables(searchParams: SearchVariablesParams, options?: RequestOptions): Promise<UmmResponse<UmmVar>>;
+    getSamplingOfGranules(collectionEntryId: string, options?: RequestOptions): Promise<{
+        minDate?: string;
+        maxDate?: string;
+        isSubDaily: boolean;
+        hasGranules: boolean;
+    }>;
+    searchGranules(params: SearchGranulesParams, options?: RequestOptions): Promise<UmmResponse<UmmG>>;
+}
+declare const cmrApi: CmrApi;
+export default cmrApi;

package/cdn/apis/gesdisc.api.d.ts

@@ -0,0 +1,17 @@
+import { type RequestOptions } from '../lib/api.client.js';
+export interface GesDiscCollection {
+    services: {
+        subset?: Array<{
+            dimensions?: Array<{
+                value: string;
+                label: string;
+            }>;
+        }>;
+    };
+}
+declare class GesDiscApi {
+    #private;
+    getCollectionByEntryId(collectionEntryId?: string, options?: RequestOptions): Promise<GesDiscCollection>;
+}
+declare const gesDiscApi: GesDiscApi;
+export default gesDiscApi;

package/cdn/apis/giovanni.api.d.ts

@@ -0,0 +1,11 @@
+import { type RequestOptions } from '../lib/api.client.js';
+declare class GiovanniApi {
+    #private;
+    /**
+     * Fetches the list of configured variables from the Giovanni API.
+     * Giovanni does not support all variables, so this endpoint provides a list of variables that are supported for subsetting.
+     */
+    getConfiguredVariables(options?: RequestOptions): Promise<string[]>;
+}
+declare const giovanniApi: GiovanniApi;
+export default giovanniApi;

package/cdn/apis/harmony.api.d.ts

@@ -0,0 +1,149 @@
+import { type RequestOptions } from '../lib/api.client.js';
+import type { HarmonyRequest } from '../lib/harmony/harmony.request.js';
+import type { SubsetJobStatus, SearchOptions } from '../data-services/types.js';
+export declare const Environments: {
+    readonly PROD: "PROD";
+    readonly UAT: "UAT";
+};
+export type Environments = (typeof Environments)[keyof typeof Environments];
+export declare const HARMONY_URLS: {
+    PROD: string;
+    UAT: string;
+    ANONYMOUS_ACCESS: string;
+};
+export declare const CLOUD_GIOVANNI_URLS: {
+    PROD: string;
+    UAT: string;
+};
+export declare enum Status {
+    FETCHING = "fetching",
+    PREVIEWING = "previewing",
+    RUNNING = "running",
+    SUCCESSFUL = "successful",
+    FAILED = "failed",
+    CANCELED = "canceled",
+    PAUSED = "paused",
+    RUNNING_WITH_ERRORS = "running_with_errors",
+    COMPLETE_WITH_ERRORS = "complete_with_errors"
+}
+export declare const FINAL_STATUSES: Set<Status>;
+export declare const OUTPUT_FORMATS: {
+    readonly 'application/x-netcdf4': "X-NETCDF-4";
+    readonly 'application/netcdf4': "NETCDF-4";
+    readonly 'application/x-netcdf4;profile=opendap_url': "X-NETCDF-4 (OPeNDAP URL)";
+    readonly 'application/netcdf': "NETCDF";
+    readonly 'application/x-hdf': "X-HDF";
+    readonly 'image/tiff': "GEOTIFF";
+    readonly 'image/gif': "GIF";
+    readonly 'image/png': "PNG";
+    readonly 'image/jpeg': "JPEG";
+    readonly 'text/csv': "CSV";
+    readonly 'application/shapefile+zip': "Shapefile+zip";
+    readonly 'application/x-zarr': "ZARR";
+};
+export type OutputFormats = (typeof OUTPUT_FORMATS)[keyof typeof OUTPUT_FORMATS];
+export interface HarmonyCapabilitiesResponse {
+    conceptId: string;
+    shortName: string;
+    summary: HarmonyCapabilitiesSummary;
+    services: Service[];
+    variables: Variable[];
+    capabilitiesVersion: string;
+    configuredOutputFormats: ConfiguredOutputFormat[];
+}
+export interface HarmonyCapabilitiesSummary {
+    subsetting: {
+        bbox: boolean;
+        dimension: boolean;
+        shape: boolean;
+        temporal: boolean;
+        variable: boolean;
+    };
+    reprojection: {
+        supported: boolean;
+        supportedProjections: string[];
+        interpolationMethods: string[];
+    };
+    averaging: {
+        time: boolean;
+        area: boolean;
+    };
+    concatenation: boolean;
+    outputFormats: string[];
+}
+export type ConfiguredOutputFormat = {
+    key: string;
+    label: string;
+    description: string;
+    isGiovanniFormat?: boolean;
+};
+export interface Service {
+    name: string;
+    href: string;
+    capabilities: Capabilities;
+}
+export interface Capabilities {
+    subsetting: Subsetting;
+    outputFormats: string[];
+    averaging?: Averaging;
+}
+export interface Averaging {
+    time: boolean;
+    area: boolean;
+}
+export interface Subsetting {
+    temporal: boolean;
+    variable: boolean;
+    multiple_variable?: boolean;
+    bbox?: boolean;
+    shape?: boolean;
+}
+export interface Variable {
+    conceptId: string;
+    name: string;
+    href: string;
+}
+/**
+ * Harmony REST API wrapper for OGC-based subset job operations.
+ * Makes direct HTTP calls to the Harmony service endpoints.
+ */
+declare class HarmonyApi {
+    #private;
+    /**
+     * Returns collection capabilities including available services, output formats, subsetting options, etc.
+     * from the Harmony /capabilities endpoint
+     */
+    getCollectionCapabilities(conceptId?: string, options?: RequestOptions): Promise<HarmonyCapabilitiesResponse>;
+    /**
+     * Create a subset job by sending a GET request to the Harmony OGC API endpoint.
+     * The harmonyRequest.requestUrl contains the full URL with all subset parameters.
+     */
+    createJob(harmonyRequest: HarmonyRequest, options?: SearchOptions): Promise<SubsetJobStatus>;
+    /**
+     * Get the current status of an existing subset job.
+     * Intended for polling until the job reaches a final state.
+     */
+    getJobStatus(jobId: string, options?: SearchOptions): Promise<SubsetJobStatus>;
+    /**
+     * Given a jobId for a running job, send a cancellation request to the Harmony API.
+     * Returns the updated job status after cancellation.
+     */
+    cancelJob(jobId: string, options?: SearchOptions): Promise<SubsetJobStatus>;
+    /**
+     * When a Harmony job finishes, it provides URLs for downloading the results. This method can be used to fetch the results from those URLs, which may require authentication if the data is not public.
+     */
+    fetchUrl(url: string, options?: SearchOptions): Promise<unknown>;
+    /**
+     * Extracts the variable concept ID from the variable's href and adds it as a property on the variable object.
+     */
+    addConceptIdToVariables(variables: Variable[]): Variable[];
+    /**
+     * Processes the Harmony capabilities response to generate a list of output format options with user-friendly labels and descriptions.
+     * If Giovanni is the only service available, only return Giovanni-specific formats.
+     * If Giovanni is present with other services, include both Giovanni and non-Giovanni formats, avoiding duplicates.
+     * If Giovanni is not present, return only non-Giovanni formats.
+     */
+    getOutputFormatOptions(capabilities: HarmonyCapabilitiesResponse): ConfiguredOutputFormat[];
+}
+export declare const harmonyApi: HarmonyApi;
+export {};