duoops 0.0.0

package/dist/lib/gitlab/provider.js

@@ -0,0 +1,72 @@
+import { createGitlabClient } from './client.js';
+/**
+ * GitLab implementation of PipelineProvider.
+ * Wraps @gitbeaker/rest and normalizes responses to our domain types.
+ */
+export class GitLabPipelineProvider {
+    #client;
+    constructor(client) {
+        this.#client = client ?? createGitlabClient();
+    }
+    async getJobTrace(projectId, jobId) {
+        const raw = await this.#client.Jobs.showLog(projectId, jobId);
+        const data = raw?.data ?? raw;
+        return typeof data === 'string' ? data : String(data ?? '');
+    }
+    async getPipeline(projectId, pipelineId) {
+        const raw = await this.#client.Pipelines.show(projectId, pipelineId);
+        const data = raw?.data ?? raw;
+        return normalizePipeline(data);
+    }
+    async listJobs(projectId, pipelineId) {
+        const raw = await this.#client.Jobs.all(projectId, { pipelineId });
+        const data = Array.isArray(raw) ? raw : raw.data ?? raw;
+        const arr = Array.isArray(data) ? data : [data];
+        return arr.map((item) => normalizeJob(item));
+    }
+    async listPipelines(projectId, options) {
+        const raw = await this.#client.Pipelines.all(projectId, {
+            perPage: options?.perPage ?? 20,
+            ref: options?.ref,
+            status: options?.status,
+        });
+        const data = Array.isArray(raw) ? raw : raw.data ?? raw;
+        const arr = Array.isArray(data) ? data : [data];
+        return arr.map((item) => normalizePipeline(item));
+    }
+}
+function normalizePipeline(raw) {
+    return {
+        createdAt: String(raw.created_at ?? ''),
+        duration: raw.duration === undefined || raw.duration === null
+            ? undefined
+            : Number(raw.duration),
+        id: Number(raw.id),
+        ref: String(raw.ref ?? ''),
+        sha: String(raw.sha ?? ''),
+        status: String(raw.status ?? ''),
+        updatedAt: raw.updated_at === undefined || raw.updated_at === null
+            ? undefined
+            : String(raw.updated_at),
+        webUrl: raw.web_url === undefined || raw.web_url === null
+            ? undefined
+            : String(raw.web_url),
+    };
+}
+function normalizeJob(raw) {
+    return {
+        createdAt: raw.created_at === undefined || raw.created_at === null
+            ? undefined
+            : String(raw.created_at),
+        duration: raw.duration === undefined || raw.duration === null
+            ? undefined
+            : Number(raw.duration),
+        finishedAt: raw.finished_at === undefined || raw.finished_at === null
+            ? undefined
+            : String(raw.finished_at),
+        id: Number(raw.id),
+        name: String(raw.name ?? ''),
+        stage: String(raw.stage ?? ''),
+        status: String(raw.status ?? ''),
+    };
+}

package/dist/lib/gitlab/types.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Shared types for pipeline and job data.
+ * Keeps the data layer independent of GitLab API specifics.
+ */
+export interface ListOptions {
+    perPage?: number;
+    ref?: string;
+    status?: string;
+}
+export interface Pipeline {
+    createdAt: string;
+    duration?: number;
+    id: number;
+    ref: string;
+    sha: string;
+    status: string;
+    updatedAt?: string;
+    webUrl?: string;
+}
+export interface Job {
+    createdAt?: string;
+    duration?: number;
+    finishedAt?: string;
+    id: number;
+    name: string;
+    stage: string;
+    status: string;
+}
+export interface PipelineProvider {
+    getJobTrace(projectId: string, jobId: number): Promise<string>;
+    getPipeline(projectId: string, pipelineId: number): Promise<Pipeline>;
+    listJobs(projectId: string, pipelineId: number): Promise<Job[]>;
+    listPipelines(projectId: string, options?: ListOptions): Promise<Pipeline[]>;
+}

package/dist/lib/gitlab/types.js

@@ -0,0 +1,5 @@
+/**
+ * Shared types for pipeline and job data.
+ * Keeps the data layer independent of GitLab API specifics.
+ */
+export {};

package/dist/lib/integrations/bigquery-sink.d.ts

