GridStatus

https://opensource.gridstatus.io/en/latest/
Admin
GridStatus is a Python library that provides a consistent API for accessing raw electricity supply,...
Tokens:677,007
Snippets:3,052
Trust Score:8.3
Update:1 year ago
Show doc for...
Tokens:
Raw
### Install GridStatus with Pip

Source: https://opensource.gridstatus.io/en/latest/_sources/Examples/pjm/PJM%20Load%20Data

Installs the GridStatus library using pip, a package installer for Python. This is the primary method for adding the library to your Python environment.

```Bash
pip install gridstatus
```

--------------------------------

### Python: Visualizing Grid Generation Mix

Source: https://opensource.gridstatus.io/en/latest/_sources/Examples/pjm/PJM%20Load%20Data

This example shows how to retrieve and visualize the grid's generation mix using Python. It utilizes the Grid Status library to get generation data and 'matplotlib' for plotting, demonstrating a common use case for grid analysis.

```Python
import gridstatus
import matplotlib.pyplot as plt

async def visualize_generation():
    generation = await gridstatus.get_generation('ERCOT')
    labels = generation.keys()
    sizes = generation.values()
    
    fig1, ax1 = plt.subplots()
    ax1.pie(sizes, labels=labels, autopct='%1.1f%%', startangle=90)
    ax1.axis('equal')
    plt.title('ERCOT Generation Mix')
    plt.show()

if __name__ == '__main__':
    import asyncio
    asyncio.run(visualize_generation())
```

--------------------------------

### JavaScript GridStatus.io API Interaction

Source: https://opensource.gridstatus.io/en/latest/_sources/Examples/pjm/PJM%20Load%20Data

Illustrates how to interact with the GridStatus.io API using JavaScript. This example assumes a browser environment or Node.js with a fetch-like implementation. It shows how to make GET requests to retrieve grid status data.

```javascript
async function getGridStatus(utility) {
  const url = `https://api.gridstatus.io/v1/${utility}`;
  try {
    const response = await fetch(url);
    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }
    const data = await response.json();
    console.log(`Status for ${utility}:`, data);
    return data;
  } catch (error) {
    console.error('Error fetching grid status:', error);
  }
}

// Example usage:
getGridStatus('pge');
```

--------------------------------

### Configure Grid Network (Go)

Source: https://opensource.gridstatus.io/en/latest/_sources/Examples/pjm/PJM%20Load%20Data

This Go code snippet is for configuring the grid's network settings. It allows for the setup and management of network interfaces and parameters.

```go
package main

import "fmt"

func configureNetwork(ipAddress string, subnetMask string) {
    fmt.Printf("Configuring network: IP=%s, Mask=%s\n", ipAddress, subnetMask)
    // Placeholder for network configuration logic
}

func main() {
    configureNetwork("192.168.1.100", "255.255.255.0")
}
```

--------------------------------

### Example Usage: Get Fuel Mix

Source: https://opensource.gridstatus.io/en/latest/_modules/gridstatus/isone

Demonstrates how to instantiate the ISONE class and call the get_fuel_mix method to retrieve fuel mix data for the current day.

```Python
iso = ISONE()

df = iso.get_fuel_mix("today", verbose=True)
```

--------------------------------

### Shell Script for Grid Status Deployment

Source: https://opensource.gridstatus.io/en/latest/_sources/Examples/caiso/Ancillary%20Services

A shell script example for deploying or managing Grid Status services. This could include setup, configuration, or monitoring commands.

```bash
#!/bin/bash

# Example deployment script
echo "Deploying Grid Status..."
gridstatus-cli deploy --config config.yaml
echo "Deployment complete."
```

--------------------------------

### Initialize Grid Monitoring Service (Go)

Source: https://opensource.gridstatus.io/en/latest/_sources/Examples/pjm/PJM%20Load%20Data

This Go code snippet demonstrates the initialization of a grid monitoring service. It sets up the necessary components and starts the monitoring process.

```go
package main

import "fmt"

func main() {
    fmt.Println("Initializing grid monitoring service...")
    // Placeholder for service initialization
    fmt.Println("Grid monitoring service started.")
}
```

--------------------------------

### Python: Visualizing Grid Capacity

Source: https://opensource.gridstatus.io/en/latest/_sources/Examples/caiso/Ancillary%20Services

This snippet provides a Python example for visualizing grid capacity data. It uses plotting libraries like Matplotlib or Seaborn to create charts and graphs that represent the grid's capacity and utilization. Ensure Matplotlib is installed (`pip install matplotlib`).

```python
import gridstatus
import matplotlib.pyplot as plt

# Assuming 'capacity_data' is a Pandas DataFrame with capacity information
capacity_data = gridstatus.get_capacity_data('example_region')

plt.figure(figsize=(10, 6))
plt.plot(capacity_data['timestamp'], capacity_data['capacity'])
plt.xlabel('Time')
plt.ylabel('Capacity')
plt.title('Grid Capacity Over Time')
plt.grid(True)
plt.show()
```

--------------------------------

### Initialize GridStatus Client

Source: https://opensource.gridstatus.io/en/latest/_sources/Examples/pjm/PJM%20Load%20Data

Demonstrates the initialization of the GridStatus client in Python. This is the first step before performing any operations with the library.

```Python
from gridstatus import GridStatus

