modusa 0.2.22__py3-none-any.whl → 0.3__py3-none-any.whl

modusa/tools/plotter.py

@@ -0,0 +1,351 @@
+#!/usr/bin/env python3
+
+
+import numpy as np
+import matplotlib.pyplot as plt
+import matplotlib.gridspec as gridspec
+from matplotlib.patches import Rectangle
+from mpl_toolkits.axes_grid1.inset_locator import inset_axes
+
+#======== 1D ===========
+def plot1d(*args, ann=None, events=None, xlim=None, ylim=None, xlabel=None, ylabel=None, title=None, legend=None):
+		"""
+		Plots a 1D signal using matplotlib.
+
+		.. code-block:: python
+	
+			import modusa as ms
+			import numpy as np
+			
+			x = np.arange(100) / 100
+			y = np.sin(x)
+			
+			display(ms.plot1d(y, x))
+			
+	
+		Parameters
+		----------
+		*args : tuple[array-like, array-like] | tuple[array-like]
+			- The signal y and axis x to be plotted.
+			- If only values are provided, we generate the axis using arange.
+			- E.g. (y1, x1), (y2, x2), ...
+		ann : list[tuple[Number, Number, str] | None
+			- A list of annotations to mark specific points. Each tuple should be of the form (start, end, label).
+			- Default: None => No annotation.
+		events : list[Number] | None
+			- A list of x-values where vertical lines (event markers) will be drawn.
+			- Default: None
+		xlim : tuple[Number, Number] | None
+			- Limits for the x-axis as (xmin, xmax).
+			- Default: None
+		ylim : tuple[Number, Number] | None
+			- Limits for the y-axis as (ymin, ymax).
+			- Default: None
+		xlabel : str | None
+			- Label for the x-axis.
+			- - Default: None
+		ylabel : str | None
+			- Label for the y-axis.
+			- Default: None
+		title : str | None
+			- Title of the plot.
+			- Default: None
+		legend : list[str] | None
+			- List of legend labels corresponding to each signal if plotting multiple lines.
+			- Default: None
+	
+		Returns
+		-------
+		plt.Figure
+			Matplolib figure.
+		"""
+	
+		for arg in args:
+			if len(arg) not in [1, 2]: # 1 if it just provides values, 2 if it provided axis as well
+				raise ValueError(f"1D signal needs to have max 2 arrays (y, x) or simply (y, )")
+		if isinstance(legend, str): legend = (legend, )
+		
+		if legend is not None:
+			if len(legend) < len(args):
+				raise ValueError(f"Legend should be provided for each signal.")
+
+		fig = plt.figure(figsize=(16, 2))
+		gs = gridspec.GridSpec(2, 1, height_ratios=[0.2, 1])
+			
+		colors = plt.get_cmap('tab10').colors
+		
+		signal_ax = fig.add_subplot(gs[1, 0])
+		annotation_ax = fig.add_subplot(gs[0, 0], sharex=signal_ax)
+		
+		# Set lim
+		if xlim is not None:
+			signal_ax.set_xlim(xlim)
+		
+		if ylim is not None:
+			signal_ax.set_ylim(ylim)
+		
+			
+		# Add signal plot
+		for i, signal in enumerate(args):
+			if len(signal) == 1:
+				y = signal[0]
+				if legend is not None:
+					signal_ax.plot(y, label=legend[i])
+				else:
+					signal_ax.plot(y)
+			elif len(signal) == 2:
+				y, x = signal[0], signal[1]
+				if legend is not None:
+					signal_ax.plot(x, y, label=legend[i])
+				else:
+					signal_ax.plot(x, y)
+		
+		# Add annotations
+		if ann is not None:
+			annotation_ax.set_ylim(0, 1)
+			for i, (start, end, tag) in enumerate(ann):
+				if xlim is not None:
+					if end < xlim[0] or start > xlim[1]:
+						continue  # Skip out-of-view regions
+					# Clip boundaries to xlim
+					start = max(start, xlim[0])
+					end = min(end, xlim[1])
+					
+				color = colors[i % len(colors)]
+				width = end - start
+				rect = Rectangle((start, 0), width, 1, color=color, alpha=0.7)
+				annotation_ax.add_patch(rect)
+				annotation_ax.text((start + end) / 2, 0.5, tag,
+									ha='center', va='center',
+									fontsize=10, color='white', fontweight='bold', zorder=10)
+		# Add vlines
+		if events is not None:
+			for xpos in events:
+				if xlim is not None:
+					if xlim[0] <= xpos <= xlim[1]:
+						annotation_ax.axvline(x=xpos, color='black', linestyle='--', linewidth=1.5)
+				else:
+					annotation_ax.axvline(x=xpos, color='black', linestyle='--', linewidth=1.5)
+					
+		# Add legend
+		if legend is not None:
+			handles, labels = signal_ax.get_legend_handles_labels()
+			fig.legend(handles, labels, loc='upper right', bbox_to_anchor=(0.9, 1.2), ncol=len(legend), frameon=False)
+			
+		# Set title, labels
+		if title is not None:
+			annotation_ax.set_title(title, pad=10, size=11)
+		if xlabel is not None:
+			signal_ax.set_xlabel(xlabel)
+		if ylabel is not None:
+			signal_ax.set_ylabel(ylabel)
+		
+		# Decorating annotation axis thicker
+		if ann is not None:
+			annotation_ax.tick_params(left=False, bottom=False, labelleft=False, labelbottom=False)
+		else:
+			annotation_ax.axis("off")
+		
+		
+		fig.subplots_adjust(hspace=0.01, wspace=0.05)
+		plt.close()
+		return fig
+
+#======== 2D ===========
+def plot2d(*args, ann=None, events=None, xlim=None, ylim=None, origin="lower", Mlabel=None, xlabel=None, ylabel=None, title=None, legend=None, lm=False):
+	"""
+	Plots a 2D matrix (e.g., spectrogram or heatmap) with optional annotations and events.
+
+	.. code-block:: python
+
+		import modusa as ms
+		import numpy as np
+		
+		M = np.random.random((10, 30))
+		y = np.arange(M.shape[0])
+		x = np.arange(M.shape[1])
+		
+		display(ms.plot2d(M, y, x))
+
+	Parameters
+	----------
+	*args : tuple[array-like, array-like]
+		- The signal values to be plotted.
+		- E.g. (M1, y1, x1), (M2, y2, x2), ...
+	ann : list[tuple[Number, Number, str]] | None
+		- A list of annotation spans. Each tuple should be (start, end, label).
+		- Default: None (no annotations).
+	events : list[Number] | None
+		- X-values where vertical event lines will be drawn.
+		- Default: None.
+	xlim : tuple[Number, Number] | None
+		- Limits for the x-axis as (xmin, xmax).
+		- Default: None (auto-scaled).
+	ylim : tuple[Number, Number] | None
+		- Limits for the y-axis as (ymin, ymax).
+		- Default: None (auto-scaled).
+	origin : {'upper', 'lower'}
+		- Origin position for the image display. Used in `imshow`.
+		- Default: "lower".
+	Mlabel : str | None
+		- Label for the colorbar (e.g., "Magnitude", "Energy").
+		- Default: None.
+	xlabel : str | None
+		- Label for the x-axis.
+		- Default: None.
+	ylabel : str | None
+		- Label for the y-axis.
+		- Default: None.
+	title : str | None
+		- Title of the plot.
+		- Default: None.
+	legend : list[str] | None
+		- Legend labels for any overlaid lines or annotations.
+		- Default: None.
+	lm: bool
+		- Adds a circular marker for the line.
+		- Default: False
+		- Useful to show the data points.
+
+	Returns
+	-------
+	matplotlib.figure.Figure
+		The matplotlib Figure object.
+	"""
+	
+	for arg in args:
+		if len(arg) not in [1, 2, 3]: # Either provide just the matrix or with both axes info
+			raise ValueError(f"Data to plot needs to have 3 arrays (M, y, x)")
+	if isinstance(legend, str): legend = (legend, )
+	
+	fig = plt.figure(figsize=(16, 4))
+	gs = gridspec.GridSpec(3, 1, height_ratios=[0.2, 0.1, 1]) # colorbar, annotation, signal
+
+	colors = plt.get_cmap('tab10').colors
+	
+	signal_ax = fig.add_subplot(gs[2, 0])
+	annotation_ax = fig.add_subplot(gs[1, 0], sharex=signal_ax)
+	
+	colorbar_ax = fig.add_subplot(gs[0, 0])
+	colorbar_ax.axis("off")
+	
+	
+	# Add lim
+	if xlim is not None:
+		signal_ax.set_xlim(xlim)
+		
+	if ylim is not None:
+		signal_ax.set_ylim(ylim)
+		
+	# Add signal plot
+	i = 0 # This is to track the legend for 1D plots
+	for signal in args:
+		
+		data = signal[0] # This can be 1D or 2D (1D meaning we have to overlay on the matrix)
+			
+		if data.ndim == 1: # 1D
+			if len(signal) == 1: # It means that the axis was not passed
+				x = np.arange(data.shape[0])
+			
+			if lm is False:
+				if legend is not None:
+					signal_ax.plot(x, data, label=legend[i])
+					signal_ax.legend(loc="upper right")
+				else:
+					signal_ax.plot(x, data)
+			else:
+				if legend is not None:
+					signal_ax.plot(x, data, marker="o", markersize=7, markerfacecolor='red', linestyle="--", linewidth=2, label=legend[i])
+					signal_ax.legend(loc="upper right")
+				else:
+					signal_ax.plot(x, data, marker="o", markersize=7, markerfacecolor='red', linestyle="--", linewidth=2)
+					
+			i += 1
+			
+		elif data.ndim == 2: # 2D
+			M = data
+			if len(signal) == 1: # It means that the axes were not passed
+				y = np.arange(M.shape[0])
+				x = np.arange(M.shape[1])
+				dx = x[1] - x[0]
+				dy = y[1] - y[0]
+				extent=[x[0] - dx/2, x[-1] + dx/2, y[0] - dy/2, y[-1] + dy/2]
+				im = signal_ax.imshow(M, aspect="auto", origin=origin, cmap="gray_r", extent=extent)
+				
+			elif len(signal) == 3: # It means that the axes were passed
+				M, y, x = signal[0], signal[1], signal[2]
+				dx = x[1] - x[0]
+				dy = y[1] - y[0]
+				extent=[x[0] - dx/2, x[-1] + dx/2, y[0] - dy/2, y[-1] + dy/2]
+				im = signal_ax.imshow(M, aspect="auto", origin=origin, cmap="gray_r", extent=extent)
+	
+	# Add annotations
+	if ann is not None:
+		annotation_ax.set_ylim(0, 1)
+		for i, (start, end, tag) in enumerate(ann):
+			if xlim is not None:
+				if end < xlim[0] or start > xlim[1]:
+					continue  # Skip out-of-view regions
+				# Clip boundaries to xlim
+				start = max(start, xlim[0])
+				end = min(end, xlim[1])
+				
+			color = colors[i % len(colors)]
+			width = end - start
+			rect = Rectangle((start, 0), width, 1, color=color, alpha=0.7)
+			annotation_ax.add_patch(rect)
+			annotation_ax.text((start + end) / 2, 0.5, tag,
+								ha='center', va='center',
+								fontsize=10, color='white', fontweight='bold', zorder=10)
+	# Add vlines
+	if events is not None:
+		for xpos in events:
+			if xlim is not None:
+				if xlim[0] <= xpos <= xlim[1]:
+					annotation_ax.axvline(x=xpos, color='black', linestyle='--', linewidth=1.5)
+			else:
+				annotation_ax.axvline(x=xpos, color='black', linestyle='--', linewidth=1.5)
+	
+	# Add legend incase there are 1D overlays
+	if legend is not None:
+		handles, labels = signal_ax.get_legend_handles_labels()
+		if handles:  # Only add legend if there's something to show
+			signal_ax.legend(handles, labels, loc="upper right")
+	
+	# Add colorbar
+	# Create an inset axis on top-right of signal_ax
+	cax = inset_axes(
+		colorbar_ax,
+		width="20%",      # percentage of parent width
+		height="20%",      # height in percentage of parent height
+		loc='upper right',
+		bbox_to_anchor=(0, 0, 1, 1),
+		bbox_transform=colorbar_ax.transAxes,
+		borderpad=1
+	)
+	
+	cbar = plt.colorbar(im, cax=cax, orientation='horizontal')
+	cbar.ax.xaxis.set_ticks_position('top')
+	
+	if Mlabel is not None:
+		cbar.set_label(Mlabel, labelpad=5)
+	
+		
+	# Set title, labels
+	if title is not None:
+		annotation_ax.set_title(title, pad=10, size=11)
+	if xlabel is not None:
+		signal_ax.set_xlabel(xlabel)
+	if ylabel is not None:
+		signal_ax.set_ylabel(ylabel)
+	
+	
+	# Making annotation axis spines thicker
+	if ann is not None:
+		annotation_ax.tick_params(left=False, bottom=False, labelleft=False, labelbottom=False)
+	else:
+		annotation_ax.axis("off")
+
+	fig.subplots_adjust(hspace=0.01, wspace=0.05)
+	plt.close()
+	return fig