@@ -0,0 +1,12 @@
+import { BudgetResult, EmissionsResult, JobInput } from '../measure/types.js';
+export interface JobPayloadOptions {
+    budget: BudgetResult;
+    jobInput: JobInput;
+    jsonReport: Record<string, unknown>;
+    result: EmissionsResult;
+}
+export interface BigQuerySinkConfig {
+    dataset: string;
+    table: string;
+}
+export declare const persistJobToBigQuery: (options: JobPayloadOptions, config: BigQuerySinkConfig) => Promise<void>;

package/dist/lib/integrations/bigquery-sink.js

@@ -0,0 +1,47 @@
+import { BigQuery } from '@google-cloud/bigquery';
+const getSafeEnv = (key) => process.env[key];
+const calculateAverage = (points) => {
+    if (points.length === 0)
+        return 0;
+    const sum = points.reduce((acc, p) => acc + p.value, 0);
+    return sum / points.length;
+};
+export const persistJobToBigQuery = async (options, config) => {
+    const bigquery = new BigQuery();
+    const dataset = bigquery.dataset(config.dataset);
+    const table = dataset.table(config.table);
+    // Use snake_case for BigQuery columns, but wrap in quotes if eslint complains, or disable rule
+    /* eslint-disable camelcase */
+    const row = {
+        carbon_intensity: options.result.carbonIntensity,
+        cpu_emissions_g: options.result.cpuEmissions,
+        cpu_utilization_avg: calculateAverage(options.jobInput.cpuTimeseries),
+        energy_kwh: options.result.cpuEnergyKwh + options.result.ramEnergyKwh,
+        gitlab_job_id: getSafeEnv('CI_JOB_ID') ? Number(getSafeEnv('CI_JOB_ID')) : undefined,
+        gitlab_job_name: getSafeEnv('CI_JOB_NAME'),
+        gitlab_pipeline_id: getSafeEnv('CI_PIPELINE_ID') ? Number(getSafeEnv('CI_PIPELINE_ID')) : undefined,
+        gitlab_project_id: getSafeEnv('CI_PROJECT_ID') ? Number(getSafeEnv('CI_PROJECT_ID')) : undefined,
+        ingested_at: BigQuery.timestamp(new Date()),
+        machine_type: options.jobInput.machineType,
+        payload_json: JSON.stringify(options.jsonReport),
+        provider: options.jobInput.provider,
+        pue: options.result.pue,
+        ram_emissions_g: options.result.ramEmissions,
+        ram_utilization_avg: calculateAverage(options.jobInput.ramUsedTimeseries),
+        region: options.jobInput.region,
+        runtime_seconds: Math.round(options.result.runtimeHours * 3600),
+        scope3_emissions_g: options.result.scope3Emissions,
+        total_emissions_g: options.result.totalEmissions,
+    };
+    /* eslint-enable camelcase */
+    try {
+        await table.insert(row);
+    }
+    catch (error) {
+        console.error('Failed to insert into BigQuery:', error);
+        // Surface error so the job knows the sink failed, but maybe don't exit(1) unless critical?
+        // gitgreen philosophy was usually best-effort for sinks.
+        // We'll throw so the user sees it.
+        throw error;
+    }
+};

package/dist/lib/logger.d.ts

@@ -0,0 +1,2 @@
+import pino from 'pino';
+export declare const logger: pino.Logger<never, boolean>;

package/dist/lib/logger.js

@@ -0,0 +1,11 @@
+import pino from 'pino';
+const isDev = process.env.NODE_ENV !== 'production';
+export const logger = pino({
+    level: process.env.LOG_LEVEL ?? 'info',
+    ...(isDev && {
+        transport: {
+            options: { colorize: true },
+            target: 'pino-pretty',
+        },
+    }),
+});

package/dist/lib/measure/bigquery-service.d.ts

@@ -0,0 +1,2 @@
+export declare function fetchCarbonMetrics(projectId: number | string, limit?: number): Promise<any[]>;
+export declare function fetchAvailableProjects(): Promise<any[]>;

package/dist/lib/measure/bigquery-service.js