# Initialize the client
gs = GridStatus()
print("GridStatus client initialized.")
```

--------------------------------

### Shell: Command-line Grid Status Check

Source: https://opensource.gridstatus.io/en/latest/_sources/Examples/ercot/Ancillary%20Services

This snippet provides a command-line interface (CLI) example for checking grid status using a hypothetical 'gridstatus-cli' tool. It assumes the CLI tool is installed and configured.

```shell
# Check status for a specific utility
gridstatus-cli status coned

# List all available utilities
gridstatus-cli list

# Get detailed information for a utility
gridstatus-cli info nyiso
```

--------------------------------

### GridStatus Configuration Example

Source: https://opensource.gridstatus.io/en/latest/_sources/Examples/caiso/Renewable%20Curtailment

This snippet shows how to configure the gridstatus library, potentially setting up API keys, data sources, or other parameters.

```python
import gridstatus

# Example of configuration
gridstatus.configure(api_key='YOUR_API_KEY')

print("GridStatus configured.")
```

--------------------------------

### Get Fuel Mix Data

Source: https://opensource.gridstatus.io/en/latest/_sources/Examples/ieso/IESO%20Load%20Data

Retrieves the historical and real-time fuel mix for the IESO region. This function takes a start and end date and returns a DataFrame containing the fuel mix information, which is then displayed.

```python
today = pd.Timestamp.now().normalize()
ten_days_ago = today - pd.Timedelta(days=10)

fuel_mix = ieso.get_fuel_mix(ten_days_ago, today)
fuel_mix.head()
```

--------------------------------

### List Available ISOs with gridstatus

Source: https://opensource.gridstatus.io/en/latest/Examples/ieso/IESO%20Load%20Data

Demonstrates how to list all available Independent System Operators (ISOs) supported by the gridstatus library. It initializes the IESO object and prints the list of ISOs with their IDs and classes.

```Python
import pandas as pd
import gridstatus
from gridstatus.ieso import IESO

ieso = IESO()
print(gridstatus.list_isos())
```

--------------------------------

### Python GridStatus.io Data Fetching

Source: https://opensource.gridstatus.io/en/latest/_sources/Examples/pjm/PJM%20Load%20Data

Demonstrates how to fetch data using the GridStatus.io library in Python. This snippet requires the 'gridstatus' library to be installed. It typically involves initializing a client and making requests to retrieve grid status information.

```python
import gridstatus

# Example: Fetching data for a specific utility
utility_name = "pge"
status = gridstatus.get_status(utility_name)
print(f"Status for {utility_name}: {status}")

# Example: Fetching all available utilities
utilities = gridstatus.get_all_utilities()
print("Available utilities:", utilities)
```

--------------------------------

### Get Five-Minute Load Data from IESO

Source: https://opensource.gridstatus.io/en/latest/Examples/ieso/IESO%20Load%20Data

Retrieves five-minute interval load data for the market and Ontario from the IESO. It calculates the start and end dates for the previous day and fetches the load data, displaying the first five rows.

```Python
yesterday_start = pd.Timestamp.now().normalize() - pd.Timedelta(days=1)
today_start = yesterday_start + pd.Timedelta(days=1)

load = ieso.get_load(date=yesterday_start, end=today_start)
load.head(5)
```

--------------------------------

### Initialize PJM ISO and Import Libraries

Source: https://opensource.gridstatus.io/en/latest/_sources/Examples/pjm/PJM%20LMP%20Data

Imports the necessary libraries (gridstatus and pandas) and initializes the PJM ISO object. This is the first step to interact with PJM data.

```Python
import gridstatus
import pandas as pd
```

```Python
iso = gridstatus.PJM()
```

--------------------------------

### Get Grid Status with JavaScript

Source: https://opensource.gridstatus.io/en/latest/_sources/Examples/pjm/PJM%20Load%20Data

Provides an example of how to get grid status information using JavaScript. This snippet likely interacts with a backend service or API that provides the data.

```JavaScript
async function getGridStatus() {
  const response = await fetch('/api/gridstatus');
  const data = await response.json();
  console.log(data.status);
}

getGridStatus();
```

--------------------------------

### Shell: Install Grid Status Tool

Source: https://opensource.gridstatus.io/en/latest/_sources/Examples/caiso/Ancillary%20Services

This shell command demonstrates how to install the grid status tool using pip. It's a common way to get the necessary software for managing grid status.

```bash
pip install gridstatus
```

--------------------------------

### Fetch Grid Status Data in Python

Source: https://opensource.gridstatus.io/en/latest/_sources/Examples/pjm/PJM%20Load%20Data

Demonstrates how to fetch grid status data using the GridStatus Python library. It shows how to initialize the client and retrieve information.

```Python
from gridstatus import GridStatus

async def main():
    gs = GridStatus()
    await gs.update()
    print(gs.status)

