code: def generate_series(
      n_series: int,
      freq: str = "D",
      min_length: int = 50,
      max_length: int = 500,
      n_temporal_features: int = 0,
      n_static_features: int = 0,
      equal_ends: bool = False,
      seed: int = 0,
  ) -> pd.DataFrame:
      """Generate Synthetic Panel Series.
  
      Generates `n_series` of frequency `freq` of different lengths in the interval [`min_length`, `max_length`].
      If `n_temporal_features > 0`, then each serie gets temporal features with random values.
      If `n_static_features > 0`, then a static dataframe is returned along the temporal dataframe.
      If `equal_ends == True` then all series end at the same date.
  
      **Parameters:**<br>
      `n_series`: int, number of series for synthetic panel.<br>
      `min_length`: int, minimal length of synthetic panel's series.<br>
      `max_length`: int, minimal length of synthetic panel's series.<br>
      `n_temporal_features`: int, default=0, number of temporal exogenous variables for synthetic panel's series.<br>
      `n_static_features`: int, default=0, number of static exogenous variables for synthetic panel's series.<br>
      `equal_ends`: bool, if True, series finish in the same date stamp `ds`.<br>
      `freq`: str, frequency of the data, [panda's available frequencies](https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#offset-aliases).<br>
  
      **Returns:**<br>
      `freq`: pandas.DataFrame, synthetic panel with columns [`unique_id`, `ds`, `y`] and exogenous.
      """
      seasonalities = {"D": 7, "M": 12}
      season = seasonalities[freq]
  
      rng = np.random.RandomState(seed)
      series_lengths = rng.randint(min_length, max_length + 1, n_series)
      total_length = series_lengths.sum()
  
      dates = pd.date_range(
          "2000-01-01", periods=max_length, freq=freq
      ).values
      uids = [
          np.repeat(i, serie_length)
          for i, serie_length in enumerate(series_lengths)
      ]
      if equal_ends:
          ds = [
              dates[-serie_length:] for serie_length in series_lengths
          ]
      else:
          ds = [dates[:serie_length] for serie_length in series_lengths]
  
      y = (
          np.arange(total_length) % season
          + rng.rand(total_length) * 0.5
      )
      temporal_df = pd.DataFrame(
          dict(
              unique_id=chain.from_iterable(uids),
              ds=chain.from_iterable(ds),
              y=y,
          )
      )
  
      random.seed(seed)
      for i in range(n_temporal_features):
          random.seed(seed)
          temporal_values = [
              [random.randint(0, 100)] * serie_length
              for serie_length in series_lengths
          ]
          temporal_df[f"temporal_{i}"] = np.hstack(temporal_values)
          temporal_df[f"temporal_{i}"] = temporal_df[
              f"temporal_{i}"
          ].astype("category")
          if i == 0:
              temporal_df["y"] = temporal_df["y"] * (
                  1 + temporal_df[f"temporal_{i}"].cat.codes
              )
  
      temporal_df["unique_id"] = temporal_df["unique_id"].astype(
          "category"
      )
      temporal_df["unique_id"] = temporal_df[
          "unique_id"
      ].cat.as_ordered()
  
      if n_static_features > 0:
          static_features = np.random.uniform(
              low=0.0, high=1.0, size=(n_series, n_static_features)
          )
          static_df = pd.DataFrame.from_records(
              static_features,
              columns=[f"static_{i}" for i in range(n_static_features)],
          )
  
          static_df["unique_id"] = np.arange(n_series)
          static_df["unique_id"] = static_df["unique_id"].astype(
              "category"
          )
          static_df["unique_id"] = static_df[
              "unique_id"
          ].cat.as_ordered()
  
          return temporal_df, static_df
  
      return temporal_df
  
imports: import random
  from itertools import chain
  import numpy
  import pandas
  from typing import List
label_desc: Use image node_id 1 for calling a global function with example usage: generate_series(n_series, freq, min_length, max_length, n_temporal_features, n_static_features, equal_ends, seed) and returns: temporal_df, temporal_df,  static_df