modusa/tools/youtube_downloader.py

@@ -0,0 +1,72 @@
+#!/usr/bin/env python3
+
+
+from modusa import excp
+from modusa.decorators import validate_args_type
+from modusa.tools.base import ModusaTool
+from typing import Any
+from pathlib import Path
+import yt_dlp
+
+
+def download(url, content_type, output_dir):
+	"""
+	Downloads audio/video from YouTube.
+
+	.. code-block:: python
+		
+		# To download audio
+		import modusa as ms
+		audio_fp = ms.download(
+			url="https://www.youtube.com/watch?v=lIpw9-Y_N0g", 
+			content_type="audio", 
+			output_dir=".")
+	
+	Parameters
+	----------
+	url: str
+		Link to the YouTube video.
+	content_type: str
+		"audio" or "video"
+	output_dir: str | Path
+		Directory to save the YouTube content.
+	
+	Returns
+	-------
+	Path
+		File path of the downloaded content.
+	
+	"""
+	if content_type == "audio":
+		output_dir = Path(output_dir)
+		output_dir.mkdir(parents=True, exist_ok=True)
+		
+		ydl_opts = {
+				'format': 'bestaudio/best',
+				'outtmpl': f'{output_dir}/%(title)s.%(ext)s',
+				'quiet': True,
+			}
+		
+		with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+			info = ydl.extract_info(url, download=True)
+			return Path(info['requested_downloads'][0]['filepath'])
+		
+	elif content_type == "video":
+		output_dir = Path(output_dir)
+		output_dir.mkdir(parents=True, exist_ok=True)
+		
+		ydl_opts = {
+			'format': 'bestvideo+bestaudio/best',  # High quality
+			'outtmpl': str(output_dir / '%(title)s.%(ext)s'),
+			'merge_output_format': 'mp4',
+			'quiet': True,  # Hide verbose output
+		}
+		
+		with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+			info = ydl.extract_info(url, download=True)
+			return Path(info['requested_downloads'][0]['filepath'])
+	else:
+		raise excp.InputValueError(f"`content_type` can either take 'audio' or 'video' not {content_type}")
+
+	
+	

