numdaplot 0.1.0__py3-none-any.whl

numdaplot/plots/output/shown_object.py

@@ -0,0 +1,45 @@
+"""
+Kind of object a display shows: a Plot or a Figure.
+
+.. versionadded:: 0.1.0
+"""
+
+from enum import Enum
+
+
+class ShownObject(Enum):
+	"""
+	Kind of object a display shows, named in the message of a ``DisplayWarning``.
+
+	The value is the name of the class.
+
+	.. versionadded:: 0.1.0
+
+	Examples
+	--------
+	>>> from numdaplot.plots.output.shown_object import ShownObject
+	>>> ShownObject.FIGURE.value
+	'Figure'
+	"""
+
+	PLOT = "Plot"
+	"""
+	A Plot, shown with ``Plot.show``.
+
+	Examples
+	--------
+	>>> from numdaplot.plots.output.shown_object import ShownObject
+	>>> ShownObject.PLOT.value
+	'Plot'
+	"""
+
+	FIGURE = "Figure"
+	"""
+	A Figure, shown with ``Figure.show``.
+
+	Examples
+	--------
+	>>> from numdaplot.plots.output.shown_object import ShownObject
+	>>> ShownObject.FIGURE.value
+	'Figure'
+	"""

numdaplot/plots/overlay_checks.py