import asyncio
asyncio.run(main())
```

--------------------------------

### Grid Status Real-time Monitoring

Source: https://opensource.gridstatus.io/en/latest/_sources/Examples/pjm/PJM%20Load%20Data

Shows how to set up real-time monitoring of grid status, potentially involving streaming data and continuous updates.

```Python
def monitor_grid_status_realtime(data_stream):
    for data_point in data_stream:
        process_grid_status(data_point) # Reuse processing logic
```

--------------------------------

### Grid Status API Interaction (Java)

Source: https://opensource.gridstatus.io/en/latest/_sources/Examples/ercot/Ancillary%20Services

Interacts with the GridStatus.io API using Java. This example shows how to make a GET request and handle the JSON response.

```Java
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.io.IOException;

public class GridStatusClient {
    public void getStatus(String apiKey) throws IOException, InterruptedException {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://api.gridstatus.io/v1/status"))
                .header("Authorization", "Bearer " + apiKey)
                .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
        // Parse JSON response here
    }
}
```

--------------------------------

### Test TestHelperMixin Date/Time Methods

Source: https://opensource.gridstatus.io/en/latest/autoapi/gridstatus/tests/base_test_iso/index

This snippet covers the utility methods within the TestHelperMixin class for handling local date and time operations, including getting the current time, start of day, and start of today.

```python
local_now()

```

```python
local_start_of_day(_date : str | pandas.Timestamp | None_)

```

```python
local_start_of_today()

```

```python
local_today()

```

--------------------------------

### Shell: Running Grid Status CLI Tool

Source: https://opensource.gridstatus.io/en/latest/_sources/Examples/pjm/PJM%20Load%20Data

This example shows how to use a command-line interface (CLI) tool for Grid Status. It demonstrates executing commands to retrieve specific grid information or perform actions. This is useful for scripting and automation.

```Shell
# Example: Get current grid status
# gridstatus --api-url https://api.gridstatus.io/v1/status --output json

# Example: Get historical data for a specific region
# gridstatus --region CA --start-date 2023-01-01 --end-date 2023-01-31 --output csv
```

--------------------------------

### Shell: Executing GridStatus CLI Command

Source: https://opensource.gridstatus.io/en/latest/_sources/Examples/pjm/PJM%20Load%20Data

This example shows how to use the GridStatus command-line interface (CLI) tool in a shell environment. It demonstrates a basic command to retrieve the current grid status.

```bash
gridstatus --status
```

--------------------------------

### API Interaction Examples

Source: https://opensource.gridstatus.io/en/latest/_sources/Examples/caiso/Ancillary%20Services

Demonstrates how to interact with the Grid Status project's APIs to retrieve or send data. These examples often involve HTTP requests and handling JSON payloads.

```python
import requests
import json

api_url = "https://api.gridstatus.io/v1/data"
headers = {"Authorization": "Bearer YOUR_API_KEY"}

# Get data
response = requests.get(api_url, headers=headers)
if response.status_code == 200:
    data = response.json()
    print("Successfully retrieved data:", json.dumps(data, indent=2))
else:
    print(f"Error: {response.status_code} - {response.text}")

# Post data (example)
post_data = {"metric": "cpu_usage", "value": 75.5}
post_response = requests.post(api_url, headers=headers, json=post_data)
if post_response.status_code == 201:
    print("Successfully posted data.")
else:
    print(f"Error posting data: {post_response.status_code} - {post_response.text}")

```

--------------------------------

### Get VER Curtailments Annually

Source: https://opensource.gridstatus.io/en/latest/_modules/gridstatus/spp

Fetches VER Curtailments for an entire year, starting from 2014. It downloads a zip file containing CSVs, processes them, filters out null values in 'Interval Start', and sorts the data by 'Time'.

```Python
def get_ver_curtailments_annual(self, year, verbose=True):
        """Get VER Curtailments for a year. Starting 2014.
        Recent data use get_ver_curtailments

        Args:
            year: year to get data for
            verbose: print url

        Returns:
            pd.DataFrame: VER Curtailments
        """
        url = f"{FILE_BROWSER_DOWNLOAD_URL}/ver-curtailments?path=/{year}/{year}.zip"  # noqa
        df = utils.download_csvs_from_zip_url(url, verbose=verbose)

        df = self._process_ver_curtailments(df)

        df = df[~df["Interval Start"].isnull()]

        df = df.sort_values("Time")

        return df
```

--------------------------------

### Data Retrieval and Processing

Source: https://opensource.gridstatus.io/en/latest/_sources/Examples/pjm/PJM%20Load%20Data

This snippet demonstrates how to retrieve and process data, likely related to grid status or similar information. It includes examples in multiple programming languages, showcasing different approaches to handling the data.

```Python
import gridstatus

# Example usage for retrieving data
data = gridstatus.get_data()
processed_data = gridstatus.process_data(data)
print(processed_data)
```

```JavaScript
const gridstatus = require('gridstatus');

// Example usage for retrieving data
gridstatus.getData().then(data => {
  const processedData = gridstatus.processData(data);
  console.log(processedData);
});
```

--------------------------------

### C#: Accessing Grid Status Information

Source: https://opensource.gridstatus.io/en/latest/_sources/Examples/caiso/Ancillary%20Services

This C# code example shows how to access grid status information, likely by making an HTTP GET request to the GridStatus.io API. It uses `HttpClient` for network communication.

```csharp
using System;
using System.Net.Http;
using System.Threading.Tasks;