@@ -0,0 +1,54 @@
+import { BigQuery } from '@google-cloud/bigquery';
+import { configManager } from '../config.js';
+export async function fetchCarbonMetrics(projectId, limit = 10) {
+    const config = configManager.get();
+    if (!config.measure?.bigqueryDataset || !config.measure?.bigqueryTable) {
+        throw new Error('BigQuery sink not configured. Run "duoops init" first.');
+    }
+    const bigquery = new BigQuery({
+        projectId: config.measure?.googleProjectId || process.env.GCP_PROJECT_ID,
+    });
+    // Ensure we are selecting relevant columns for charts
+    const query = `
+    SELECT 
+      ingested_at,
+      gitlab_job_id,
+      gitlab_project_id,
+      gitlab_job_name,
+      gitlab_user_name,
+      region,
+      machine_type,
+      total_emissions_g,
+      energy_kwh,
+      cpu_utilization_avg,
+      ram_utilization_avg,
+      runtime_seconds
+    FROM \`${config.measure.bigqueryDataset}.${config.measure.bigqueryTable}\`
+    WHERE gitlab_project_id = @projectId
+    ORDER BY ingested_at DESC
+    LIMIT @limit
+  `;
+    const [rows] = await bigquery.query({
+        params: { limit, projectId: Number(projectId) },
+        query,
+    });
+    return rows;
+}
+export async function fetchAvailableProjects() {
+    const config = configManager.get();
+    if (!config.measure?.bigqueryDataset || !config.measure?.bigqueryTable) {
+        throw new Error('BigQuery sink not configured. Run "duoops init" first.');
+    }
+    const bigquery = new BigQuery({
+        projectId: config.measure?.googleProjectId || process.env.GCP_PROJECT_ID,
+    });
+    // Get distinct project IDs that have data
+    const query = `
+    SELECT DISTINCT gitlab_project_id
+    FROM \`${config.measure.bigqueryDataset}.${config.measure.bigqueryTable}\`
+    ORDER BY gitlab_project_id
+  `;
+    const [rows] = await bigquery.query({ query });
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return rows.map((row) => row.gitlab_project_id);
+}

package/dist/lib/measure/carbon-calculator.d.ts

@@ -0,0 +1,13 @@
+import { IntensityProvider } from './intensity-provider.js';
+import { PowerProfileRepository } from './power-profile-repository.js';
+import { EmissionsResult, JobInput } from './types.js';
+import { ZoneMapper } from './zone-mapper.js';
+export declare class CarbonCalculator {
+    private readonly powerProfileRepository;
+    private readonly zoneMapper;
+    private readonly intensityProvider;
+    constructor(powerProfileRepository: PowerProfileRepository, zoneMapper: ZoneMapper, intensityProvider: IntensityProvider);
+    calculate(job: JobInput): Promise<EmissionsResult>;
+    private interpolatePower;
+    private parseTimestamp;
+}

package/dist/lib/measure/carbon-calculator.js