@@ -0,0 +1,245 @@
+"""
+Checks of a chart added to a Plot with ``add_line``, ``add_bar`` or ``add_scatter``.
+
+.. versionadded:: 0.1.0
+"""
+
+from typing import cast
+
+from numdaplot.data_types.value_family import ValueFamily, find_family
+from numdaplot.errors.incompatible_charts_error import IncompatibleChartsError
+from numdaplot.errors.refused_setting_error import RefusedSettingError
+from numdaplot.plots.chart_layer import ChartLayer
+from numdaplot.plots.charts.bar_chart import BarChart
+from numdaplot.plots.charts.chart import Chart
+from numdaplot.plots.charts.line_chart import LineChart
+from numdaplot.plots.charts.orientation import Orientation
+from numdaplot.plots.charts.scatter_chart import ScatterChart
+from numdaplot.plots.charts.value_axis import ValueAxis
+from numdaplot.plots.data.chart_values import ChartValues
+from numdaplot.plots.data.position_kind import PositionKind
+
+OVERLAID_CHARTS = (LineChart, BarChart, ScatterChart)
+POSITION_NAMES = {
+	PositionKind.NUMBERS: "numbers",
+	PositionKind.MOMENTS: "dates",
+	PositionKind.TEXTS: "texts",
+	PositionKind.TIMES: "times of day",
+}
+VALUE_NAMES = {
+	ValueFamily.NUMBER: "numbers",
+	ValueFamily.TIME: "times of day",
+}
+AXIS_NAMES = {
+	ValueAxis.LEFT: "left",
+	ValueAxis.RIGHT: "right",
+}
+VALUE_DESCRIPTION = "{value_name} on the {axis_name} axis"
+PLOT_NAME = "a Plot of {chart_name}"
+HORIZONTAL_BARS_NAME = "a Plot of horizontal bars"
+HORIZONTAL_SETTING = "Orientation.HORIZONTAL"
+
+
+def require_overlay_base(first_layer: ChartLayer, method_name: str) -> None:
+	"""
+	Check that a Plot accepts added charts: its first chart draws lines, vertical bars or points.
+
+	.. versionadded:: 0.1.0
+
+	Parameters
+	----------
+	first_layer
+		The first chart of the Plot and its values.
+	method_name
+		The method adding a chart, such as ``add_line``, shown in the error message.
+
+	Raises
+	------
+	RefusedSettingError
+		When the first chart is not a LineChart, a BarChart or a ScatterChart, or draws horizontal bars.
+
+	Examples
+	--------
+	>>> import numdaplot as ndp
+	>>> from numdaplot.plots.chart_layer import ChartLayer
+	>>> from numdaplot.plots.data.sample_values import read_sample_values
+	>>> from numdaplot.plots.overlay_checks import require_overlay_base
+	>>> prices = ndp.Array.from_list([12.0, 15.5])
+	>>> layer = ChartLayer(ndp.BoxChart(), read_sample_values(prices, None, None, "BoxChart"))
+	>>> try:
+	... 	require_overlay_base(layer, "add_line")
+	... except ndp.RefusedSettingError as error:
+	... 	print(error)
+	add_line does not accept a Plot of BoxChart.
+	"""
+	chart = first_layer.chart
+	if not isinstance(chart, OVERLAID_CHARTS):
+		chart_class = type(chart)
+		plot_name = PLOT_NAME.format(chart_name=chart_class.__name__)
+		raise RefusedSettingError(plot_name, method_name)
+
+	draws_horizontal_bars = is_horizontal_bar_chart(chart)
+	if draws_horizontal_bars:
+		raise RefusedSettingError(HORIZONTAL_BARS_NAME, method_name)
+
+
+def require_vertical_bars(chart: BarChart, method_name: str) -> None:
+	"""
+	Check that bars added to a Plot are vertical, their ``x`` values sharing the horizontal axis.
+
+	.. versionadded:: 0.1.0
+
+	Parameters
+	----------
+	chart
+		The bars added.
+	method_name
+		The method adding them, shown in the error message.
+
+	Raises
+	------
+	RefusedSettingError
+		When the bars are horizontal.
+
+	Examples
+	--------
+	>>> import numdaplot as ndp
+	>>> from numdaplot.plots.overlay_checks import require_vertical_bars
+	>>> try:
+	... 	require_vertical_bars(ndp.BarChart(orientation=ndp.Orientation.HORIZONTAL), "add_bar")
+	... except ndp.RefusedSettingError as error:
+	... 	print(error)
+	add_bar does not accept Orientation.HORIZONTAL.
+	"""
+	if chart.orientation == Orientation.HORIZONTAL:
+		raise RefusedSettingError(HORIZONTAL_SETTING, method_name)
+
+
+def require_same_positions(first_layer: ChartLayer, added_layer: ChartLayer) -> None:
+	"""
+	Check that a chart added to a Plot has the same kind of ``x`` values as its first chart.
+
+	.. versionadded:: 0.1.0
+
+	Parameters
+	----------
+	first_layer
+		The first chart of the Plot and its values.
+	added_layer
+		The chart added and its values.
+
+	Raises
+	------
+	IncompatibleChartsError
+		When one has numbers, dates or texts and the other another kind.
+
+	Examples
+	--------
+	>>> import numdaplot as ndp
+	>>> from numdaplot.plots.chart_layer import ChartLayer
+	>>> from numdaplot.plots.data.array_values import read_array_values
+	>>> from numdaplot.plots.overlay_checks import require_same_positions
+	>>> prices = ndp.Array.from_list([12.0, 15.5])
+	>>> layer = ChartLayer(ndp.LineChart(), read_array_values(prices, "LineChart"))
+	>>> require_same_positions(layer, layer)
+	"""
+	first_values = cast(ChartValues, first_layer.values)
+	added_values = cast(ChartValues, added_layer.values)
+	plot_kind = first_values.positions.kind
+	added_kind = added_values.positions.kind
+	if added_kind == plot_kind:
+		return
+
+	added_class = type(added_layer.chart)
+	added_name = POSITION_NAMES[added_kind]
+	plot_name = POSITION_NAMES[plot_kind]
+	raise IncompatibleChartsError(added_class.__name__, added_name, plot_name)
+
+
+def require_same_values(layers: list[ChartLayer], added_layer: ChartLayer, axis: ValueAxis) -> None:
+	"""
+	Check that a chart added to a Plot measures the same kind of values as the charts already on its axis.
+
+	.. versionadded:: 0.1.0
+
+	Parameters
+	----------
+	layers
+		The charts of the Plot and their values.
+	added_layer
+		The chart added and its values.
+	axis
+		The vertical axis the added chart is measured on.
+
+	Raises
+	------
+	IncompatibleChartsError
+		When one measures numbers and the other times of day on the same axis.
+
+	Examples
+	--------
+	>>> from datetime import time
+	>>> import numdaplot as ndp
+	>>> from numdaplot.plots.chart_layer import ChartLayer
+	>>> from numdaplot.plots.data.array_values import read_array_values
+	>>> from numdaplot.plots.overlay_checks import require_same_values
+	>>> counts = ndp.Array.from_list([3.0, 5.0])
+	>>> hours = ndp.Array.from_list([time(8), time(9)])
+	>>> count_line = ChartLayer(ndp.LineChart(), read_array_values(counts, "LineChart"))
+	>>> hour_line = ChartLayer(ndp.LineChart(), read_array_values(hours, "LineChart"))
+	>>> try:
+	... 	require_same_values([count_line], hour_line, ndp.ValueAxis.LEFT)
+	... except ndp.IncompatibleChartsError as error:
+	... 	print(error)
+	A LineChart with times of day on the left axis cannot be added to a Plot with numbers on the left axis.
+	"""
+	added_values = cast(ChartValues, added_layer.values)
+	added_family = find_family(added_values.value_type)
+	axis_name = AXIS_NAMES[axis]
+
+	for layer in layers:
+		if layer.value_axis != axis:
+			continue
+
+		values = cast(ChartValues, layer.values)
+		plot_family = find_family(values.value_type)
+		if plot_family == added_family:
+			return
+
+		added_class = type(added_layer.chart)
+		added_value_name = VALUE_NAMES[added_family]
+		plot_value_name = VALUE_NAMES[plot_family]
+		added_name = VALUE_DESCRIPTION.format(value_name=added_value_name, axis_name=axis_name)
+		plot_name = VALUE_DESCRIPTION.format(value_name=plot_value_name, axis_name=axis_name)
+		raise IncompatibleChartsError(added_class.__name__, added_name, plot_name)
+
+
+def is_horizontal_bar_chart(chart: Chart) -> bool:
+	"""
+	Return whether a chart draws horizontal bars.
+
+	.. versionadded:: 0.1.0
+
+	Parameters
+	----------
+	chart
+		Any chart.
+
+	Returns
+	-------
+	bool
+		True for a BarChart of horizontal bars.
+
+	Examples
+	--------
+	>>> import numdaplot as ndp
+	>>> from numdaplot.plots.overlay_checks import is_horizontal_bar_chart
+	>>> is_horizontal_bar_chart(ndp.BarChart(orientation=ndp.Orientation.HORIZONTAL))
+	True
+	"""
+	if not isinstance(chart, BarChart):
+		return False
+
+	is_horizontal = chart.orientation == Orientation.HORIZONTAL
+
+	return is_horizontal