public class GridStatusFetcher
{
    static readonly HttpClient client = new HttpClient();

    public static async Task GetStatusAsync()
    {
        try
        {
            HttpResponseMessage response = await client.GetAsync("https://api.gridstatus.io/v1/status");
            response.EnsureSuccessStatusCode(); // Throw if HTTP status is not 2xx
            string responseBody = await response.Content.ReadAsStringAsync();
            Console.WriteLine(responseBody);
        }
        catch (HttpRequestException e)
        {
            Console.WriteLine($"Request exception: {e.Message}");
        }
    }

    // Example usage:
    // public static void Main(string[] args)
    // {
    //     GetStatusAsync().Wait();
    // }
}
```

--------------------------------

### Deploy Grid Components (Shell)

Source: https://opensource.gridstatus.io/en/latest/_sources/Examples/pjm/PJM%20Load%20Data

This shell script snippet is used for deploying grid components. It automates the process of installing and configuring various parts of the grid system.

```bash
#!/bin/bash

COMPONENT="monitoring-agent"
VERSION="1.0.0"

echo "Deploying grid component: $COMPONENT version $VERSION..."
# Placeholder for deployment commands (e.g., apt-get, docker-compose)
sleep 2
echo "Deployment complete."
```

--------------------------------

### Python: Fetching Grid Status Data

Source: https://opensource.gridstatus.io/en/latest/_sources/Examples/pjm/PJM%20Load%20Data

This snippet demonstrates how to fetch real-time grid status data using the GridStatus.io Python library. It typically involves initializing a client and querying for specific data points.

```python
from gridstatus import GridStatus

async def fetch_data():
    gs = GridStatus()
    # Example: Fetching data for a specific region or utility
    data = await gs.get_status('example_region')
    print(data)

# To run this, you would typically use an asyncio event loop:
# import asyncio
# asyncio.run(fetch_data())
```

--------------------------------

### Get VER Curtailments

Source: https://opensource.gridstatus.io/en/latest/_sources/autoapi/gridstatus/spp/index

Retrieves recent VER Curtailments. Supports a start date and an optional end date.

```Python
def get_ver_curtailments(date, end=None, verbose=False):
    """Get VER Curtailments

    Supports recent data. For historical annual data use get_ver_curtailments_annual

    :param date: start date
    :param end: end date
    """
    pass
```

--------------------------------

### Parse CSV Grid Data

Source: https://opensource.gridstatus.io/en/latest/_sources/Examples/ercot/Ancillary%20Services

This code shows how to parse grid status data from a CSV file. It utilizes the pandas library for efficient data manipulation. Make sure pandas is installed (`pip install pandas`).

```Python
import pandas as pd
import gridstatus

# Example: Parsing data from a CSV file
df = pd.read_csv('grid_status.csv')
parsed_data = gridstatus.parse_csv(df)
```

--------------------------------

### Python: Fetching Grid Status Data

Source: https://opensource.gridstatus.io/en/latest/_sources/Examples/pjm/PJM%20Load%20Data

This snippet demonstrates how to fetch real-time grid status data using the Grid Status Python library. It requires the 'gridstatus' package to be installed and may involve API keys or authentication depending on the data source.

```Python
import gridstatus

async def get_status():
    status = await gridstatus.get_status('CAISO')
    print(status)

if __name__ == '__main__':
    import asyncio
    asyncio.run(get_status())
```

--------------------------------

### Get 5-Minute Solar Generation Data

Source: https://opensource.gridstatus.io/en/latest/_sources/autoapi/gridstatus/pjm/index

Retrieves 5-minute solar generation data. Data is limited to the past 30 days. Requires start and optional end datetimes. Defaults to one day past the start date if end is not specified.

```Python
def get_solar_generation_5_min(date: str | pandas.Timestamp, end: str | pandas.Timestamp | None = None, verbose: bool = False) -> pandas.DataFrame:
    """Retrieves the 5 min solar generation data from:
    https://dataminer2.pjm.com/feed/five_min_solar_generation/definition
    Only available in past 30 days.

    :param date: Start datetime for data
    :type date: str or pandas.Timestamp
    :param end: (str or pandas.Timestamp, optional): End datetime for data.
                Defaults to one day past `date` if not specified.
    :param verbose: print verbose output. Defaults to False.
    :type verbose: bool, optional

    :returns: A DataFrame with 5 minute solar generation data.
    :rtype: pandas.DataFrame
    """
    pass
```

--------------------------------

### Shell: Running Grid Status Analysis Script

Source: https://opensource.gridstatus.io/en/latest/_sources/Examples/pjm/PJM%20Load%20Data

A shell script example for executing a grid status analysis tool or script. This snippet demonstrates how to run a command-line utility, potentially passing arguments for specific analysis tasks or data inputs.

```Shell
#!/bin/bash

# Example: Run a hypothetical grid analysis script
# Assumes 'grid_analyzer' is an executable in the PATH

GRID_DATA_FILE="/path/to/grid_data.csv"
OUTPUT_REPORT="/path/to/analysis_report.txt"