modusa/utils/excp.py

@@ -4,73 +4,46 @@
 #----------------------------------------
 # Base class errors
 #----------------------------------------
-class MusaBaseError(Exception):
+class ModusaBaseError(Exception):
 	"""
 	Ultimate base class for any kind of custom errors.
 	"""
 	pass
 
-class TypeError(MusaBaseError):
+class TypeError(ModusaBaseError):
 	pass
 	
-class InputError(MusaBaseError):
+class InputError(ModusaBaseError):
 	"""
 	Any Input type error.
 	"""
 
-class InputTypeError(MusaBaseError):
+class InputTypeError(ModusaBaseError):
 	"""
 	Any Input type error.
 	"""
 
-class InputValueError(MusaBaseError):
+class InputValueError(ModusaBaseError):
 	"""
 	Any Input type error.
 	"""
 	
-class ImmutableAttributeError(MusaBaseError):
+class OperationNotPossibleError(ModusaBaseError):
+	"""
+	Any errors if there is an operations
+	failure.
+	"""
+	
+class ImmutableAttributeError(ModusaBaseError):
 	"""Raised when attempting to modify an immutable attribute."""
 	pass
 	
-class FileNotFoundError(MusaBaseError):
+class FileNotFoundError(ModusaBaseError):
 	"""Raised when file does not exist."""
 	pass
 	