numdaplot/plots/plot.py

@@ -0,0 +1,31 @@
+"""
+The ``ndp.Plot`` class: a drawn view of a Table or an Array.
+
+.. versionadded:: 0.1.0
+"""
+
+from numdaplot.plots.plot_distribution_creation import PlotDistributionCreation
+from numdaplot.plots.plot_output import PlotOutput
+from numdaplot.plots.plot_overlays import PlotOverlays
+from numdaplot.plots.plot_overview_creation import PlotOverviewCreation
+from numdaplot.plots.plot_series_creation import PlotSeriesCreation
+
+
+class Plot(PlotSeriesCreation, PlotDistributionCreation, PlotOverviewCreation, PlotOverlays, PlotOutput):
+	"""
+	A drawn view of a Table or an Array, made by creation methods such as ``Plot.line``.
+
+	A Plot is immutable: it keeps the values it was made from, so changing the data afterwards never changes it.
+	It is only displayed by ``show``, never on its own in a notebook.
+
+	Calling ``ndp.Plot(...)`` is refused with ``RefusedOperationError``, which names the methods to use instead.
+
+	.. versionadded:: 0.1.0
+
+	Examples
+	--------
+	>>> import numdaplot as ndp
+	>>> prices = ndp.Array.from_list([12.0, 15.5, 14.0, 17.0])
+	>>> plot = ndp.Plot.line(prices)
+	>>> plot.show()
+	"""

numdaplot/plots/plot_data.py