echo "Starting grid status analysis..."
grid_analyzer --input $GRID_DATA_FILE --output $OUTPUT_REPORT --format csv

if [ $? -eq 0 ]; then
    echo "Analysis completed successfully. Report saved to $OUTPUT_REPORT"
else
    echo "Grid analysis failed."
fi
```

--------------------------------

### Initialize PJM Object with gridstatus

Source: https://opensource.gridstatus.io/en/latest/Examples/pjm/PJM%20LMP%20Data

Demonstrates how to import the gridstatus library and initialize a PJM object to interact with PJM data. This is the first step in querying any PJM-related data.

```Python
import gridstatus
import pandas as pd
```

```Python
iso = gridstatus.PJM()
```

--------------------------------

### Python: Fetching Grid Status Data

Source: https://opensource.gridstatus.io/en/latest/_sources/Examples/pjm/PJM%20Load%20Data

This snippet demonstrates how to fetch grid status data using the GridStatus library in Python. It typically involves initializing a client and making requests to retrieve real-time grid information.

```Python
import gridstatus

async def main():
    client = gridstatus.GridStatus()
    status = await client.get_status()
    print(status)

if __name__ == "__main__":
    import asyncio
    asyncio.run(main())
```

--------------------------------

### Get Historical Ancillary Services Prices

Source: https://opensource.gridstatus.io/en/latest/Examples/ercot/Ancillary%20Services

Fetches historical Ancillary Services prices from ERCOT for the last 30 days. It calculates the date 30 days prior to the current date and uses it as the start date for the query.

```Python
thirty_days_ago = pd.Timestamp.now().date() - pd.Timedelta(days=30)
df = iso.get_as_prices(start=thirty_days_ago, end="today")
df
```

--------------------------------

### Fetch Grid Status Data

Source: https://opensource.gridstatus.io/en/latest/_sources/Examples/ercot/Ancillary%20Services

This snippet demonstrates how to fetch grid status data using the GridStatus library. It typically involves specifying a data source or API endpoint. Ensure the library is installed (`pip install gridstatus`).

```Python
import gridstatus

# Example: Fetching data from a hypothetical source
data = gridstatus.fetch_data(source='example_source', params={'region': 'us'})
```

--------------------------------

### Get 5-Minute Transfer Interface Information

Source: https://opensource.gridstatus.io/en/latest/_sources/autoapi/gridstatus/pjm/index

Retrieves transfer interface information in 5-minute intervals. Data is limited to the past 30 days. Requires start and optional end datetimes. Defaults to one day past the start date if end is not specified.

```Python
def get_transfer_interface_information_5_min(date: str | pandas.Timestamp, end: str | pandas.Timestamp | None = None, verbose: bool = False) -> pandas.DataFrame:
    """Retrieves the transfer interface information from:
    https://dataminer2.pjm.com/feed/transfer_interface_infor/definition
    Only available in past 30 days.

    :param date: Start datetime for data
    :type date: str or pandas.Timestamp
    :param end: (str or pandas.Timestamp, optional): End datetime for data.
                Defaults to one day past `date` if not specified.
    :param verbose: print verbose output. Defaults to False.
    :type verbose: bool, optional

    :returns: A DataFrame with transfer interface information
              in 5 minute intervals.
    :rtype: pandas.DataFrame
    """
    pass
```

--------------------------------

### Python: Fetching Grid Status Data

Source: https://opensource.gridstatus.io/en/latest/_sources/Examples/pjm/PJM%20Load%20Data

This snippet demonstrates how to fetch real-time grid status data using the GridStatus.io Python library. It requires the 'gridstatus' package and handles API authentication.

```Python
import gridstatus

# Initialize the client
client = gridstatus.Client()

# Fetch current grid status for a specific region (e.g., 'CAISO')
status = client.get_status('CAISO')
print(status)
```

--------------------------------

### List Available ISOs using GridStatus

Source: https://opensource.gridstatus.io/en/latest/_sources/Examples/ieso/IESO%20Load%20Data

This code snippet demonstrates how to list all available Independent System Operators (ISOs) supported by the GridStatus library. It initializes the IESO object and then calls the `list_isos()` method to display the available ISOs with their names, IDs, and classes.

```Python
import pandas as pd
import gridstatus
from gridstatus.ieso import IESO

ieso = IESO()
print(gridstatus.list_isos())
```

--------------------------------

### Get CAISO Load for a Date Range

Source: https://opensource.gridstatus.io/en/latest/index

Fetches historical load data for a specified period, from a start date to an end date, from CAISO. This is useful for analyzing load trends over time. Both start and end dates need to be provided.

```Python
caiso_load = caiso.get_load(start="Jan 1, 2021", end="Feb 1, 2021")
caiso_load
```

--------------------------------

### Get Solar Generation by Area Data

Source: https://opensource.gridstatus.io/en/latest/_sources/autoapi/gridstatus/pjm/index

Retrieves current solar generation information. Data is published daily around 7 am market time. Requires start and optional end datetimes. Defaults to one day past the start date if end is not specified.

```Python
def get_solar_generation_by_area(date: str | pandas.Timestamp, end: str | pandas.Timestamp | None = None, verbose: bool = False) -> pandas.DataFrame:
    """Retrieves the current solar generation information from:
    https://dataminer2.pjm.com/feed/solar_gen/definition
    Data is published daily around 7am market time.

    :param date: Start datetime for data
    :type date: str or pandas.Timestamp
    :param end: (str or pandas.Timestamp, optional): End datetime for data.
                Defaults to one day past `date` if not specified.
    :param verbose: print verbose output. Defaults to False.
    :type verbose: bool, optional

    :returns: A DataFrame with solar generation information.
    :rtype: pandas.DataFrame
    """
    pass