@@ -0,0 +1,125 @@
+import CubicSpline from 'cubic-spline';
+export class CarbonCalculator {
+    powerProfileRepository;
+    zoneMapper;
+    intensityProvider;
+    constructor(powerProfileRepository, zoneMapper, intensityProvider) {
+        this.powerProfileRepository = powerProfileRepository;
+        this.zoneMapper = zoneMapper;
+        this.intensityProvider = intensityProvider;
+    }
+    async calculate(job) {
+        const machineProfile = await this.powerProfileRepository.getMachineProfile(job.provider, job.machineType);
+        if (!machineProfile) {
+            throw new Error(`No machine profile found for ${job.machineType} on ${job.provider}`);
+        }
+        const cpuProfile = await this.powerProfileRepository.getCpuPowerProfile(job.provider, job.machineType);
+        if (!cpuProfile || cpuProfile.length === 0) {
+            throw new Error(`No CPU power profile for ${job.machineType}`);
+        }
+        const { pue, zone } = this.zoneMapper.resolve(job.provider, job.region);
+        const carbonIntensity = await this.intensityProvider.getCarbonIntensity(zone);
+        // Sort timeseries by timestamp
+        const cpuSorted = [...job.cpuTimeseries].sort((a, b) => this.parseTimestamp(a.timestamp) - this.parseTimestamp(b.timestamp));
+        const ramUsedSorted = [...job.ramUsedTimeseries].sort((a, b) => this.parseTimestamp(a.timestamp) - this.parseTimestamp(b.timestamp));
+        const DEFAULT_INTERVAL_SECONDS = 60;
+        // Integrate CPU energy over timeseries
+        let cpuEnergyKwh = 0;
+        for (let i = 0; i < cpuSorted.length; i++) {
+            const rawCpuValue = cpuSorted[i].value;
+            const cpuPercent = job.provider === 'aws'
+                ? (rawCpuValue <= 1 ? rawCpuValue * 100 : rawCpuValue)
+                : rawCpuValue * 100;
+            const powerWatts = this.interpolatePower(cpuProfile, cpuPercent);
+            // Calculate interval from timestamps, or use default interval for single point
+            let intervalSeconds;
+            if (cpuSorted.length === 1) {
+                intervalSeconds = DEFAULT_INTERVAL_SECONDS;
+            }
+            else if (i < cpuSorted.length - 1) {
+                intervalSeconds = this.parseTimestamp(cpuSorted[i + 1].timestamp) - this.parseTimestamp(cpuSorted[i].timestamp);
+            }
+            else {
+                // Last point: assume same interval as previous
+                intervalSeconds = this.parseTimestamp(cpuSorted[i].timestamp) - this.parseTimestamp(cpuSorted[i - 1].timestamp);
+            }
+            cpuEnergyKwh += (powerWatts / 1000) * (intervalSeconds / 3600);
+        }
+        // Integrate RAM energy over timeseries
+        let ramEnergyKwh = 0;
+        const RAM_WATTS_PER_GB = 0.5; // Standard estimation
+        for (let i = 0; i < ramUsedSorted.length; i++) {
+            // Calculate RAM power based on total RAM of the machine (static consumption) + dynamic? 
+            // Cloud Carbon Footprint methodology suggests ~0.392 Watts/GB for older DRAM, less for newer.
+            // GitGreen uses 0.5 Watts/GB as a conservative flat estimate for allocated memory.
+            // We'll stick to the GitGreen logic: Power = Total RAM GB * Watts/GB
+            // Note: GitGreen original code used ramUsedSorted values, but memory power is largely static based on allocation.
+            // However, looking at the original code: 
+            // const ramUsedGb = ramUsedBytes / (1024 * 1024 * 1024);
+            // const powerWatts = ramUsedGb * RAM_WATTS_PER_GB;
+            // This implies it calculates power based on *used* memory, not *total* memory. We will replicate that.
+            const ramUsedBytes = ramUsedSorted[i].value;
+            const ramUsedGb = ramUsedBytes / (1024 * 1024 * 1024);
+            const powerWatts = ramUsedGb * RAM_WATTS_PER_GB;
+            let intervalSeconds;
+            if (ramUsedSorted.length === 1) {
+                intervalSeconds = DEFAULT_INTERVAL_SECONDS;
+            }
+            else if (i < ramUsedSorted.length - 1) {
+                intervalSeconds = this.parseTimestamp(ramUsedSorted[i + 1].timestamp) - this.parseTimestamp(ramUsedSorted[i].timestamp);
+            }
+            else {
+                intervalSeconds = this.parseTimestamp(ramUsedSorted[i].timestamp) - this.parseTimestamp(ramUsedSorted[i - 1].timestamp);
+            }
+            ramEnergyKwh += (powerWatts / 1000) * (intervalSeconds / 3600);
+        }
+        // Calculate total runtime from timeseries
+        // Find the min start time across all series
+        const startTimes = [];
+        if (cpuSorted.length > 0)
+            startTimes.push(this.parseTimestamp(cpuSorted[0].timestamp));
+        if (ramUsedSorted.length > 0)
+            startTimes.push(this.parseTimestamp(ramUsedSorted[0].timestamp));
+        const endTimes = [];
+        if (cpuSorted.length > 0)
+            endTimes.push(this.parseTimestamp(cpuSorted.at(-1).timestamp));
+        if (ramUsedSorted.length > 0)
+            endTimes.push(this.parseTimestamp(ramUsedSorted.at(-1).timestamp));
+        const firstTs = startTimes.length > 0 ? Math.min(...startTimes) : 0;
+        const lastTs = endTimes.length > 0 ? Math.max(...endTimes) : 0;
+        const durationSeconds = (lastTs > firstTs) ? (lastTs - firstTs) : DEFAULT_INTERVAL_SECONDS;
+        const runtimeHours = durationSeconds / 3600;
+        // Calculate emissions
+        const cpuEmissions = cpuEnergyKwh * pue * carbonIntensity;
+        const ramEmissions = ramEnergyKwh * pue * carbonIntensity;
+        const scope3Emissions = (machineProfile.scope3EmissionsHourly || 0) * runtimeHours;
+        const totalEmissions = cpuEmissions + ramEmissions + scope3Emissions;
+        return {
+            carbonIntensity,
+            cpuEmissions,
+            cpuEnergyKwh,
+            machineType: job.machineType,
+            provider: job.provider,
+            pue,
+            ramEmissions,
+            ramEnergyKwh,
+            region: job.region,
+            runtimeHours,
+            scope3Emissions,
+            totalEmissions,
+        };
+    }
+    interpolatePower(profile, utilization) {
+        const sorted = [...profile].sort((a, b) => a.percentage - b.percentage);
+        const exact = sorted.find((point) => point.percentage === utilization);
+        if (exact)
+            return exact.watts;
+        const percentages = sorted.map((p) => p.percentage);
+        const watts = sorted.map((p) => p.watts);
+        const spline = new CubicSpline(percentages, watts);
+        return spline.at(utilization);
+    }
+    parseTimestamp(ts) {
+        return new Date(ts).getTime() / 1000;
+    }
+}