@@ -0,0 +1,140 @@
+"""
+Charts and style stored by a Plot, shared by every group of Plot methods.
+
+.. versionadded:: 0.1.0
+"""
+
+from typing import Never, Self
+
+from matplotlib.figure import FigureBase
+
+from numdaplot.errors.refused_operation_error import RefusedOperationError
+from numdaplot.plots.chart_layer import ChartLayer
+from numdaplot.plots.data.shown_columns import require_distinct_shown_names
+from numdaplot.plots.drawing.plot_drawing import FigureDrawing, draw_plot
+from numdaplot.plots.drawing.size_inches import convert_size_to_inches
+from numdaplot.plots.style.plot_style import PlotStyle
+
+CONSTRUCTOR_OPERATION = "Creating a Plot with ndp.Plot(...)"
+CONSTRUCTOR_ALTERNATIVE = "ndp.Plot.line, bar, scatter, histogram, box, pie, heatmap, missing_by_column or missing_map"
+
+
+class PlotData:
+	"""
+	Charts and style stored by a Plot, shared by every group of Plot methods.
+
+	Use ``ndp.Plot`` and its creation methods; this base class only holds the charts and the style.
+
+	.. versionadded:: 0.1.0
+	"""
+
+	_layers: list[ChartLayer]
+	_style: PlotStyle
+
+	def __init__(self, *arguments: Never, **keyword_arguments: Never) -> None:
+		"""
+		Refuse the creation of a Plot by its constructor: the creation methods such as ``line`` create Plots.
+
+		.. versionadded:: 0.1.0
+
+		Parameters
+		----------
+		arguments
+			Any value, refused.
+		keyword_arguments
+			Any named value, refused.
+
+		Raises
+		------
+		RefusedOperationError
+			Always, naming the creation methods.
+		"""
+		raise RefusedOperationError(CONSTRUCTOR_OPERATION, CONSTRUCTOR_ALTERNATIVE)
+
+	@classmethod
+	def _create(cls, layers: list[ChartLayer], style: PlotStyle) -> Self:
+		"""
+		Return a new Plot keeping the charts and the style.
+
+		.. versionadded:: 0.1.0
+
+		Parameters
+		----------
+		layers
+			The charts and their values, made by the creation methods, the first one giving the default labels.
+			The Plot keeps its own copy of the list.
+		style
+			The look of the Plot.
+
+		Returns
+		-------
+		Self
+			The new Plot.
+
+		Raises
+		------
+		DuplicateColumnError
+			When the style shows a column under the name of another column of the charts.
+		"""
+		require_distinct_shown_names(layers, style.renaming)
+		created_plot = cls.__new__(cls)
+		created_plot._layers = list(layers)
+		created_plot._style = style
+
+		return created_plot
+
+	@classmethod
+	def _create_from_layer(cls, layer: ChartLayer, style: PlotStyle | None) -> Self:
+		"""
+		Return a new Plot drawing one chart, with the default ``PlotStyle`` when none is given.
+
+		.. versionadded:: 0.1.0
+
+		Parameters
+		----------
+		layer
+			The chart and its values.
+		style
+			The look of the Plot, or None for the default ``PlotStyle``.
+
+		Returns
+		-------
+		Self
+			The Plot of the chart.
+		"""
+		chosen_style = style
+		if chosen_style is None:
+			chosen_style = PlotStyle()
+
+		created_plot = cls._create([layer], chosen_style)
+
+		return created_plot
+
+	def _draw_on(self, target: FigureBase) -> None:
+		"""
+		Draw the Plot on an empty matplotlib figure or subfigure, as ``show``, ``save`` and ``Figure`` do.
+
+		.. versionadded:: 0.1.0
+
+		Parameters
+		----------
+		target
+			The figure or subfigure drawn on.
+		"""
+		draw_plot(target, self._layers, self._style)
+
+	def _describe_drawing(self) -> FigureDrawing:
+		"""
+		Return what the Plot draws, and the size of its style.
+
+		.. versionadded:: 0.1.0
+
+		Returns
+		-------
+		FigureDrawing
+			The drawing of the Plot.
+		"""
+		size_inches = convert_size_to_inches(self._style.size)
+		drawing = FigureDrawing(self._draw_on, size_inches)
+
+		return drawing

numdaplot/plots/plot_distribution_creation.py