```

--------------------------------

### Python: Fetching Grid Status Data

Source: https://opensource.gridstatus.io/en/latest/_sources/Examples/pjm/PJM%20Load%20Data

This snippet demonstrates how to fetch real-time grid status data using the Grid Status Python library. It requires the 'gridstatus' package to be installed and may depend on specific API keys or configurations for accessing data sources.

```python
import gridstatus

# Example: Fetching data for a specific region
region_data = gridstatus.get_region_data('example_region')
print(region_data)
```

--------------------------------

### Python: Fetching Grid Status Data

Source: https://opensource.gridstatus.io/en/latest/_sources/Examples/pjm/PJM%20Load%20Data

This snippet demonstrates how to fetch real-time grid status data using the Grid Status Python library. It requires the 'gridstatus' package to be installed.

```python
import gridstatus

async def get_status():
    status = await gridstatus.get_status('CAISO')
    print(status)

# To run this, you would typically use an asyncio event loop:
# import asyncio
# asyncio.run(get_status())
```

--------------------------------

### Get Hourly Transmission Constraints Data

Source: https://opensource.gridstatus.io/en/latest/_sources/autoapi/gridstatus/pjm/index

Retrieves hourly transmission constraints data. Requires start and optional end datetimes.

```Python
def get_transmission_constraints_day_ahead_hourly(date: str | pandas.Timestamp, end: str | pandas.Timestamp = None, verbose: bool = False) -> pandas.DataFrame:
    """Retrieves the transmission constraints data from:
    https://dataminer2.pjm.com/feed/da_transconstraints/definition
    """
    pass
```

--------------------------------

### Get Transmission Limits Data

Source: https://opensource.gridstatus.io/en/latest/_sources/autoapi/gridstatus/pjm/index

Retrieves current transmission limit information in 5-minute intervals when data is available. Data is limited to the past 30 days. Requires start and optional end datetimes. Defaults to one day past the start date if end is not specified.

```Python
def get_transmission_limits(date: str | pandas.Timestamp, end: str | pandas.Timestamp | None = None, verbose: bool = False) -> pandas.DataFrame:
    """Retrieves the current transmission limit information from:
    https://dataminer2.pjm.com/feed/transfer_interface_infor/definition
    Only available in past 30 days. Data is published only when constraints
    exist for that five minute interval.

    :param date: Start datetime for data
    :type date: str or pandas.Timestamp
    :param end: (str or pandas.Timestamp, optional): End datetime for data.
                Defaults to one day past `date` if not specified.
    :param verbose: print verbose output. Defaults to False.
    :type verbose: bool, optional

    :returns: A DataFrame with transmission limit information
              in 5 minute intervals, when data is available.
    :rtype: pandas.DataFrame
    """
    pass
```

--------------------------------

### Initialize SPP Gridstatus

Source: https://opensource.gridstatus.io/en/latest/Examples/spp/LMP%20Data

Initializes the SPP object from the gridstatus library to access market data. This is the first step before querying any LMP information.

```Python
import gridstatus
import pandas as pd
```

```Python
iso = gridstatus.SPP()
```

--------------------------------

### Python: Grid Capacity Planning

Source: https://opensource.gridstatus.io/en/latest/_sources/Examples/pjm/PJM%20Load%20Data

A Python example for grid capacity planning. This snippet could involve analyzing historical data, forecasting future demand, and assessing grid infrastructure to ensure sufficient capacity. It might utilize forecasting libraries and data analysis techniques.

```Python
import pandas as pd
import gridstatus
from statsmodels.tsa.arima.model import ARIMA

data = gridstatus.fetch_data(region='US-Central', duration='1y')
df = pd.DataFrame(data)

# Example: Forecast future load
model = ARIMA(df['load'], order=(5,1,0))
model_fit = model.fit()
forecast = model_fit.forecast(steps=7)
print(f"7-day Load Forecast: {forecast}")
```

--------------------------------

### Get Hourly Solar Forecast

Source: https://opensource.gridstatus.io/en/latest/autoapi/gridstatus/index

Retrieves the hourly solar forecast from the PJM dataminer feed. Requires a start date and optionally an end date.

```Python
get_solar_forecast_hourly(_date : str | pandas.Timestamp_, _end : str | pandas.Timestamp | None = None_, _verbose : bool = False_) → pandas.DataFrame[source]#
```

--------------------------------

### Fetch Grid Status Data (Python)

Source: https://opensource.gridstatus.io/en/latest/_sources/Examples/pjm/PJM%20Load%20Data

Demonstrates how to fetch real-time grid status data using Python. This function typically requires API keys and specific endpoint configurations.

```python
import requests