-	
-class PluginInputError(MusaBaseError):
-	pass
-
-class PluginOutputError(MusaBaseError):
-	pass
-	
-
-
-class SignalOpError(MusaBaseError):
-	pass
-	
-class AttributeNotFoundError(MusaBaseError):
-	pass
-	
-class ParsingError(MusaBaseError):
-	"""
-	Base class for any parsing related issues
-	"""
-	pass
-
-class ValidationError(MusaBaseError):
-	"""
-	Base class for all input validation error
-	"""
+class PluginInputError(ModusaBaseError):
 	pass
 
-class GenerationError(MusaBaseError):
-	"""
-	Error when generation fails
-	"""
-	pass
-
-class FileLoadingError(MusaBaseError):
-	"""
-	Error loading a file
-	"""
+class PluginOutputError(ModusaBaseError):
 	pass

modusa/utils/np_func_cat.py

@@ -0,0 +1,44 @@
+#!/usr/bin/env python3
+
+# This contains categorised NumPy functions
+# This is useful while handling np operations on modusa signals
+
+import numpy as np
+
+SHAPE_PRESERVING_FUNCS = {
+	np.sin, np.cos, np.tan, 
+	np.sinh, np.cosh, np.tanh,
+	np.arcsin, np.arccos, np.arctan,
+	np.exp, np.expm1, np.log, np.log2, np.log10, np.log1p,
+	np.abs, np.negative, np.positive,
+	np.square, np.sqrt, np.cbrt,
+	np.floor, np.ceil, np.round, np.rint, np.trunc,
+	np.clip, np.sign,
+	np.add, np.subtract, np.multiply, np.true_divide, np.floor_divide
+}
+
+REDUCTION_FUNCS = {
+	np.sum, np.prod,
+	np.mean, np.std, np.var,
+	np.min, np.max,
+	np.argmin, np.argmax,
+	np.median, np.percentile,
+	np.all, np.any,
+	np.nanmean, np.nanstd, np.nanvar, np.nansum
+}
+
+CONCAT_FUNCS = {
+	np.concatenate, np.stack, np.hstack, np.vstack, np.dstack,
+	np.column_stack, np.row_stack
+}
+
+X_NEEDS_ADJUSTMENT_FUNCS = {
+	np.diff,
+	np.gradient,
+	np.trim_zeros,
+	np.unwrap,
+	np.fft.fft, np.fft.ifft, np.fft.fftshift, np.fft.ifftshift,
+	np.correlate, np.convolve
+}
+
+