@@ -0,0 +1,237 @@
+"""
+Creation of a Plot showing how values are spread or shared out.
+
+.. versionadded:: 0.1.0
+"""
+
+from typing import Self
+
+from numdaplot.arrays.array import Array
+from numdaplot.plots.chart_layer import ChartLayer
+from numdaplot.plots.charts.box_chart import BoxChart
+from numdaplot.plots.charts.histogram_chart import HistogramChart
+from numdaplot.plots.charts.pie_chart import PieChart
+from numdaplot.plots.data.pie_values import read_pie_values
+from numdaplot.plots.data.sample_values import read_sample_values
+from numdaplot.plots.drawing.histogram_drawing import require_bins_on_values
+from numdaplot.plots.drawing.series_colors import require_color_count
+from numdaplot.plots.plot_data import PlotData
+from numdaplot.plots.style.axis_settings import require_no_axis_settings
+from numdaplot.plots.style.plot_style import PlotStyle
+from numdaplot.settings.argument_types import checked_arguments
+from numdaplot.tables.table import Table
+
+HISTOGRAM_CHART_NAME = "HistogramChart"
+BOX_CHART_NAME = "BoxChart"
+
+
+class PlotDistributionCreation(PlotData):
+	"""
+	Creation of a Plot showing how values are spread or shared out.
+
+	Use ``ndp.Plot.histogram``, ``ndp.Plot.box`` and ``ndp.Plot.pie``.
+
+	.. versionadded:: 0.1.0
+	"""
+
+	@classmethod
+	@checked_arguments
+	def histogram(
+		cls, data: Table | Array, chart: HistogramChart | None = None, style: PlotStyle | None = None
+	) -> Self:
+		"""
+		Return a Plot drawing how many values of columns of numbers or times of day fall in each bin.
+
+		For a Table, ``HistogramChart.columns`` names the columns drawn. For an Array of one or two dimensions, each
+		column is drawn. Several columns share the same bins.
+
+		.. versionadded:: 0.1.0
+
+		Parameters
+		----------
+		data
+			The Table or the Array drawn.
+		chart
+			The columns drawn, the bins, the measure and the colors.
+			The default ``HistogramChart`` when omitted, which draws an Array: a Table needs the columns named.
+		style
+			The look of the Plot, the default ``PlotStyle`` when omitted.
+
+		Returns
+		-------
+		Self
+			The Plot, which ``show`` displays and ``save`` writes as an image.
+
+		Raises
+		------
+		InvalidTypeError
+			When an argument is not of the type its annotation names.
+		InvalidChartDataError
+			When a Table has no ``columns``, or an Array has ``columns``.
+		ColumnNotFoundError
+			When a column does not exist.
+		IncompatibleTypesError
+			When a drawn column holds neither numbers nor times of day, the columns mix them, or the width of the bins
+			is a number for times of day or a duration for numbers.
+		DimensionError
+			When an Array has more than two dimensions.
+		InvalidColorCountError
+			When the colors of the chart are not one per column.
+
+		Examples
+		--------
+		>>> import numdaplot as ndp
+		>>> prices = ndp.Array.from_list([12.0, 15.5, 14.0, 17.0, 13.5, 16.0, 14.5, 15.0, 18.5, 11.0])
+		>>> flats = ndp.Table.from_arrays({"price": prices})
+		>>> chart = ndp.HistogramChart(columns=["price"], bins=ndp.BinWidth(2.0), measure=ndp.Measure.RATIO)
+		>>> style = ndp.PlotStyle(title="Prices", x_label="Price (euros)")
+		>>> plot = ndp.Plot.histogram(flats, chart, style)
+		>>> plot.show()
+		"""
+		if chart is None:
+			chart = HistogramChart()
+
+		values = read_sample_values(data, chart.columns, None, HISTOGRAM_CHART_NAME)
+		require_bins_on_values(chart.bins, values.value_type)
+		series_count = len(values.series)
+		require_color_count(chart.colors, series_count)
+		layer = ChartLayer(chart, values)
+		plot = cls._create_from_layer(layer, style)
+
+		return plot
+
+	@classmethod
+	@checked_arguments
+	def box(cls, data: Table | Array, chart: BoxChart | None = None, style: PlotStyle | None = None) -> Self:
+		"""
+		Return a Plot summing up the spread of columns of numbers or times of day as boxes.
+
+		For a Table, ``BoxChart.columns`` names the columns drawn, and ``BoxChart.group_by`` may split their rows into
+		groups. For an Array of one or two dimensions, each column is a box.
+
+		.. versionadded:: 0.1.0
+
+		Parameters
+		----------
+		data
+			The Table or the Array drawn.
+		chart
+			The columns drawn, their groups, the outliers and the colors.
+			The default ``BoxChart`` when omitted, which draws an Array: a Table needs the columns named.
+		style
+			The look of the Plot, the default ``PlotStyle`` when omitted.
+
+		Returns
+		-------
+		Self
+			The Plot, which ``show`` displays and ``save`` writes as an image.
+
+		Raises
+		------
+		InvalidTypeError
+			When an argument is not of the type its annotation names.
+		InvalidChartDataError
+			When a Table has no ``columns``, or an Array has ``columns`` or ``group_by``.
+		ColumnNotFoundError
+			When a column does not exist.
+		IncompatibleTypesError
+			When a drawn column holds neither numbers nor times of day, the columns mix them, or ``group_by`` holds
+			neither texts, booleans nor times of day.
+		DimensionError
+			When an Array has more than two dimensions.
+		InvalidColorCountError
+			When the colors of the chart are not one per column.
+
+		Examples
+		--------
+		>>> import numdaplot as ndp
+		>>> cities = ndp.Array.from_list(["Paris", "Lyon", "Pau", "Paris", "Lyon", "Pau", "Paris", "Lyon", "Pau"])
+		>>> prices = ndp.Array.from_list([14.0, 9.5, 7.0, 16.5, 10.0, 8.5, 15.0, 11.5, 6.0])
+		>>> flats = ndp.Table.from_arrays({"city": cities, "price": prices})
+		>>> chart = ndp.BoxChart(columns=["price"], group_by="city")
+		>>> style = ndp.PlotStyle(y_label="Price per night (euros)")
+		>>> plot = ndp.Plot.box(flats, chart, style)
+		>>> plot.show()
+		"""
+		if chart is None:
+			chart = BoxChart()
+
+		values = read_sample_values(data, chart.columns, chart.group_by, BOX_CHART_NAME)
+		series_count = len(values.series)
+		require_color_count(chart.colors, series_count)
+		layer = ChartLayer(chart, values)
+		plot = cls._create_from_layer(layer, style)
+
+		return plot
+
+	@classmethod
+	@checked_arguments
+	def pie(cls, table: Table, chart: PieChart, style: PlotStyle | None = None) -> Self:
+		"""
+		Return a Plot sharing out the values of a column of a Table as slices of a disc.
+
+		``PieChart.labels`` names the column of texts labeling the slices and ``PieChart.values`` the column of numbers
+		sizing them. A Plot of a pie has no axes, so its style takes no axis label.
+
+		.. versionadded:: 0.1.0
+
+		Parameters
+		----------
+		table
+			The Table drawn.
+		chart
+			The labels, the values, the percentages and the colors.
+		style
+			The look of the Plot, the default ``PlotStyle`` when omitted.
+
+		Returns
+		-------
+		Self
+			The Plot, which ``show`` displays and ``save`` writes as an image.
+
+		Raises
+		------
+		InvalidTypeError
+			When an argument is not of the type its annotation names.
+		ColumnNotFoundError
+			When a column does not exist.
+		IncompatibleTypesError
+			When ``labels`` does not hold texts, or ``values`` does not hold numbers.
+		MissingValueError
+			When a label or a value is missing.
+		OutOfDomainError
+			When a value is negative.
+		EmptyTotalError
+			When the values add up to 0.
+		DuplicateLabelError
+			When two slices have the same label.
+		InvalidColorCountError
+			When the colors of the chart are not one per slice.
+		RefusedSettingError
+			When the style has an axis setting: ``x_label``, ``y_label``, ``right_label``, ``x_tick_rotation`` or
+			``y_tick_rotation``.
+
+		Warns
+		-----
+		ReadabilityWarning
+			When there are more than 5 slices.
+
+		Examples
+		--------
+		>>> import numdaplot as ndp
+		>>> devices = ndp.Array.from_list(["Phone", "Computer", "Tablet"])
+		>>> visits = ndp.Array.from_list([5400.0, 3100.0, 900.0])
+		>>> traffic = ndp.Table.from_arrays({"device": devices, "visits": visits})
+		>>> chart = ndp.PieChart(labels="device", values="visits")
+		>>> style = ndp.PlotStyle(title="Visits per device")
+		>>> plot = ndp.Plot.pie(traffic, chart, style)
+		>>> plot.show()
+		"""
+		values = read_pie_values(table, chart)
+		slice_count = len(values.rows)
+		require_color_count(chart.colors, slice_count)
+		require_no_axis_settings(style)
+		layer = ChartLayer(chart, values)
+		plot = cls._create_from_layer(layer, style)
+
+		return plot