def fetch_grid_status(api_key, region):
    url = f"https://api.gridstatus.io/v1/status?region={region}"
    headers = {"Authorization": f"Bearer {api_key}"}
    response = requests.get(url, headers=headers)
    response.raise_for_status()  # Raise an exception for bad status codes
    return response.json()
```

--------------------------------

### Get Hourly Transmission Constraints Data

Source: https://opensource.gridstatus.io/en/latest/_sources/autoapi/gridstatus/index

Retrieves hourly transmission constraints data from the PJM dataminer2 feed. Requires start and end datetimes.

```Python
def get_transmission_constraints_day_ahead_hourly(date: str | pandas.Timestamp, end: str | pandas.Timestamp = None, verbose: bool = False) -> pandas.DataFrame:
    """Retrieves the transmission constraints data from: https://dataminer2.pjm.com/feed/da_transconstraints/definition
    """
    pass
```

--------------------------------

### Build Documentation Locally

Source: https://opensource.gridstatus.io/en/latest/contributing

This command builds the project's documentation locally. It's used to verify that new documentation or examples are correctly integrated and displayed.

```Shell
make docs
```

--------------------------------

### Get Capacity of Generation on Outage (Annual)

Source: https://opensource.gridstatus.io/en/latest/_modules/gridstatus/spp

Retrieves annual capacity of generation on outage data for a given year. It downloads a zip file containing multiple CSVs, processes each CSV using a custom function, and combines them into a single DataFrame, sorted by interval start time. Starting from 2014.

```Python
def get_capacity_of_generation_on_outage_annual(self, year, verbose=True):
        """Get VER Curtailments for a year. Starting 2014.
        Recent data use get_capacity_of_generation_on_outage

        Args:
            year: year to get data for
            verbose: print url

        Returns:
            pd.DataFrame: VER Curtailments
        """
        url = f"{FILE_BROWSER_DOWNLOAD_URL}/capacity-of-generation-on-outage?path=/{year}/{year}.zip"  # noqa

        def process_csv(df, file_name):
            # infer date from '2020/01/Capacity-Gen-Outage-20200101.csv'

            publish_time_str = file_name.split(".")[0].split("-")[-1]
            publish_time = pd.to_datetime(publish_time_str).tz_localize(
                self.default_timezone,
            )

            df = self._process_capacity_of_generation_on_outage(df, publish_time)

            return df

        df = utils.download_csvs_from_zip_url(
            url,
            process_csv=process_csv,
            verbose=verbose,
        )

        df = df.sort_values("Interval Start")

        return df
```

--------------------------------

### Python Dictionary Usage Example

Source: https://opensource.gridstatus.io/en/latest/_sources/Examples/pjm/PJM%20Load%20Data

Demonstrates the use of dictionaries in Python for key-value data storage. This could represent configuration settings or status information for grid components.

```python
def access_dictionary():
    config = {
        "interval": 60,
        "unit": "seconds",
        "enabled": True
    }
    print(f"Update interval: {config['interval']} {config['unit']}")

# Example usage:
access_dictionary()
```

--------------------------------

### Python: Data Processing and Analysis

Source: https://opensource.gridstatus.io/en/latest/_sources/Examples/pjm/PJM%20Load%20Data

This Python code illustrates a common data processing task within the GridStatus.io project, such as calculating average demand over a period. It leverages the pandas library for efficient data manipulation. Ensure pandas is installed (`pip install pandas`).

```Python
import pandas as pd

# Assuming 'status_data' is a pandas DataFrame obtained from gridstatus.get_status()

# Example: Calculate average demand for a specific region
if 'demand' in status_data.columns:
    average_demand = status_data['demand'].mean()
    print(f"Average Demand: {average_demand}")
else:
    print("Demand column not found in the data.")
```

--------------------------------

### YAML Configuration Example

Source: https://opensource.gridstatus.io/en/latest/_sources/Examples/caiso/Renewable%20Curtailment

A YAML file example for configuring grid status monitoring. YAML is often used for configuration files due to its human-readable format.

```yaml
monitoring:
  enabled: true
  interval_seconds: 60
  api_endpoint: "http://api.gridstatus.io/config"
```

--------------------------------

### Get Look Ahead Hourly Data

Source: https://opensource.gridstatus.io/en/latest/autoapi/gridstatus/index

Fetches look-ahead hourly data from MISO. Requires a start date and optionally an end date. Verbosity can be controlled.

```Python
get_look_ahead_hourly(_date : str | pandas.Timestamp_, _end : str | pandas.Timestamp | None = None_, _verbose : bool = False_)
```

--------------------------------

### License File Example

Source: https://opensource.gridstatus.io/en/latest/_sources/Examples/caiso/Renewable%20Curtailment

An example of a LICENSE file, typically MIT or Apache, specifying the terms under which the software can be used and distributed.

```text
MIT License

Copyright (c) 2023 Your Name

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
```

--------------------------------

### Get ERCOT Short Term System Adequacy

Source: https://opensource.gridstatus.io/en/latest/autoapi/gridstatus/ercot/index

Retrieves Short Term System Adequacy data published between a start and end date.

```Python
import gridstatus
from datetime import date