modusa/utils/plot.py

@@ -0,0 +1,142 @@
+#!/usr/bin/env python3
+
+from modusa.models.s1d import S1D
+from modusa.models.s2d import S2D
+import matplotlib.pyplot as plt
+import numpy as np
+from collections import defaultdict
+import itertools
+
+def _in_notebook() -> bool:
+	"""
+	To check if we are in jupyter notebook environment.
+	"""
+	try:
+		from IPython import get_ipython
+		shell = get_ipython()
+		return shell and shell.__class__.__name__ == "ZMQInteractiveShell"
+	except ImportError:
+		return False
+
+def plot_multiple_signals(
+	*args,
+	loc = None,
+	x_lim: tuple[float, float] | None = None,
+	highlight_regions: list[tuple[float, float, str]] | None = None,
+	vlines: list[float, ...] | None = None,
+) -> plt.Figure:
+	"""
+	Plots multiple instances of uniform `Signal1D` and `Signal2D`
+	with proper formatting and time aligned.
+
+	Parameters
+	----------
+	loc: tuple[int]
+		- The len should match the number of signals sent as args.
+		- e.g. (0, 1, 1) => First plot at ax 0, second and third plot at ax 1
+		- Default: None => (0, 1, 2, ...) all plots on a new ax.
+	highlight_regions: list[tuple[float, float, str]]
+		-
+	
+	"""
+	
+	assert len(args) >= 1, "No signal provided to plot"
+	signals = args
+	
+	for signal in signals: 
+		if not isinstance(signal, (S1D, S2D)):
+			raise TypeError(f"Invalid signal type {type(signal)}")
+	
+	if loc is None: # => We will plot all the signals on different subplots
+		loc = tuple([i for i in range(len(args))]) # Create (0, 1, 2, ...) that serves as ax number for plots
+	else: # Incase loc is provided, we make sure that we do it for each of the signals
+		assert len(args) == len(loc)
+	
+	# Make sure that all the elements in loc do not miss any number in between (0, 1, 1, 2, 4) -> Not allowed
+	assert min(loc) == 0
+	max_loc = max(loc)
+	for i in range(max_loc):
+		if i not in loc:
+			raise ValueError(f"Invalid `loc` values, it should not have any missing integer in between.")
+	
+	# Create a dict that maps subplot to signals that need to be plotted on that subplot e.g. {0: [signal1, signal3], ...}
+	subplot_signal_map = defaultdict(list)
+	for signal, i in zip(args, loc):
+		subplot_signal_map[i].append(signal)
+	
+	# We need to create a figure with right configurations
+	height_ratios = []
+	height_1d_subplot = 0.4
+	height_2d_subplot = 1
+	n_1d_subplots = 0
+	n_2d_subplots = 0
+	for l, signals in subplot_signal_map.items():
+
+		# If there is any 2D signal, the subplot will be 2D
+		if any(isinstance(s, S2D) for s in signals):
+			n_2d_subplots += 1
+			height_ratios.append(height_2d_subplot)
+		
+		# If all are 1D signal, the subplot will be 1D
+		elif all(isinstance(s, S1D) for s in signals):
+			n_1d_subplots += 1
+			height_ratios.append(height_1d_subplot)
+	
+	
+	n_subplots = n_1d_subplots + n_2d_subplots
+	fig_width = 15
+	fig_height = n_1d_subplots * 2 + n_2d_subplots * 4 # This is as per the figsize height set in the plotter tool
+	fig, axs = plt.subplots(n_subplots, 2, figsize=(fig_width, fig_height), width_ratios=[1, 0.01], height_ratios=height_ratios) # 2nd column for cbar
+	
+	if n_subplots == 1:
+		axs = [axs]  # axs becomes list of one pair [ (ax, cbar_ax) ]
+	
+	# We find the x axis limits as per the max limit for all the signals combined, so that all the signals can be seen.
+	if x_lim is None:
+		x_min = min(np.min(signal.x.values) for signal in args)
+		x_max = max(np.max(signal.x.values) for signal in args)
+		x_lim = (x_min, x_max)
+		
+	for l, signals in subplot_signal_map.items():
+		# Incase we have plot multiple signals in the same subplot, we change the color
+		fmt_cycle = itertools.cycle(['k-', 'r-', 'g-', 'b-', 'm-', 'c-', 'y-'])
+		
+		# For each subplot, we want to know if it is 2D or 1D
+		if any(isinstance(s, S2D) for s in signals): is_1d_subplot = False
+		else: is_1d_subplot = True
+		
+		if is_1d_subplot: # All the signals are 1D
+			for signal in signals:
+				fmt = next(fmt_cycle)
+				if len(signals) == 1: # highlight region works properly only if there is one signal for a subplot
+					signal.plot(axs[l][0], x_lim=x_lim, highlight_regions=highlight_regions, show_grid=True, vlines=vlines, fmt=fmt, legend=signal._title)
+				else:
+					y, x = signal._x._values, signal._y._values
+					signal.plot(axs[l][0], x_lim=x_lim, show_grid=True, vlines=vlines, fmt=fmt, legend=signal.title, y_label=signal.y.label, x_label=signal.x.label, title="")
+				
+			# Remove the colorbar column (if the subplot is 1d)
+			axs[l][1].remove()
+			
+		if not is_1d_subplot: # Atleast 1 signal is 2D, we we have a 2D subplot
+			for signal in signals:
+				if len(signals) == 1: # Only one 2D signal is to be plotted
+					signal.plot(axs[l][0], x_lim=x_lim, show_colorbar=True, cax=axs[l][1], highlight_regions=highlight_regions, vlines=vlines)
+				else:
+					if isinstance(signal, S1D):
+						fmt = next(fmt_cycle)
+						signal.plot(axs[l][0], x_lim=x_lim, show_grid=True, vlines=vlines, fmt=fmt, legend=signal.title, y_label=signal.y.label, x_label=signal.x.label, title="")
+					elif isinstance(signal, S2D):
+						signal.plot(axs[l][0], x_lim=x_lim, show_colorbar=True, cax=axs[l][1], vlines=vlines, x_label=signal.x.label, y_label=signal.y.label, title="")
+		
+		# We set the xlim, this will align all the signals automatically as they are on the same row
+		for l in range(n_subplots):
+			axs[l][0].set_xlim(x_lim)
+		
+	if _in_notebook():
+		plt.tight_layout()
+		plt.close(fig)
+		return fig
+	else:
+		plt.tight_layout()
+		plt.show()
+		return fig