package/dist/lib/measure/cli-utils.d.ts

@@ -0,0 +1,2 @@
+import { TimeseriesPoint } from './types.js';
+export declare const parseTimeseriesFile: (filePath: string) => TimeseriesPoint[];

package/dist/lib/measure/cli-utils.js

@@ -0,0 +1,107 @@
+import fs from 'node:fs';
+const toIsoTimestamp = (input) => {
+    if (input instanceof Date) {
+        return Number.isNaN(input.getTime()) ? undefined : input.toISOString();
+    }
+    if (typeof input === 'string' || typeof input === 'number') {
+        const date = new Date(input);
+        return Number.isNaN(date.getTime()) ? undefined : date.toISOString();
+    }
+    return undefined;
+};
+const toNumericValue = (input) => {
+    if (typeof input === 'number') {
+        return Number.isFinite(input) ? input : undefined;
+    }
+    if (typeof input === 'string') {
+        const parsed = Number(input);
+        return Number.isFinite(parsed) ? parsed : undefined;
+    }
+    return undefined;
+};
+const parseGcpTimeseries = (raw) => {
+    const points = [];
+    const response = raw;
+    const { timeSeries } = response;
+    if (!Array.isArray(timeSeries))
+        return points;
+    for (const ts of timeSeries) {
+        const series = ts;
+        if (!Array.isArray(series.points))
+            continue;
+        for (const point of series.points) {
+            const timestamp = toIsoTimestamp(point.interval?.endTime || point.interval?.startTime);
+            const value = point.value?.doubleValue === undefined
+                ? toNumericValue(point.value?.int64Value)
+                : toNumericValue(point.value.doubleValue);
+            if (timestamp && value !== undefined)
+                points.push({ timestamp, value });
+        }
+    }
+    return points;
+};
+const parseCloudWatchMetricData = (raw) => {
+    const data = raw.MetricDataResults || raw.metricDataResults;
+    const results = Array.isArray(data) ? data : [];
+    if (results.length === 0)
+        return [];
+    const first = results[0];
+    const timestamps = Array.isArray(first?.Timestamps) ? first.Timestamps : [];
+    const values = Array.isArray(first?.Values) ? first.Values : [];
+    const len = Math.min(timestamps.length, values.length);
+    const points = [];
+    for (let i = 0; i < len; i++) {
+        const timestamp = toIsoTimestamp(timestamps[i]);
+        const value = toNumericValue(values[i]);
+        if (timestamp && value !== undefined) {
+            points.push({ timestamp, value });
+        }
+    }
+    return points;
+};
+const parseLegacyTimeseries = (entries) => {
+    const points = [];
+    for (const entry of entries) {
+        const timestamp = toIsoTimestamp((entry.timestamp ?? entry.Timestamp));
+        const value = toNumericValue((entry.value ?? entry.Value));
+        if (timestamp && value !== undefined) {
+            points.push({ timestamp, value });
+        }
+    }
+    return points;
+};
+const convertCloudWatchDatapoints = (entries) => {
+    const points = [];
+    for (const entry of entries) {
+        const timestamp = toIsoTimestamp(entry.Timestamp);
+        const value = toNumericValue((entry.Average ?? entry.Maximum ?? entry.Minimum ?? entry.Sum));
+        if (timestamp && value !== undefined) {
+            points.push({ timestamp, value });
+        }
+    }
+    return points;
+};
+export const parseTimeseriesFile = (filePath) => {
+    const raw = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    const gcp = parseGcpTimeseries(raw);
+    if (gcp.length > 0)
+        return gcp;
+    const cw = parseCloudWatchMetricData(raw);
+    if (cw.length > 0)
+        return cw;
+    if (Array.isArray(raw)) {
+        const cwFromArray = parseCloudWatchMetricData({ MetricDataResults: raw });
+        if (cwFromArray.length > 0)
+            return cwFromArray;
+        const legacy = parseLegacyTimeseries(raw);
+        if (legacy.length > 0)
+            return legacy;
+    }
+    const datapointResponse = raw;
+    if (Array.isArray(datapointResponse.Datapoints)) {
+        const datapointSeries = convertCloudWatchDatapoints(datapointResponse.Datapoints);
+        if (datapointSeries.length > 0)
+            return datapointSeries;
+    }
+    return [];
+};