ercot = gridstatus.Ercot()
adequacy_data = ercot.get_short_term_system_adequacy(date(2023, 1, 1), date(2023, 1, 5))
```

--------------------------------

### Install Project Dependencies with Poetry

Source: https://opensource.gridstatus.io/en/latest/contributing

This snippet shows how to configure Poetry to use an in-project virtual environment and install all project dependencies, including extras. This is a crucial step for setting up a development environment.

```Shell
# Configure poetry to use a virtual environment
poetry config virtualenvs.in-project true
# Install the project dependencies
poetry install --all-extras
```

--------------------------------

### Get Ontario Load Forecast

Source: https://opensource.gridstatus.io/en/latest/_modules/gridstatus/ieso

Retrieves the forecasted load for Ontario. This function supports only 'today' and 'latest' dates as there's a single load forecast. It parses XML data to extract projected values, creation timestamps, and start dates, then constructs a DataFrame with interval start and end times.

```Python
if date not in ["today", "latest"]:
            raise NotSupported(
                "Only 'today' and 'latest' are supported for load forecasts.",
            )

        root = ET.fromstring(self._request(LOAD_FORECAST_URL, verbose).text)

        # Extract values from <DataSet Series="Projected">
        projected_values = []

        # Iterate through the XML to find the DataSet with Series="Projected"
        for dataset in root.iter("DataSet"):
            if dataset.attrib.get("Series") == "Projected":
                for data in dataset.iter("Data"):
                    for value in data.iter("Value"):
                        projected_values.append(value.text)

        created_at = pd.Timestamp(
            root.find(".//CreatedAt").text,
            tz=self.default_timezone,
        )
        start_date = pd.Timestamp(
            root.find(".//StartDate").text,
            tz=self.default_timezone,
        )

        # Create the range of interval starts based on the number of values at an
        # hourly frequency
        interval_starts = pd.date_range(
            start_date,
            periods=len(projected_values),
            freq="h",
            tz=self.default_timezone,
        )

        # Create a DataFrame with the projected values
        df_projected = pd.DataFrame(projected_values, columns=["Ontario Load Forecast"])
        df_projected["Ontario Load Forecast"] = df_projected[
            "Ontario Load Forecast"
        ].astype(float)
        df_projected["Publish Time"] = created_at
        df_projected["Interval Start"] = interval_starts
        df_projected["Interval End"] = df_projected["Interval Start"] + pd.Timedelta(
            hours=HOUR_INTERVAL,
        )

        return utils.move_cols_to_front(
            df_projected,
            [
                "Interval Start",
                "Interval End",
                "Publish Time",
                "Ontario Load Forecast",
            ],
        )
```

--------------------------------

### Grid Status IO - Shell Script Example

Source: https://opensource.gridstatus.io/en/latest/_sources/Examples/ercot/Ancillary%20Services

This snippet provides an example of a shell script used with Grid Status IO. It could be for automation, deployment, or running specific commands related to the grid status service. It might involve command-line arguments and system commands.

```Shell
#!/bin/bash
# Placeholder for Grid Status IO Shell script
echo "Grid Status IO Shell Example"
```

--------------------------------

### Deploy Grid Status Service (Docker)

Source: https://opensource.gridstatus.io/en/latest/_sources/Examples/pjm/PJM%20Load%20Data

A Dockerfile to containerize and deploy the GridStatus service. This ensures consistent environments for development and production.

```dockerfile
FROM python:3.9-slim

WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
CMD ["python", "app.py"]
```

--------------------------------

### Python: Fetching Grid Status Data

Source: https://opensource.gridstatus.io/en/latest/_sources/Examples/pjm/PJM%20Load%20Data

This snippet demonstrates how to fetch grid status data using the GridStatus library in Python. It typically involves initializing a client and making a request to retrieve the latest status information.

```python
from gridstatus import GridStatus

# Initialize the GridStatus client
client = GridStatus()

# Fetch the latest grid status
status = client.get_status()

# Print the status
print(status)
```

--------------------------------

### Get Hourly Metered Load Data

Source: https://opensource.gridstatus.io/en/latest/autoapi/gridstatus/index

Retrieves hourly metered load data from the PJM dataminer feed. Requires a start date and optionally an end date.

```Python
get_load_metered_hourly(_date : str | pandas.Timestamp_, _end : str | pandas.Timestamp | None = None_, _verbose : bool = False_)[source]#
```

--------------------------------

### Get NYISO Interface Limits and Flows (5-min)

Source: https://opensource.gridstatus.io/en/latest/autoapi/gridstatus/index

Fetches interface limits and flows for a specified date range at 5-minute intervals. Requires start and end dates.

```python
get_interface_limits_and_flows_5_min(_date : str | pandas.Timestamp | tuple[pandas.Timestamp, pandas.Timestamp]_, _end : str | pandas.Timestamp | tuple[pandas.Timestamp, pandas.Timestamp] | None = None_, _verbose : bool = False_) → pandas.DataFrame[source]#
    
Get interface limits and flows for a date
```
Tokens:
Raw