package/dist/lib/measure/intensity-provider.d.ts

@@ -0,0 +1,6 @@
+export declare class IntensityProvider {
+    private readonly baseUrl;
+    private readonly apiKey;
+    constructor(baseUrl?: string, apiKey?: string);
+    getCarbonIntensity(zone: string): Promise<number>;
+}

package/dist/lib/measure/intensity-provider.js

@@ -0,0 +1,34 @@
+import axios from 'axios';
+export class IntensityProvider {
+    baseUrl;
+    apiKey;
+    constructor(baseUrl = 'https://api.electricitymap.org/v3', apiKey = process.env.ELECTRICITY_MAPS_API_KEY || '') {
+        this.baseUrl = baseUrl;
+        this.apiKey = apiKey;
+    }
+    async getCarbonIntensity(zone) {
+        if (!this.apiKey) {
+            // Return global average as fallback if no API key
+            // Approx 475 gCO2/kWh global average, or use region-specific fallbacks if we had them
+            // For now, let's warn and return a static average to avoid breaking
+            console.warn('Warning: ELECTRICITY_MAPS_API_KEY not set. Using global average fallback (475 gCO2/kWh).');
+            return 475;
+        }
+        const url = `${this.baseUrl.replace(/\/$/, '')}/carbon-intensity/latest`;
+        try {
+            const response = await axios.get(url, {
+                headers: { 'auth-token': this.apiKey },
+                params: { zone },
+            });
+            const intensity = response.data.carbonIntensity;
+            if (typeof intensity !== 'number' || intensity < 0) {
+                throw new Error(`Invalid carbon intensity response for ${zone}`);
+            }
+            return intensity;
+        }
+        catch (error) {
+            console.warn(`Warning: Failed to fetch carbon intensity for ${zone}. Using global average fallback (475 gCO2/kWh). Error: ${error instanceof Error ? error.message : String(error)}`);
+            return 475;
+        }
+    }
+}

package/dist/lib/measure/power-profile-repository.d.ts

@@ -0,0 +1,19 @@
+import { CloudProvider, MachineProfile, PowerPoint } from './types.js';
+export declare class PowerProfileRepository {
+    private readonly dataDir;
+    private awsMachines;
+    private cpuPhysicalSpecs;
+    private cpuProfiles;
+    private gcpMachines;
+    constructor(dataDir: string);
+    getCpuPowerProfile(provider: CloudProvider, machineType: string): Promise<null | PowerPoint[]>;
+    getMachineProfile(provider: CloudProvider, machineType: string): Promise<MachineProfile | null>;
+    listMachines(provider: CloudProvider): string[];
+    private findPhysicalSpec;
+    private loadCpuPhysicalSpecs;
+    private loadCpuProfiles;
+    private loadJsonFile;
+    private loadMachineData;
+    private normalizeNumber;
+    private normalizePowerPoints;
+}