diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index fc5f08233..e22134769 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -7,7 +7,7 @@ jobs: runs-on: ubuntu-latest strategy: matrix: - python-version: ["3.8", "3.9", "3.10", "3.11", "3.12"] + python-version: ["3.9", "3.10", "3.11", "3.12"] jsonschema-version: ["3.0", "latest"] name: py ${{ matrix.python-version }} js ${{ matrix.jsonschema-version }} steps: @@ -28,18 +28,18 @@ jobs: - name: Maybe uninstall optional dependencies # We uninstall pyarrow and vegafusion for one job to test that we have not # accidentally introduced a hard dependency on these libraries. - # Uninstalling for Python 3.8 is an arbitrary choice. + # Uninstalling for Python 3.9 is an arbitrary choice. # Also see https://github.com/vega/altair/pull/3114 - if: ${{ matrix.python-version == '3.8' }} + if: ${{ matrix.python-version == '3.9' }} run: | pip uninstall -y pyarrow vegafusion vegafusion-python-embed vl-convert-python anywidget - name: Maybe install lowest supported pandas version # We install the lowest supported pandas version for one job to test that # it still works. Downgrade to the oldest versions of pandas and numpy that include - # Python 3.8 wheels, so only run this job for Python 3.8 - if: ${{ matrix.python-version == '3.8' }} + # Python 3.9 wheels, so only run this job for Python 3.9 + if: ${{ matrix.python-version == '3.9' }} run: | - pip install pandas==0.25.3 numpy==1.17.5 + pip install pandas==1.1.3 numpy==1.19.3 - name: Test that schema generation has no effect run: | pip install vl-convert-python diff --git a/altair/expr/__init__.py b/altair/expr/__init__.py index 1f93ac2b7..38d87f4c5 100644 --- a/altair/expr/__init__.py +++ b/altair/expr/__init__.py @@ -1,8 +1,12 @@ +# The contents of this file are automatically written by +# tools/generate_schema_wrapper.py. Do not modify directly. + """Tools for creating transform & filter expressions with a python syntax.""" from __future__ import annotations import sys +from typing import TYPE_CHECKING, Any from altair.expr.core import ConstExpression, FunctionExpression from altair.vegalite.v5.schema.core import ExprRef as _ExprRef @@ -12,58 +16,65 @@ else: from typing_extensions import override +if TYPE_CHECKING: + from altair.expr.core import Expression, IntoExpression + + +class _ExprMeta(type): + """ + Metaclass for :class:`expr`. -class _ConstExpressionType(type): - """Metaclass providing read-only class properties for :class:`expr`.""" + Currently providing read-only class properties, representing JavaScript constants. + """ @property - def NaN(cls) -> ConstExpression: + def NaN(cls) -> Expression: """Not a number (same as JavaScript literal NaN).""" return ConstExpression("NaN") @property - def LN10(cls) -> ConstExpression: + def LN10(cls) -> Expression: """The natural log of 10 (alias to Math.LN10).""" return ConstExpression("LN10") @property - def E(cls) -> ConstExpression: + def E(cls) -> Expression: """The transcendental number e (alias to Math.E).""" return ConstExpression("E") @property - def LOG10E(cls) -> ConstExpression: + def LOG10E(cls) -> Expression: """The base 10 logarithm e (alias to Math.LOG10E).""" return ConstExpression("LOG10E") @property - def LOG2E(cls) -> ConstExpression: + def LOG2E(cls) -> Expression: """The base 2 logarithm of e (alias to Math.LOG2E).""" return ConstExpression("LOG2E") @property - def SQRT1_2(cls) -> ConstExpression: + def SQRT1_2(cls) -> Expression: """The square root of 0.5 (alias to Math.SQRT1_2).""" return ConstExpression("SQRT1_2") @property - def LN2(cls) -> ConstExpression: + def LN2(cls) -> Expression: """The natural log of 2 (alias to Math.LN2).""" return ConstExpression("LN2") @property - def SQRT2(cls) -> ConstExpression: + def SQRT2(cls) -> Expression: """The square root of 2 (alias to Math.SQRT1_2).""" return ConstExpression("SQRT2") @property - def PI(cls) -> ConstExpression: + def PI(cls) -> Expression: """The transcendental number pi (alias to Math.PI).""" return ConstExpression("PI") -class expr(_ExprRef, metaclass=_ConstExpressionType): - r""" +class expr(_ExprRef, metaclass=_ExprMeta): + """ Utility providing *constants* and *classmethods* to construct expressions. `Expressions`_ can be used to write basic formulas that enable custom interactions. @@ -110,1321 +121,1803 @@ class expr(_ExprRef, metaclass=_ConstExpressionType): @override def __new__(cls: type[_ExprRef], expr: str) -> _ExprRef: # type: ignore[misc] - # NOTE: `mypy<=1.10.1` is not consistent with typing spec - # https://github.com/python/mypy/issues/1020 - # https://docs.python.org/3/reference/datamodel.html#object.__new__ - # https://typing.readthedocs.io/en/latest/spec/constructors.html#new-method return _ExprRef(expr=expr) @classmethod - def if_(cls, *args) -> FunctionExpression: - """ - If *test* is truthy, returns *thenValue*. Otherwise, returns *elseValue*. - - The *if* function is equivalent to the ternary operator `a ? b : c`. - """ - return FunctionExpression("if", args) + def isArray(cls, value: IntoExpression, /) -> Expression: + """Returns true if ``value`` is an array, false otherwise.""" + return FunctionExpression("isArray", (value,)) @classmethod - def isArray(cls, *args) -> FunctionExpression: - """Returns true if *value* is an array, false otherwise.""" - return FunctionExpression("isArray", args) + def isBoolean(cls, value: IntoExpression, /) -> Expression: + """Returns true if ``value`` is a boolean (``true`` or ``false``), false otherwise.""" + return FunctionExpression("isBoolean", (value,)) @classmethod - def isBoolean(cls, *args) -> FunctionExpression: - """Returns true if *value* is a boolean (`true` or `false`), false otherwise.""" - return FunctionExpression("isBoolean", args) - - @classmethod - def isDate(cls, *args) -> FunctionExpression: + def isDate(cls, value: IntoExpression, /) -> Expression: """ - Returns true if *value* is a Date object, false otherwise. + Returns true if ``value`` is a Date object, false otherwise. - This method will return false for timestamp numbers or date-formatted strings; it recognizes Date objects only. + This method will return false for timestamp numbers or date-formatted strings; it recognizes + Date objects only. """ - return FunctionExpression("isDate", args) + return FunctionExpression("isDate", (value,)) @classmethod - def isDefined(cls, *args) -> FunctionExpression: + def isDefined(cls, value: IntoExpression, /) -> Expression: """ - Returns true if *value* is a defined value, false if *value* equals `undefined`. + Returns true if ``value`` is a defined value, false if ``value`` equals ``undefined``. - This method will return true for `null` and `NaN` values. + This method will return true for ``null`` and ``NaN`` values. """ - return FunctionExpression("isDefined", args) + return FunctionExpression("isDefined", (value,)) @classmethod - def isNumber(cls, *args) -> FunctionExpression: + def isNumber(cls, value: IntoExpression, /) -> Expression: """ - Returns true if *value* is a number, false otherwise. + Returns true if ``value`` is a number, false otherwise. - `NaN` and `Infinity` are considered numbers. + ``NaN`` and ``Infinity`` are considered numbers. """ - return FunctionExpression("isNumber", args) + return FunctionExpression("isNumber", (value,)) + + @classmethod + def isObject(cls, value: IntoExpression, /) -> Expression: + """Returns true if ``value`` is an object (including arrays and Dates), false otherwise.""" + return FunctionExpression("isObject", (value,)) @classmethod - def isObject(cls, *args) -> FunctionExpression: - """Returns true if *value* is an object (including arrays and Dates), false otherwise.""" - return FunctionExpression("isObject", args) + def isRegExp(cls, value: IntoExpression, /) -> Expression: + """Returns true if ``value`` is a RegExp (regular expression) object, false otherwise.""" + return FunctionExpression("isRegExp", (value,)) @classmethod - def isRegExp(cls, *args) -> FunctionExpression: - """Returns true if *value* is a RegExp (regular expression) object, false otherwise.""" - return FunctionExpression("isRegExp", args) + def isString(cls, value: IntoExpression, /) -> Expression: + """Returns true if ``value`` is a string, false otherwise.""" + return FunctionExpression("isString", (value,)) @classmethod - def isString(cls, *args) -> FunctionExpression: - """Returns true if *value* is a string, false otherwise.""" - return FunctionExpression("isString", args) + def isValid(cls, value: IntoExpression, /) -> Expression: + """Returns true if ``value`` is not ``null``, ``undefined``, or ``NaN``, false otherwise.""" + return FunctionExpression("isValid", (value,)) @classmethod - def isValid(cls, *args) -> FunctionExpression: - """Returns true if *value* is not `null`, `undefined`, or `NaN`, false otherwise.""" - return FunctionExpression("isValid", args) + def toBoolean(cls, value: IntoExpression, /) -> Expression: + """ + Coerces the input ``value`` to a string. + + Null values and empty strings are mapped to ``null``. + """ + return FunctionExpression("toBoolean", (value,)) @classmethod - def toBoolean(cls, *args) -> FunctionExpression: + def toDate(cls, value: IntoExpression, /) -> Expression: """ - Coerces the input *value* to a string. + Coerces the input ``value`` to a Date instance. - Null values and empty strings are mapped to `null`. + Null values and empty strings are mapped to ``null``. If an optional *parser* function is + provided, it is used to perform date parsing, otherwise ``Date.parse`` is used. Be aware + that ``Date.parse`` has different implementations across browsers! """ - return FunctionExpression("toBoolean", args) + return FunctionExpression("toDate", (value,)) @classmethod - def toDate(cls, *args) -> FunctionExpression: + def toNumber(cls, value: IntoExpression, /) -> Expression: """ - Coerces the input *value* to a Date instance. + Coerces the input ``value`` to a number. - Null values and empty strings are mapped to `null`. - If an optional *parser* function is provided, it is used to perform date parsing, otherwise `Date.parse` is used. - Be aware that `Date.parse` has different implementations across browsers! + Null values and empty strings are mapped to ``null``. """ - return FunctionExpression("toDate", args) + return FunctionExpression("toNumber", (value,)) @classmethod - def toNumber(cls, *args) -> FunctionExpression: + def toString(cls, value: IntoExpression, /) -> Expression: """ - Coerces the input *value* to a number. + Coerces the input ``value`` to a string. - Null values and empty strings are mapped to `null`. + Null values and empty strings are mapped to ``null``. """ - return FunctionExpression("toNumber", args) + return FunctionExpression("toString", (value,)) @classmethod - def toString(cls, *args) -> FunctionExpression: + def if_( + cls, + test: IntoExpression, + thenValue: IntoExpression, + elseValue: IntoExpression, + /, + ) -> Expression: """ - Coerces the input *value* to a string. + If ``test`` is truthy, returns ``thenValue``. - Null values and empty strings are mapped to `null`. + Otherwise, returns ``elseValue``. The *if* function is equivalent to the ternary operator + ``a ? b : c``. """ - return FunctionExpression("toString", args) + return FunctionExpression("if", (test, thenValue, elseValue)) @classmethod - def isNaN(cls, *args) -> FunctionExpression: + def isNaN(cls, value: IntoExpression, /) -> Expression: """ - Returns true if *value* is not a number. + Returns true if ``value`` is not a number. + + Same as JavaScript's `Number.isNaN`_. - Same as JavaScript's `isNaN`. + .. _Number.isNaN: + https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isNan """ - return FunctionExpression("isNaN", args) + return FunctionExpression("isNaN", (value,)) @classmethod - def isFinite(cls, *args) -> FunctionExpression: + def isFinite(cls, value: IntoExpression, /) -> Expression: """ - Returns true if *value* is a finite number. + Returns true if ``value`` is a finite number. + + Same as JavaScript's `Number.isFinite`_. - Same as JavaScript's `isFinite`. + .. _Number.isFinite: + https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isFinite """ - return FunctionExpression("isFinite", args) + return FunctionExpression("isFinite", (value,)) @classmethod - def abs(cls, *args) -> FunctionExpression: + def abs(cls, value: IntoExpression, /) -> Expression: """ - Returns the absolute value of *value*. + Returns the absolute value of ``value``. - Same as JavaScript's `Math.abs`. + Same as JavaScript's `Math.abs`_. + + .. _Math.abs: + https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/abs """ - return FunctionExpression("abs", args) + return FunctionExpression("abs", (value,)) @classmethod - def acos(cls, *args) -> FunctionExpression: + def acos(cls, value: IntoExpression, /) -> Expression: """ Trigonometric arccosine. - Same as JavaScript's `Math.acos`. + Same as JavaScript's `Math.acos`_. + + .. _Math.acos: + https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/acos """ - return FunctionExpression("acos", args) + return FunctionExpression("acos", (value,)) @classmethod - def asin(cls, *args) -> FunctionExpression: + def asin(cls, value: IntoExpression, /) -> Expression: """ Trigonometric arcsine. - Same as JavaScript's `Math.asin`. + Same as JavaScript's `Math.asin`_. + + .. _Math.asin: + https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/asin """ - return FunctionExpression("asin", args) + return FunctionExpression("asin", (value,)) @classmethod - def atan(cls, *args) -> FunctionExpression: + def atan(cls, value: IntoExpression, /) -> Expression: """ Trigonometric arctangent. - Same as JavaScript's `Math.atan`. + Same as JavaScript's `Math.atan`_. + + .. _Math.atan: + https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/atan """ - return FunctionExpression("atan", args) + return FunctionExpression("atan", (value,)) @classmethod - def atan2(cls, *args) -> FunctionExpression: + def atan2(cls, dy: IntoExpression, dx: IntoExpression, /) -> Expression: """ Returns the arctangent of *dy / dx*. - Same as JavaScript's `Math.atan2`. + Same as JavaScript's `Math.atan2`_. + + .. _Math.atan2: + https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/atan2 """ - return FunctionExpression("atan2", args) + return FunctionExpression("atan2", (dy, dx)) @classmethod - def ceil(cls, *args) -> FunctionExpression: + def ceil(cls, value: IntoExpression, /) -> Expression: """ - Rounds *value* to the nearest integer of equal or greater value. + Rounds ``value`` to the nearest integer of equal or greater value. + + Same as JavaScript's `Math.ceil`_. - Same as JavaScript's `Math.ceil`. + .. _Math.ceil: + https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/ceil """ - return FunctionExpression("ceil", args) + return FunctionExpression("ceil", (value,)) @classmethod - def clamp(cls, *args) -> FunctionExpression: - """Restricts *value* to be between the specified *min* and *max*.""" - return FunctionExpression("clamp", args) + def clamp( + cls, value: IntoExpression, min: IntoExpression, max: IntoExpression, / + ) -> Expression: + """Restricts ``value`` to be between the specified ``min`` and ``max``.""" + return FunctionExpression("clamp", (value, min, max)) @classmethod - def cos(cls, *args) -> FunctionExpression: + def cos(cls, value: IntoExpression, /) -> Expression: """ Trigonometric cosine. - Same as JavaScript's `Math.cos`. + Same as JavaScript's `Math.cos`_. + + .. _Math.cos: + https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/cos """ - return FunctionExpression("cos", args) + return FunctionExpression("cos", (value,)) @classmethod - def exp(cls, *args) -> FunctionExpression: + def exp(cls, exponent: IntoExpression, /) -> Expression: """ - Returns the value of *e* raised to the provided *exponent*. + Returns the value of *e* raised to the provided ``exponent``. + + Same as JavaScript's `Math.exp`_. - Same as JavaScript's `Math.exp`. + .. _Math.exp: + https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/exp """ - return FunctionExpression("exp", args) + return FunctionExpression("exp", (exponent,)) @classmethod - def floor(cls, *args) -> FunctionExpression: + def floor(cls, value: IntoExpression, /) -> Expression: """ - Rounds *value* to the nearest integer of equal or lower value. + Rounds ``value`` to the nearest integer of equal or lower value. + + Same as JavaScript's `Math.floor`_. - Same as JavaScript's `Math.floor`. + .. _Math.floor: + https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/floor """ - return FunctionExpression("floor", args) + return FunctionExpression("floor", (value,)) @classmethod - def hypot(cls, *args) -> FunctionExpression: + def hypot(cls, value: IntoExpression, /) -> Expression: """ Returns the square root of the sum of squares of its arguments. - Same as JavaScript's `Math.hypot`. + Same as JavaScript's `Math.hypot`_. + + .. _Math.hypot: + https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/hypot """ - return FunctionExpression("hypot", args) + return FunctionExpression("hypot", (value,)) @classmethod - def log(cls, *args) -> FunctionExpression: + def log(cls, value: IntoExpression, /) -> Expression: """ - Returns the natural logarithm of *value*. + Returns the natural logarithm of ``value``. + + Same as JavaScript's `Math.log`_. - Same as JavaScript's `Math.log`. + .. _Math.log: + https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/log """ - return FunctionExpression("log", args) + return FunctionExpression("log", (value,)) @classmethod - def max(cls, *args) -> FunctionExpression: + def max( + cls, value1: IntoExpression, value2: IntoExpression, *args: Any + ) -> Expression: """ Returns the maximum argument value. - Same as JavaScript's `Math.max`. + Same as JavaScript's `Math.max`_. + + .. _Math.max: + https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/max """ - return FunctionExpression("max", args) + return FunctionExpression("max", (value1, value2, *args)) @classmethod - def min(cls, *args) -> FunctionExpression: + def min( + cls, value1: IntoExpression, value2: IntoExpression, *args: Any + ) -> Expression: """ Returns the minimum argument value. - Same as JavaScript's `Math.min`. + Same as JavaScript's `Math.min`_. + + .. _Math.min: + https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/min """ - return FunctionExpression("min", args) + return FunctionExpression("min", (value1, value2, *args)) @classmethod - def pow(cls, *args) -> FunctionExpression: + def pow(cls, value: IntoExpression, exponent: IntoExpression, /) -> Expression: """ - Returns *value* raised to the given *exponent*. + Returns ``value`` raised to the given ``exponent``. + + Same as JavaScript's `Math.pow`_. - Same as JavaScript's `Math.pow`. + .. _Math.pow: + https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/pow """ - return FunctionExpression("pow", args) + return FunctionExpression("pow", (value, exponent)) @classmethod - def random(cls, *args) -> FunctionExpression: + def random(cls) -> Expression: """ - Returns a pseudo-random number in the range `[0, 1]`. + Returns a pseudo-random number in the range [0,1). + + Same as JavaScript's `Math.random`_. - Same as JavaScript's `Math.random`. + .. _Math.random: + https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/random """ - return FunctionExpression("random", args) + return FunctionExpression("random", ()) @classmethod - def round(cls, *args) -> FunctionExpression: + def round(cls, value: IntoExpression, /) -> Expression: """ - Rounds *value* to the nearest integer. + Rounds ``value`` to the nearest integer. - Same as JavaScript's `Math.round`. + Same as JavaScript's `Math.round`_. + + .. _Math.round: + https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/round """ - return FunctionExpression("round", args) + return FunctionExpression("round", (value,)) @classmethod - def sin(cls, *args) -> FunctionExpression: + def sin(cls, value: IntoExpression, /) -> Expression: """ Trigonometric sine. - Same as JavaScript's `Math.sin`. + Same as JavaScript's `Math.sin`_. + + .. _Math.sin: + https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/sin """ - return FunctionExpression("sin", args) + return FunctionExpression("sin", (value,)) @classmethod - def sqrt(cls, *args) -> FunctionExpression: + def sqrt(cls, value: IntoExpression, /) -> Expression: """ Square root function. - Same as JavaScript's `Math.sqrt`. + Same as JavaScript's `Math.sqrt`_. + + .. _Math.sqrt: + https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/sqrt """ - return FunctionExpression("sqrt", args) + return FunctionExpression("sqrt", (value,)) @classmethod - def tan(cls, *args) -> FunctionExpression: + def tan(cls, value: IntoExpression, /) -> Expression: """ Trigonometric tangent. - Same as JavaScript's `Math.tan`. + Same as JavaScript's `Math.tan`_. + + .. _Math.tan: + https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/tan """ - return FunctionExpression("tan", args) + return FunctionExpression("tan", (value,)) @classmethod - def sampleNormal(cls, *args) -> FunctionExpression: + def sampleNormal( + cls, mean: IntoExpression = None, stdev: IntoExpression = None, / + ) -> Expression: """ - Returns a sample from a univariate `normal (Gaussian) probability distribution `__ with specified *mean* and standard deviation *stdev*. + Returns a sample from a univariate `normal (Gaussian) probability distribution`_ with specified ``mean`` and standard deviation ``stdev``. + + If unspecified, the mean defaults to ``0`` and the standard deviation defaults to ``1``. - If unspecified, the mean defaults to `0` and the standard deviation defaults to `1`. + .. _normal (Gaussian) probability distribution: + https://en.wikipedia.org/wiki/Normal_distribution """ - return FunctionExpression("sampleNormal", args) + return FunctionExpression("sampleNormal", (mean, stdev)) @classmethod - def cumulativeNormal(cls, *args) -> FunctionExpression: + def cumulativeNormal( + cls, + value: IntoExpression, + mean: IntoExpression = None, + stdev: IntoExpression = None, + /, + ) -> Expression: """ - Returns the value of the `cumulative distribution function `__ at the given input domain *value* for a normal distribution with specified *mean* and standard deviation *stdev*. + Returns the value of the `cumulative distribution function`_ at the given input domain ``value`` for a normal distribution with specified ``mean`` and standard deviation ``stdev``. + + If unspecified, the mean defaults to ``0`` and the standard deviation defaults to ``1``. - If unspecified, the mean defaults to `0` and the standard deviation defaults to `1`. + .. _cumulative distribution function: + https://en.wikipedia.org/wiki/Cumulative_distribution_function """ - return FunctionExpression("cumulativeNormal", args) + return FunctionExpression("cumulativeNormal", (value, mean, stdev)) @classmethod - def densityNormal(cls, *args) -> FunctionExpression: + def densityNormal( + cls, + value: IntoExpression, + mean: IntoExpression = None, + stdev: IntoExpression = None, + /, + ) -> Expression: """ - Returns the value of the `probability density function `__ at the given input domain *value*, for a normal distribution with specified *mean* and standard deviation *stdev*. + Returns the value of the `probability density function`_ at the given input domain ``value``, for a normal distribution with specified ``mean`` and standard deviation ``stdev``. - If unspecified, the mean defaults to `0` and the standard deviation defaults to `1`. + If unspecified, the mean defaults to ``0`` and the standard deviation defaults to ``1``. + + .. _probability density function: + https://en.wikipedia.org/wiki/Probability_density_function """ - return FunctionExpression("densityNormal", args) + return FunctionExpression("densityNormal", (value, mean, stdev)) @classmethod - def quantileNormal(cls, *args) -> FunctionExpression: + def quantileNormal( + cls, + probability: IntoExpression, + mean: IntoExpression = None, + stdev: IntoExpression = None, + /, + ) -> Expression: """ - Returns the quantile value (the inverse of the `cumulative distribution function `__ for the given input *probability*, for a normal distribution with specified *mean* and standard deviation *stdev*. + Returns the quantile value (the inverse of the `cumulative distribution function`_) for the given input ``probability``, for a normal distribution with specified ``mean`` and standard deviation ``stdev``. + + If unspecified, the mean defaults to ``0`` and the standard deviation defaults to ``1``. - If unspecified, the mean defaults to `0` and the standard deviation defaults to `1`. + .. _cumulative distribution function: + https://en.wikipedia.org/wiki/Cumulative_distribution_function """ - return FunctionExpression("quantileNormal", args) + return FunctionExpression("quantileNormal", (probability, mean, stdev)) @classmethod - def sampleLogNormal(cls, *args) -> FunctionExpression: + def sampleLogNormal( + cls, mean: IntoExpression = None, stdev: IntoExpression = None, / + ) -> Expression: """ - Returns a sample from a univariate `log-normal probability distribution `__ with specified log *mean* and log standard deviation *stdev*. + Returns a sample from a univariate `log-normal probability distribution`_ with specified log ``mean`` and log standard deviation ``stdev``. + + If unspecified, the log mean defaults to ``0`` and the log standard deviation defaults to + ``1``. - If unspecified, the log mean defaults to `0` and the log standard deviation defaults to `1`. + .. _log-normal probability distribution: + https://en.wikipedia.org/wiki/Log-normal_distribution """ - return FunctionExpression("sampleLogNormal", args) + return FunctionExpression("sampleLogNormal", (mean, stdev)) @classmethod - def cumulativeLogNormal(cls, *args) -> FunctionExpression: + def cumulativeLogNormal( + cls, + value: IntoExpression, + mean: IntoExpression = None, + stdev: IntoExpression = None, + /, + ) -> Expression: """ - Returns the value of the `cumulative distribution function `__ at the given input domain *value* for a log-normal distribution with specified log *mean* and log standard deviation *stdev*. + Returns the value of the `cumulative distribution function`_ at the given input domain ``value`` for a log-normal distribution with specified log ``mean`` and log standard deviation ``stdev``. - If unspecified, the log mean defaults to `0` and the log standard deviation defaults to `1`. + If unspecified, the log mean defaults to ``0`` and the log standard deviation defaults to + ``1``. + + .. _cumulative distribution function: + https://en.wikipedia.org/wiki/Cumulative_distribution_function """ - return FunctionExpression("cumulativeLogNormal", args) + return FunctionExpression("cumulativeLogNormal", (value, mean, stdev)) @classmethod - def densityLogNormal(cls, *args) -> FunctionExpression: + def densityLogNormal( + cls, + value: IntoExpression, + mean: IntoExpression = None, + stdev: IntoExpression = None, + /, + ) -> Expression: """ - Returns the value of the `probability density function `__ at the given input domain *value*, for a log-normal distribution with specified log *mean* and log standard deviation *stdev*. + Returns the value of the `probability density function`_ at the given input domain ``value``, for a log-normal distribution with specified log ``mean`` and log standard deviation ``stdev``. + + If unspecified, the log mean defaults to ``0`` and the log standard deviation defaults to + ``1``. - If unspecified, the log mean defaults to `0` and the log standard deviation defaults to `1`. + .. _probability density function: + https://en.wikipedia.org/wiki/Probability_density_function """ - return FunctionExpression("densityLogNormal", args) + return FunctionExpression("densityLogNormal", (value, mean, stdev)) @classmethod - def quantileLogNormal(cls, *args) -> FunctionExpression: + def quantileLogNormal( + cls, + probability: IntoExpression, + mean: IntoExpression = None, + stdev: IntoExpression = None, + /, + ) -> Expression: """ - Returns the quantile value (the inverse of the `cumulative distribution function `__ for the given input *probability*, for a log-normal distribution with specified log *mean* and log standard deviation *stdev*. + Returns the quantile value (the inverse of the `cumulative distribution function`_) for the given input ``probability``, for a log-normal distribution with specified log ``mean`` and log standard deviation ``stdev``. + + If unspecified, the log mean defaults to ``0`` and the log standard deviation defaults to + ``1``. - If unspecified, the log mean defaults to `0` and the log standard deviation defaults to `1`. + .. _cumulative distribution function: + https://en.wikipedia.org/wiki/Cumulative_distribution_function """ - return FunctionExpression("quantileLogNormal", args) + return FunctionExpression("quantileLogNormal", (probability, mean, stdev)) @classmethod - def sampleUniform(cls, *args) -> FunctionExpression: + def sampleUniform( + cls, min: IntoExpression = None, max: IntoExpression = None, / + ) -> Expression: """ - Returns a sample from a univariate `continuous uniform probability distribution `__ over the interval `[min, max]`. + Returns a sample from a univariate `continuous uniform probability distribution`_) over the interval [``min``, ``max``). - If unspecified, *min* defaults to `0` and *max* defaults to `1`. - If only one argument is provided, it is interpreted as the *max* value. + If unspecified, ``min`` defaults to ``0`` and ``max`` defaults to ``1``. If only one + argument is provided, it is interpreted as the ``max`` value. + + .. _continuous uniform probability distribution: + https://en.wikipedia.org/wiki/Uniform_distribution_(continuous """ - return FunctionExpression("sampleUniform", args) + return FunctionExpression("sampleUniform", (min, max)) @classmethod - def cumulativeUniform(cls, *args) -> FunctionExpression: + def cumulativeUniform( + cls, + value: IntoExpression, + min: IntoExpression = None, + max: IntoExpression = None, + /, + ) -> Expression: """ - Returns the value of the `cumulative distribution function `__ at the given input domain *value* for a uniform distribution over the interval `[min, max]`. + Returns the value of the `cumulative distribution function`_ at the given input domain ``value`` for a uniform distribution over the interval [``min``, ``max``). + + If unspecified, ``min`` defaults to ``0`` and ``max`` defaults to ``1``. If only one + argument is provided, it is interpreted as the ``max`` value. - If unspecified, *min* defaults to `0` and *max* defaults to `1`. - If only one argument is provided, it is interpreted as the *max* value. + .. _cumulative distribution function: + https://en.wikipedia.org/wiki/Cumulative_distribution_function """ - return FunctionExpression("cumulativeUniform", args) + return FunctionExpression("cumulativeUniform", (value, min, max)) @classmethod - def densityUniform(cls, *args) -> FunctionExpression: + def densityUniform( + cls, + value: IntoExpression, + min: IntoExpression = None, + max: IntoExpression = None, + /, + ) -> Expression: """ - Returns the value of the `probability density function `__ at the given input domain *value*, for a uniform distribution over the interval `[min, max]`. + Returns the value of the `probability density function`_ at the given input domain ``value``, for a uniform distribution over the interval [``min``, ``max``). - If unspecified, *min* defaults to `0` and *max* defaults to `1`. - If only one argument is provided, it is interpreted as the *max* value. + If unspecified, ``min`` defaults to ``0`` and ``max`` defaults to ``1``. If only one + argument is provided, it is interpreted as the ``max`` value. + + .. _probability density function: + https://en.wikipedia.org/wiki/Probability_density_function """ - return FunctionExpression("densityUniform", args) + return FunctionExpression("densityUniform", (value, min, max)) @classmethod - def quantileUniform(cls, *args) -> FunctionExpression: + def quantileUniform( + cls, + probability: IntoExpression, + min: IntoExpression = None, + max: IntoExpression = None, + /, + ) -> Expression: """ - Returns the quantile value (the inverse of the `cumulative distribution function `__ for the given input *probability*, for a uniform distribution over the interval `[min, max]`. + Returns the quantile value (the inverse of the `cumulative distribution function`_) for the given input ``probability``, for a uniform distribution over the interval [``min``, ``max``). + + If unspecified, ``min`` defaults to ``0`` and ``max`` defaults to ``1``. If only one + argument is provided, it is interpreted as the ``max`` value. - If unspecified, *min* defaults to `0` and *max* defaults to `1`. - If only one argument is provided, it is interpreted as the *max* value. + .. _cumulative distribution function: + https://en.wikipedia.org/wiki/Cumulative_distribution_function """ - return FunctionExpression("quantileUniform", args) + return FunctionExpression("quantileUniform", (probability, min, max)) @classmethod - def now(cls, *args) -> FunctionExpression: + def now(cls) -> Expression: """Returns the timestamp for the current time.""" - return FunctionExpression("now", args) + return FunctionExpression("now", ()) @classmethod - def datetime(cls, *args) -> FunctionExpression: + def datetime( + cls, + year: IntoExpression, + month: IntoExpression, + day: IntoExpression = None, + hour: IntoExpression = None, + min: IntoExpression = None, + sec: IntoExpression = None, + millisec: IntoExpression = None, + /, + ) -> Expression: """ - Returns a new `Date` instance. + Returns a new ``Date`` instance. - The *month* is 0-based, such that `1` represents February. + The ``month`` is 0-based, such that ``1`` represents February. """ - return FunctionExpression("datetime", args) + return FunctionExpression( + "datetime", (year, month, day, hour, min, sec, millisec) + ) @classmethod - def date(cls, *args) -> FunctionExpression: - """Returns the day of the month for the given *datetime* value, in local time.""" - return FunctionExpression("date", args) + def date(cls, datetime: IntoExpression, /) -> Expression: + """Returns the day of the month for the given ``datetime`` value, in local time.""" + return FunctionExpression("date", (datetime,)) @classmethod - def day(cls, *args) -> FunctionExpression: - """Returns the day of the week for the given *datetime* value, in local time.""" - return FunctionExpression("day", args) + def day(cls, datetime: IntoExpression, /) -> Expression: + """Returns the day of the week for the given ``datetime`` value, in local time.""" + return FunctionExpression("day", (datetime,)) @classmethod - def dayofyear(cls, *args) -> FunctionExpression: - """Returns the one-based day of the year for the given *datetime* value, in local time.""" - return FunctionExpression("dayofyear", args) + def dayofyear(cls, datetime: IntoExpression, /) -> Expression: + """Returns the one-based day of the year for the given ``datetime`` value, in local time.""" + return FunctionExpression("dayofyear", (datetime,)) @classmethod - def year(cls, *args) -> FunctionExpression: - """Returns the year for the given *datetime* value, in local time.""" - return FunctionExpression("year", args) + def year(cls, datetime: IntoExpression, /) -> Expression: + """Returns the year for the given ``datetime`` value, in local time.""" + return FunctionExpression("year", (datetime,)) @classmethod - def quarter(cls, *args) -> FunctionExpression: - """Returns the quarter of the year (0-3) for the given *datetime* value, in local time.""" - return FunctionExpression("quarter", args) + def quarter(cls, datetime: IntoExpression, /) -> Expression: + """Returns the quarter of the year (0-3) for the given ``datetime`` value, in local time.""" + return FunctionExpression("quarter", (datetime,)) @classmethod - def month(cls, *args) -> FunctionExpression: - """Returns the (zero-based) month for the given *datetime* value, in local time.""" - return FunctionExpression("month", args) + def month(cls, datetime: IntoExpression, /) -> Expression: + """Returns the (zero-based) month for the given ``datetime`` value, in local time.""" + return FunctionExpression("month", (datetime,)) @classmethod - def week(cls, *args) -> FunctionExpression: + def week(cls, date: IntoExpression, /) -> Expression: """ Returns the week number of the year for the given *datetime*, in local time. - This function assumes Sunday-based weeks. - Days before the first Sunday of the year are considered to be in week 0, - the first Sunday of the year is the start of week 1, - the second Sunday week 2, etc. + This function assumes Sunday-based weeks. Days before the first Sunday of the year are + considered to be in week 0, the first Sunday of the year is the start of week 1, the second + Sunday week 2, *etc.*. """ - return FunctionExpression("week", args) + return FunctionExpression("week", (date,)) @classmethod - def hours(cls, *args) -> FunctionExpression: - """Returns the hours component for the given *datetime* value, in local time.""" - return FunctionExpression("hours", args) + def hours(cls, datetime: IntoExpression, /) -> Expression: + """Returns the hours component for the given ``datetime`` value, in local time.""" + return FunctionExpression("hours", (datetime,)) @classmethod - def minutes(cls, *args) -> FunctionExpression: - """Returns the minutes component for the given *datetime* value, in local time.""" - return FunctionExpression("minutes", args) + def minutes(cls, datetime: IntoExpression, /) -> Expression: + """Returns the minutes component for the given ``datetime`` value, in local time.""" + return FunctionExpression("minutes", (datetime,)) @classmethod - def seconds(cls, *args) -> FunctionExpression: - """Returns the seconds component for the given *datetime* value, in local time.""" - return FunctionExpression("seconds", args) + def seconds(cls, datetime: IntoExpression, /) -> Expression: + """Returns the seconds component for the given ``datetime`` value, in local time.""" + return FunctionExpression("seconds", (datetime,)) @classmethod - def milliseconds(cls, *args) -> FunctionExpression: - """Returns the milliseconds component for the given *datetime* value, in local time.""" - return FunctionExpression("milliseconds", args) + def milliseconds(cls, datetime: IntoExpression, /) -> Expression: + """Returns the milliseconds component for the given ``datetime`` value, in local time.""" + return FunctionExpression("milliseconds", (datetime,)) @classmethod - def time(cls, *args) -> FunctionExpression: - """Returns the epoch-based timestamp for the given *datetime* value.""" - return FunctionExpression("time", args) + def time(cls, datetime: IntoExpression, /) -> Expression: + """Returns the epoch-based timestamp for the given ``datetime`` value.""" + return FunctionExpression("time", (datetime,)) @classmethod - def timezoneoffset(cls, *args) -> FunctionExpression: - """Returns the timezone offset from the local timezone to UTC for the given *datetime* value.""" - return FunctionExpression("timezoneoffset", args) + def timezoneoffset(cls, datetime: IntoExpression, /) -> Expression: + """Returns the timezone offset from the local timezone to UTC for the given ``datetime`` value.""" + return FunctionExpression("timezoneoffset", (datetime,)) @classmethod - def timeOffset(cls, *args) -> FunctionExpression: + def timeOffset( + cls, unit: IntoExpression, date: IntoExpression, step: IntoExpression = None, / + ) -> Expression: """ - Returns a new `Date` instance that offsets the given *date* by the specified time `unit `__ in the local timezone. + Returns a new ``Date`` instance that offsets the given ``date`` by the specified time `*unit*`_ in the local timezone. + + The optional ``step`` argument indicates the number of time unit steps to offset by (default + 1). - The optional *step* argument indicates the number of time unit steps to offset by (default 1). + .. _*unit*: + https://vega.github.io/vega/docs/api/time/#time-units """ - return FunctionExpression("timeOffset", args) + return FunctionExpression("timeOffset", (unit, date, step)) @classmethod - def timeSequence(cls, *args) -> FunctionExpression: + def timeSequence( + cls, + unit: IntoExpression, + start: IntoExpression, + stop: IntoExpression, + step: IntoExpression = None, + /, + ) -> Expression: """ - Returns an array of `Date` instances from *start* (inclusive) to *stop* (exclusive), with each entry separated by the given time `unit `__ in the local timezone. + Returns an array of ``Date`` instances from ``start`` (inclusive) to ``stop`` (exclusive), with each entry separated by the given time `*unit*`_ in the local timezone. - The optional *step* argument indicates the number of time unit steps to take between each sequence entry (default 1). + The optional ``step`` argument indicates the number of time unit steps to take between each + sequence entry (default 1). + + .. _*unit*: + https://vega.github.io/vega/docs/api/time/#time-units """ - return FunctionExpression("timeSequence", args) + return FunctionExpression("timeSequence", (unit, start, stop, step)) @classmethod - def utc(cls, *args) -> FunctionExpression: - """Returns a timestamp for the given UTC date. The *month* is 0-based, such that `1` represents February.""" - return FunctionExpression("utc", args) + def utc( + cls, + year: IntoExpression, + month: IntoExpression, + day: IntoExpression = None, + hour: IntoExpression = None, + min: IntoExpression = None, + sec: IntoExpression = None, + millisec: IntoExpression = None, + /, + ) -> Expression: + """ + Returns a timestamp for the given UTC date. + + The ``month`` is 0-based, such that ``1`` represents February. + """ + return FunctionExpression("utc", (year, month, day, hour, min, sec, millisec)) @classmethod - def utcdate(cls, *args) -> FunctionExpression: - """Returns the day of the month for the given *datetime* value, in UTC time.""" - return FunctionExpression("utcdate", args) + def utcdate(cls, datetime: IntoExpression, /) -> Expression: + """Returns the day of the month for the given ``datetime`` value, in UTC time.""" + return FunctionExpression("utcdate", (datetime,)) @classmethod - def utcday(cls, *args) -> FunctionExpression: - """Returns the day of the week for the given *datetime* value, in UTC time.""" - return FunctionExpression("utcday", args) + def utcday(cls, datetime: IntoExpression, /) -> Expression: + """Returns the day of the week for the given ``datetime`` value, in UTC time.""" + return FunctionExpression("utcday", (datetime,)) @classmethod - def utcdayofyear(cls, *args) -> FunctionExpression: - """Returns the one-based day of the year for the given *datetime* value, in UTC time.""" - return FunctionExpression("utcdayofyear", args) + def utcdayofyear(cls, datetime: IntoExpression, /) -> Expression: + """Returns the one-based day of the year for the given ``datetime`` value, in UTC time.""" + return FunctionExpression("utcdayofyear", (datetime,)) @classmethod - def utcyear(cls, *args) -> FunctionExpression: - """Returns the year for the given *datetime* value, in UTC time.""" - return FunctionExpression("utcyear", args) + def utcyear(cls, datetime: IntoExpression, /) -> Expression: + """Returns the year for the given ``datetime`` value, in UTC time.""" + return FunctionExpression("utcyear", (datetime,)) @classmethod - def utcquarter(cls, *args) -> FunctionExpression: - """Returns the quarter of the year (0-3) for the given *datetime* value, in UTC time.""" - return FunctionExpression("utcquarter", args) + def utcquarter(cls, datetime: IntoExpression, /) -> Expression: + """Returns the quarter of the year (0-3) for the given ``datetime`` value, in UTC time.""" + return FunctionExpression("utcquarter", (datetime,)) @classmethod - def utcmonth(cls, *args) -> FunctionExpression: - """Returns the (zero-based) month for the given *datetime* value, in UTC time.""" - return FunctionExpression("utcmonth", args) + def utcmonth(cls, datetime: IntoExpression, /) -> Expression: + """Returns the (zero-based) month for the given ``datetime`` value, in UTC time.""" + return FunctionExpression("utcmonth", (datetime,)) @classmethod - def utcweek(cls, *args) -> FunctionExpression: + def utcweek(cls, date: IntoExpression, /) -> Expression: """ Returns the week number of the year for the given *datetime*, in UTC time. - This function assumes Sunday-based weeks. - Days before the first Sunday of the year are considered to be in week 0, - the first Sunday of the year is the start of week 1, - the second Sunday week 2, etc. + This function assumes Sunday-based weeks. Days before the first Sunday of the year are + considered to be in week 0, the first Sunday of the year is the start of week 1, the second + Sunday week 2, *etc.*. """ - return FunctionExpression("utcweek", args) + return FunctionExpression("utcweek", (date,)) @classmethod - def utchours(cls, *args) -> FunctionExpression: - """Returns the hours component for the given *datetime* value, in UTC time.""" - return FunctionExpression("utchours", args) + def utchours(cls, datetime: IntoExpression, /) -> Expression: + """Returns the hours component for the given ``datetime`` value, in UTC time.""" + return FunctionExpression("utchours", (datetime,)) @classmethod - def utcminutes(cls, *args) -> FunctionExpression: - """Returns the minutes component for the given *datetime* value, in UTC time.""" - return FunctionExpression("utcminutes", args) + def utcminutes(cls, datetime: IntoExpression, /) -> Expression: + """Returns the minutes component for the given ``datetime`` value, in UTC time.""" + return FunctionExpression("utcminutes", (datetime,)) @classmethod - def utcseconds(cls, *args) -> FunctionExpression: - """Returns the seconds component for the given *datetime* value, in UTC time.""" - return FunctionExpression("utcseconds", args) + def utcseconds(cls, datetime: IntoExpression, /) -> Expression: + """Returns the seconds component for the given ``datetime`` value, in UTC time.""" + return FunctionExpression("utcseconds", (datetime,)) @classmethod - def utcmilliseconds(cls, *args) -> FunctionExpression: - """Returns the milliseconds component for the given *datetime* value, in UTC time.""" - return FunctionExpression("utcmilliseconds", args) + def utcmilliseconds(cls, datetime: IntoExpression, /) -> Expression: + """Returns the milliseconds component for the given ``datetime`` value, in UTC time.""" + return FunctionExpression("utcmilliseconds", (datetime,)) @classmethod - def utcOffset(cls, *args) -> FunctionExpression: + def utcOffset( + cls, unit: IntoExpression, date: IntoExpression, step: IntoExpression = None, / + ) -> Expression: """ - Returns a new `Date` instance that offsets the given *date* by the specified time `unit `__ in UTC time. + Returns a new ``Date`` instance that offsets the given ``date`` by the specified time `*unit*`_ in UTC time. + + The optional ``step`` argument indicates the number of time unit steps to offset by (default + 1). - The optional *step* argument indicates the number of time unit steps to offset by (default 1). + .. _*unit*: + https://vega.github.io/vega/docs/api/time/#time-units """ - return FunctionExpression("utcOffset", args) + return FunctionExpression("utcOffset", (unit, date, step)) @classmethod - def utcSequence(cls, *args) -> FunctionExpression: + def utcSequence( + cls, + unit: IntoExpression, + start: IntoExpression, + stop: IntoExpression, + step: IntoExpression = None, + /, + ) -> Expression: """ - Returns an array of `Date` instances from *start* (inclusive) to *stop* (exclusive), with each entry separated by the given time `unit `__ in UTC time. + Returns an array of ``Date`` instances from ``start`` (inclusive) to ``stop`` (exclusive), with each entry separated by the given time `*unit*`_ in UTC time. + + The optional ``step`` argument indicates the number of time unit steps to take between each + sequence entry (default 1). - The optional *step* argument indicates the number of time unit steps to take between each sequence entry (default 1). + .. _*unit*: + https://vega.github.io/vega/docs/api/time/#time-units """ - return FunctionExpression("utcSequence", args) + return FunctionExpression("utcSequence", (unit, start, stop, step)) @classmethod - def extent(cls, *args) -> FunctionExpression: - """Returns a new `[min, max]` array with the minimum and maximum values of the input array, ignoring `null`, `undefined`, and `NaN` values.""" - return FunctionExpression("extent", args) + def extent(cls, array: IntoExpression, /) -> Expression: + """Returns a new *[min, max]* array with the minimum and maximum values of the input array, ignoring ``null``, ``undefined``, and ``NaN`` values.""" + return FunctionExpression("extent", (array,)) @classmethod - def clampRange(cls, *args) -> FunctionExpression: + def clampRange( + cls, range: IntoExpression, min: IntoExpression, max: IntoExpression, / + ) -> Expression: """ - Clamps a two-element *range* array in a span-preserving manner. + Clamps a two-element ``range`` array in a span-preserving manner. - If the span of the input *range* is less than `(max - min)` and an endpoint exceeds either the *min* or *max* value, - the range is translated such that the span is preserved and one endpoint touches the boundary of the `[min, max]` range. - If the span exceeds `(max - min)`, the range `[min, max]` is returned. + If the span of the input ``range`` is less than *(max - min)* and an endpoint exceeds either + the ``min`` or ``max`` value, the range is translated such that the span is preserved and + one endpoint touches the boundary of the *[min, max]* range. If the span exceeds *(max - + min)*, the range *[min, max]* is returned. """ - return FunctionExpression("clampRange", args) + return FunctionExpression("clampRange", (range, min, max)) @classmethod - def indexof(cls, *args) -> FunctionExpression: - """Returns the first index of *value* in the input *array*, or the first index of *substring* in the input *string*.""" - return FunctionExpression("indexof", args) + def indexof(cls, array: IntoExpression, value: IntoExpression, /) -> Expression: + """Returns the first index of ``value`` in the input ``array``.""" + return FunctionExpression("indexof", (array, value)) @classmethod - def inrange(cls, *args) -> FunctionExpression: - """Tests whether *value* lies within (or is equal to either) the first and last values of the *range* array.""" - return FunctionExpression("inrange", args) + def inrange(cls, value: IntoExpression, range: IntoExpression, /) -> Expression: + """Tests whether ``value`` lies within (or is equal to either) the first and last values of the ``range`` array.""" + return FunctionExpression("inrange", (value, range)) @classmethod - def join(cls, *args) -> FunctionExpression: - """Returns a new string by concatenating all of the elements of the input *array*, separated by commas or a specified *separator* string.""" - return FunctionExpression("join", args) + def join( + cls, array: IntoExpression, separator: IntoExpression = None, / + ) -> Expression: + """Returns a new string by concatenating all of the elements of the input ``array``, separated by commas or a specified ``separator`` string.""" + return FunctionExpression("join", (array, separator)) @classmethod - def lastindexof(cls, *args) -> FunctionExpression: - """Returns the last index of *value* in the input *array*, or the last index of *substring* in the input *string*.""" - return FunctionExpression("lastindexof", args) + def lastindexof(cls, array: IntoExpression, value: IntoExpression, /) -> Expression: + """Returns the last index of ``value`` in the input ``array``.""" + return FunctionExpression("lastindexof", (array, value)) @classmethod - def length(cls, *args) -> FunctionExpression: - """Returns the length of the input *array*, or the length of the input *string*.""" - return FunctionExpression("length", args) + def length(cls, array: IntoExpression, /) -> Expression: + """Returns the length of the input ``array``.""" + return FunctionExpression("length", (array,)) @classmethod - def lerp(cls, *args) -> FunctionExpression: + def lerp(cls, array: IntoExpression, fraction: IntoExpression, /) -> Expression: """ - Returns the linearly interpolated value between the first and last entries in the *array* for the provided interpolation *fraction* (typically between 0 and 1). + Returns the linearly interpolated value between the first and last entries in the ``array`` for the provided interpolation ``fraction`` (typically between 0 and 1). - For example, `lerp([0, 50], 0.5)` returns 25. + For example, ``alt.expr.lerp([0, 50], 0.5)`` returns 25. """ - return FunctionExpression("lerp", args) + return FunctionExpression("lerp", (array, fraction)) @classmethod - def peek(cls, *args) -> FunctionExpression: + def peek(cls, array: IntoExpression, /) -> Expression: """ - Returns the last element in the input *array*. + Returns the last element in the input ``array``. - Similar to the built-in `Array.pop` method, except that it does not remove the last element. - This method is a convenient shorthand for `array[array.length - 1]`. + Similar to the built-in ``Array.pop`` method, except that it does not remove the last + element. This method is a convenient shorthand for ``array[array.length - 1]``. """ - return FunctionExpression("peek", args) + return FunctionExpression("peek", (array,)) @classmethod - def pluck(cls, *args) -> FunctionExpression: + def pluck(cls, array: IntoExpression, field: IntoExpression, /) -> Expression: """ - Retrieves the value for the specified *field* from a given *array* of objects. + Retrieves the value for the specified ``field`` from a given ``array`` of objects. - The input *field* string may include nested properties (e.g., `foo.bar.bz`). + The input ``field`` string may include nested properties (e.g., ``foo.bar.bz``). """ - return FunctionExpression("pluck", args) + return FunctionExpression("pluck", (array, field)) @classmethod - def reverse(cls, *args) -> FunctionExpression: + def reverse(cls, array: IntoExpression, /) -> Expression: """ - Returns a new array with elements in a reverse order of the input *array*. + Returns a new array with elements in a reverse order of the input ``array``. The first array element becomes the last, and the last array element becomes the first. """ - return FunctionExpression("reverse", args) + return FunctionExpression("reverse", (array,)) @classmethod - def sequence(cls, *args) -> FunctionExpression: - r""" + def sequence(cls, *args: Any) -> Expression: + """ Returns an array containing an arithmetic sequence of numbers. - If *step* is omitted, it defaults to 1. - If *start* is omitted, it defaults to 0. - - The *stop* value is exclusive; it is not included in the result. - If *step* is positive, the last element is the largest `start + i * step` less than *stop*; - if *step* is negative, the last element is the smallest `start + i * step` greater than *stop*. - - If the returned array would contain an infinite number of values, an empty range is returned. - The arguments are not required to be integers. + If ``step`` is omitted, it defaults to 1. If ``start`` is omitted, it defaults to 0. The + ``stop`` value is exclusive; it is not included in the result. If ``step`` is positive, the + last element is the largest *start + i * step* less than ``stop``; if ``step`` is negative, + the last element is the smallest *start + i * step* greater than ``stop``. If the returned + array would contain an infinite number of values, an empty range is returned. The arguments + are not required to be integers. """ return FunctionExpression("sequence", args) @classmethod - def slice(cls, *args) -> FunctionExpression: + def slice( + cls, array: IntoExpression, start: IntoExpression, end: IntoExpression = None, / + ) -> Expression: """ - Returns a section of *array* between the *start* and *end* indices. + Returns a section of ``array`` between the ``start`` and ``end`` indices. - If the *end* argument is negative, it is treated as an offset from the end of the array `length(array) + end`. + If the ``end`` argument is negative, it is treated as an offset from the end of the array + (*alt.expr.length(array) + end*). """ - return FunctionExpression("slice", args) + return FunctionExpression("slice", (array, start, end)) @classmethod - def span(cls, *args) -> FunctionExpression: - """ - Returns the span of *array*: the difference between the last and first elements, or `array[array.length-1] - array[0]`. - - Or if input is a string: a section of *string* between the *start* and *end* indices. - If the *end* argument is negative, it is treated as an offset from the end of the string `length(string) + end`. - """ - return FunctionExpression("span", args) + def span(cls, array: IntoExpression, /) -> Expression: + """Returns the span of ``array``: the difference between the last and first elements, or *array[array.length-1] - array[0]*.""" + return FunctionExpression("span", (array,)) @classmethod - def lower(cls, *args) -> FunctionExpression: - """Transforms *string* to lower-case letters.""" - return FunctionExpression("lower", args) + def lower(cls, string: IntoExpression, /) -> Expression: + """Transforms ``string`` to lower-case letters.""" + return FunctionExpression("lower", (string,)) @classmethod - def pad(cls, *args) -> FunctionExpression: + def pad( + cls, + string: IntoExpression, + length: IntoExpression, + character: IntoExpression = None, + align: IntoExpression = None, + /, + ) -> Expression: """ - Pads a *string* value with repeated instances of a *character* up to a specified *length*. + Pads a ``string`` value with repeated instances of a ``character`` up to a specified ``length``. - If *character* is not specified, a space (' ') is used. - By default, padding is added to the end of a string. - An optional *align* parameter specifies if padding should be added to the `'left'` (beginning), `'center'`, or `'right'` (end) of the input string. + If ``character`` is not specified, a space (' ') is used. By default, padding is added to + the end of a string. An optional ``align`` parameter specifies if padding should be added to + the ``'left'`` (beginning), ``'center'``, or ``'right'`` (end) of the input string. """ - return FunctionExpression("pad", args) + return FunctionExpression("pad", (string, length, character, align)) @classmethod - def parseFloat(cls, *args) -> FunctionExpression: + def parseFloat(cls, string: IntoExpression, /) -> Expression: """ - Parses the input *string* to a floating-point value. + Parses the input ``string`` to a floating-point value. - Same as JavaScript's `parseFloat`. + Same as JavaScript's ``parseFloat``. """ - return FunctionExpression("parseFloat", args) + return FunctionExpression("parseFloat", (string,)) @classmethod - def parseInt(cls, *args) -> FunctionExpression: + def parseInt(cls, string: IntoExpression, /) -> Expression: """ - Parses the input *string* to an integer value. + Parses the input ``string`` to an integer value. - Same as JavaScript's `parseInt`. + Same as JavaScript's ``parseInt``. """ - return FunctionExpression("parseInt", args) + return FunctionExpression("parseInt", (string,)) @classmethod - def replace(cls, *args) -> FunctionExpression: + def replace( + cls, + string: IntoExpression, + pattern: IntoExpression, + replacement: IntoExpression, + /, + ) -> Expression: """ - Returns a new string with some or all matches of *pattern* replaced by a *replacement* string. + Returns a new string with some or all matches of ``pattern`` replaced by a ``replacement`` string. - The *pattern* can be a string or a regular expression. - If *pattern* is a string, only the first instance will be replaced. - Same as `JavaScript's String.replace `__. - """ - return FunctionExpression("replace", args) + The ``pattern`` can be a string or a regular expression. If ``pattern`` is a string, only + the first instance will be replaced. Same as `JavaScript's String.replace`_. - @classmethod - def split(cls, *args) -> FunctionExpression: + .. _JavaScript's String.replace: + https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace """ - Returns an array of tokens created by splitting the input *string* according to a provided *separator* pattern. - - The result can optionally be constrained to return at most *limit* tokens. - """ - return FunctionExpression("split", args) + return FunctionExpression("replace", (string, pattern, replacement)) @classmethod - def substring(cls, *args) -> FunctionExpression: - """Returns a section of *string* between the *start* and *end* indices.""" - return FunctionExpression("substring", args) + def substring( + cls, + string: IntoExpression, + start: IntoExpression, + end: IntoExpression = None, + /, + ) -> Expression: + """Returns a section of ``string`` between the ``start`` and ``end`` indices.""" + return FunctionExpression("substring", (string, start, end)) @classmethod - def trim(cls, *args) -> FunctionExpression: + def trim(cls, string: IntoExpression, /) -> Expression: """Returns a trimmed string with preceding and trailing whitespace removed.""" - return FunctionExpression("trim", args) + return FunctionExpression("trim", (string,)) @classmethod - def truncate(cls, *args) -> FunctionExpression: - r""" - Truncates an input *string* to a target *length*. + def truncate( + cls, + string: IntoExpression, + length: IntoExpression, + align: IntoExpression = None, + ellipsis: IntoExpression = None, + /, + ) -> Expression: + """ + Truncates an input ``string`` to a target ``length``. - The optional *align* argument indicates what part of the string should be truncated: `'left'` (the beginning), `'center'`, or `'right'` (the end). - By default, the `'right'` end of the string is truncated. - The optional *ellipsis* argument indicates the string to use to indicate truncated content; - by default the ellipsis character `...` (`\\u2026`) is used. + The optional ``align`` argument indicates what part of the string should be truncated: + ``'left'`` (the beginning), ``'center'``, or ``'right'`` (the end). By default, the + ``'right'`` end of the string is truncated. The optional ``ellipsis`` argument indicates the + string to use to indicate truncated content; by default the ellipsis character ``…`` + (``\u2026``) is used. """ - return FunctionExpression("truncate", args) + return FunctionExpression("truncate", (string, length, align, ellipsis)) @classmethod - def upper(cls, *args) -> FunctionExpression: - """Transforms *string* to upper-case letters.""" - return FunctionExpression("upper", args) + def upper(cls, string: IntoExpression, /) -> Expression: + """Transforms ``string`` to upper-case letters.""" + return FunctionExpression("upper", (string,)) @classmethod - def merge(cls, *args) -> FunctionExpression: + def merge( + cls, object1: IntoExpression, object2: IntoExpression = None, *args: Any + ) -> Expression: """ - Merges the input objects *object1*, *object2*, etc into a new output object. - - Inputs are visited in sequential order, such that key values from later arguments can overwrite those from earlier arguments. + Merges the input objects ``object1``, ``object2``, etc into a new output object. - Example: `merge({a:1, b:2}, {a:3}) -> {a:3, b:2}`. + Inputs are visited in sequential order, such that key values from later arguments can + overwrite those from earlier arguments. Example: ``alt.expr.merge({a:1, b:2}, {a:3}) -> + {a:3, b:2}``. """ - return FunctionExpression("merge", args) + return FunctionExpression("merge", (object1, object2, *args)) @classmethod - def dayFormat(cls, *args) -> FunctionExpression: + def dayFormat(cls, day: IntoExpression, /) -> Expression: """ Formats a (0-6) *weekday* number as a full week day name, according to the current locale. - For example: `dayFormat(0) -> "Sunday"`. + For example: ``alt.expr.dayFormat(0) -> "Sunday"``. """ - return FunctionExpression("dayFormat", args) + return FunctionExpression("dayFormat", (day,)) @classmethod - def dayAbbrevFormat(cls, *args) -> FunctionExpression: + def dayAbbrevFormat(cls, day: IntoExpression, /) -> Expression: """ Formats a (0-6) *weekday* number as an abbreviated week day name, according to the current locale. - For example: `dayAbbrevFormat(0) -> "Sun"`. + For example: ``alt.expr.dayAbbrevFormat(0) -> "Sun"``. """ - return FunctionExpression("dayAbbrevFormat", args) + return FunctionExpression("dayAbbrevFormat", (day,)) @classmethod - def format(cls, *args) -> FunctionExpression: + def format(cls, value: IntoExpression, specifier: IntoExpression, /) -> Expression: """ - Formats a numeric *value* as a string. + Formats a numeric ``value`` as a string. - The *specifier* must be a valid `d3-format specifier `__ (e.g., `format(value, ',.2f')`. + The ``specifier`` must be a valid `d3-format specifier`_ (e.g., ``alt.expr.format(value, + ',.2f')``. Null values are formatted as ``"null"``. + + .. _d3-format specifier: + https://github.com/d3/d3-format/ """ - return FunctionExpression("format", args) + return FunctionExpression("format", (value, specifier)) @classmethod - def monthFormat(cls, *args) -> FunctionExpression: + def monthFormat(cls, month: IntoExpression, /) -> Expression: """ - Formats a (zero-based) *month* number as a full month name, according to the current locale. + Formats a (zero-based) ``month`` number as a full month name, according to the current locale. - For example: `monthFormat(0) -> "January"`. + For example: ``alt.expr.monthFormat(0) -> "January"``. """ - return FunctionExpression("monthFormat", args) + return FunctionExpression("monthFormat", (month,)) @classmethod - def monthAbbrevFormat(cls, *args) -> FunctionExpression: + def monthAbbrevFormat(cls, month: IntoExpression, /) -> Expression: """ - Formats a (zero-based) *month* number as an abbreviated month name, according to the current locale. + Formats a (zero-based) ``month`` number as an abbreviated month name, according to the current locale. - For example: `monthAbbrevFormat(0) -> "Jan"`. + For example: ``alt.expr.monthAbbrevFormat(0) -> "Jan"``. """ - return FunctionExpression("monthAbbrevFormat", args) + return FunctionExpression("monthAbbrevFormat", (month,)) @classmethod - def timeUnitSpecifier(cls, *args) -> FunctionExpression: + def timeUnitSpecifier( + cls, units: IntoExpression, specifiers: IntoExpression = None, / + ) -> Expression: """ - Returns a time format specifier string for the given time `unit `__. - - The optional *specifiers* object provides a set of specifier sub-strings for customizing the format; - for more, see the `timeUnitSpecifier API documentation `__. + Returns a time format specifier string for the given time `*units*`_. - The resulting specifier string can then be used as input to the `timeFormat `__ or - `utcFormat `__ functions, or as the *format* parameter of an axis or legend. + The optional ``specifiers`` object provides a set of specifier sub-strings for customizing + the format; for more, see the `timeUnitSpecifier API documentation`_. The resulting + specifier string can then be used as input to the `timeFormat`_ or `utcFormat`_ functions, + or as the *format* parameter of an axis or legend. For example: ``alt.expr.timeFormat(date, + alt.expr.timeUnitSpecifier('year'))`` or ``alt.expr.timeFormat(date, + alt.expr.timeUnitSpecifier(['hours', 'minutes']))``. - For example: `timeFormat(date, timeUnitSpecifier('year'))` or `timeFormat(date, timeUnitSpecifier(['hours', 'minutes']))`. + .. _*units*: + https://vega.github.io/vega/docs/api/time/#time-units + .. _timeUnitSpecifier API documentation: + https://vega.github.io/vega/docs/api/time/#timeUnitSpecifier + .. _timeFormat: + https://vega.github.io/vega/docs/expressions/#timeFormat + .. _utcFormat: + https://vega.github.io/vega/docs/expressions/#utcFormat """ - return FunctionExpression("timeUnitSpecifier", args) + return FunctionExpression("timeUnitSpecifier", (units, specifiers)) @classmethod - def timeFormat(cls, *args) -> FunctionExpression: + def timeFormat( + cls, value: IntoExpression, specifier: IntoExpression, / + ) -> Expression: """ - Formats a datetime *value* (either a `Date` object or timestamp) as a string, according to the local time. + Formats a datetime ``value`` (either a ``Date`` object or timestamp) as a string, according to the local time. + + The ``specifier`` must be a valid `d3-time-format specifier`_ or `TimeMultiFormat object`_. + For example: ``alt.expr.timeFormat(timestamp, '%A')``. Null values are formatted as + ``"null"``. - The *specifier* must be a valid `d3-time-format specifier `__. - For example: `timeFormat(timestamp, '%A')`. + .. _d3-time-format specifier: + https://github.com/d3/d3-time-format/ + .. _TimeMultiFormat object: + https://vega.github.io/vega/docs/types/#TimeMultiFormat """ - return FunctionExpression("timeFormat", args) + return FunctionExpression("timeFormat", (value, specifier)) @classmethod - def timeParse(cls, *args) -> FunctionExpression: + def timeParse( + cls, string: IntoExpression, specifier: IntoExpression, / + ) -> Expression: """ - Parses a *string* value to a Date object, according to the local time. + Parses a ``string`` value to a Date object, according to the local time. - The *specifier* must be a valid `d3-time-format specifier `__. - For example: `timeParse('June 30, 2015', '%B %d, %Y')`. + The ``specifier`` must be a valid `d3-time-format specifier`_. For example: + ``alt.expr.timeParse('June 30, 2015', '%B %d, %Y')``. + + .. _d3-time-format specifier: + https://github.com/d3/d3-time-format/ """ - return FunctionExpression("timeParse", args) + return FunctionExpression("timeParse", (string, specifier)) @classmethod - def utcFormat(cls, *args) -> FunctionExpression: + def utcFormat( + cls, value: IntoExpression, specifier: IntoExpression, / + ) -> Expression: """ - Formats a datetime *value* (either a `Date` object or timestamp) as a string, according to `UTC `__ time. + Formats a datetime ``value`` (either a ``Date`` object or timestamp) as a string, according to `UTC`_ time. + + The ``specifier`` must be a valid `d3-time-format specifier`_ or `TimeMultiFormat object`_. + For example: ``alt.expr.utcFormat(timestamp, '%A')``. Null values are formatted as + ``"null"``. - The *specifier* must be a valid `d3-time-format specifier `__. - For example: `utcFormat(timestamp, '%A')`. + .. _UTC: + https://en.wikipedia.org/wiki/Coordinated_Universal_Time + .. _d3-time-format specifier: + https://github.com/d3/d3-time-format/ + .. _TimeMultiFormat object: + https://vega.github.io/vega/docs/types/#TimeMultiFormat """ - return FunctionExpression("utcFormat", args) + return FunctionExpression("utcFormat", (value, specifier)) @classmethod - def utcParse(cls, *args) -> FunctionExpression: + def utcParse( + cls, value: IntoExpression, specifier: IntoExpression, / + ) -> Expression: """ - Parses a *string* value to a Date object, according to `UTC `__ time. + Parses a *string* value to a Date object, according to `UTC`_ time. + + The ``specifier`` must be a valid `d3-time-format specifier`_. For example: + ``alt.expr.utcParse('June 30, 2015', '%B %d, %Y')``. - The *specifier* must be a valid `d3-time-format specifier `__. - For example: `utcParse('June 30, 2015', '%B %d, %Y')`. + .. _UTC: + https://en.wikipedia.org/wiki/Coordinated_Universal_Time + .. _d3-time-format specifier: + https://github.com/d3/d3-time-format/ """ - return FunctionExpression("utcParse", args) + return FunctionExpression("utcParse", (value, specifier)) @classmethod - def regexp(cls, *args) -> FunctionExpression: + def regexp( + cls, pattern: IntoExpression, flags: IntoExpression = None, / + ) -> Expression: """ - Creates a regular expression instance from an input *pattern* string and optional *flags*. + Creates a regular expression instance from an input ``pattern`` string and optional ``flags``. - Same as `JavaScript's `RegExp` `__. + Same as `JavaScript's RegExp`_. + + .. _JavaScript's RegExp: + https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp """ - return FunctionExpression("regexp", args) + return FunctionExpression("regexp", (pattern, flags)) @classmethod - def test(cls, *args) -> FunctionExpression: + def test( + cls, regexp: IntoExpression, string: IntoExpression = None, / + ) -> Expression: r""" - Evaluates a regular expression *regexp* against the input *string*, returning `true` if the string matches the pattern, `false` otherwise. + Evaluates a regular expression ``regexp`` against the input ``string``, returning ``true`` if the string matches the pattern, ``false`` otherwise. - For example: `test(\d{3}, "32-21-9483") -> true`. + For example: ``alt.expr.test(/\\d{3}/, "32-21-9483") -> true``. """ - return FunctionExpression("test", args) + return FunctionExpression("test", (regexp, string)) @classmethod - def rgb(cls, *args) -> FunctionExpression: + def rgb(cls, *args: Any) -> Expression: """ - Constructs a new `RGB `__ color. + Constructs a new `RGB`_ color. + + If ``r``, ``g`` and ``b`` are specified, these represent the channel values of the returned + color; an ``opacity`` may also be specified. If a CSS Color Module Level 3 *specifier* + string is specified, it is parsed and then converted to the RGB color space. Uses + `d3-color's rgb function`_. - If *r*, *g* and *b* are specified, these represent the channel values of the returned color; an *opacity* may also be specified. - If a CSS Color Module Level 3 *specifier* string is specified, it is parsed and then converted to the RGB color space. Uses `d3-color's rgb function `__. + .. _RGB: + https://en.wikipedia.org/wiki/RGB_color_model + .. _d3-color's rgb function: + https://github.com/d3/d3-color#rgb """ return FunctionExpression("rgb", args) @classmethod - def hsl(cls, *args) -> FunctionExpression: + def hsl(cls, *args: Any) -> Expression: """ - Constructs a new `HSL `__ color. + Constructs a new `HSL`_ color. + + If ``h``, ``s`` and ``l`` are specified, these represent the channel values of the returned + color; an ``opacity`` may also be specified. If a CSS Color Module Level 3 *specifier* + string is specified, it is parsed and then converted to the HSL color space. Uses + `d3-color's hsl function`_. - If *h*, *s* and *l* are specified, these represent the channel values of the returned color; an *opacity* may also be specified. - If a CSS Color Module Level 3 *specifier* string is specified, it is parsed and then converted to the HSL color space. - Uses `d3-color's hsl function `__. + .. _HSL: + https://en.wikipedia.org/wiki/HSL_and_HSV + .. _d3-color's hsl function: + https://github.com/d3/d3-color#hsl """ return FunctionExpression("hsl", args) @classmethod - def lab(cls, *args) -> FunctionExpression: + def lab(cls, *args: Any) -> Expression: """ - Constructs a new `CIE LAB `__ color. + Constructs a new `CIE LAB`_ color. - If *l*, *a* and *b* are specified, these represent the channel values of the returned color; an *opacity* may also be specified. - If a CSS Color Module Level 3 *specifier* string is specified, it is parsed and then converted to the LAB color space. - Uses `d3-color's lab function `__. + If ``l``, ``a`` and ``b`` are specified, these represent the channel values of the returned + color; an ``opacity`` may also be specified. If a CSS Color Module Level 3 *specifier* + string is specified, it is parsed and then converted to the LAB color space. Uses + `d3-color's lab function`_. + + .. _CIE LAB: + https://en.wikipedia.org/wiki/Lab_color_space#CIELAB + .. _d3-color's lab function: + https://github.com/d3/d3-color#lab """ return FunctionExpression("lab", args) @classmethod - def hcl(cls, *args) -> FunctionExpression: + def hcl(cls, *args: Any) -> Expression: """ - Constructs a new `HCL `__ (hue, chroma, luminance) color. + Constructs a new `HCL`_ (hue, chroma, luminance) color. + + If ``h``, ``c`` and ``l`` are specified, these represent the channel values of the returned + color; an ``opacity`` may also be specified. If a CSS Color Module Level 3 *specifier* + string is specified, it is parsed and then converted to the HCL color space. Uses + `d3-color's hcl function`_. - If *h*, *c* and *l* are specified, these represent the channel values of the returned color; an *opacity* may also be specified. - If a CSS Color Module Level 3 *specifier* string is specified, it is parsed and then converted to the HCL color space. - Uses `d3-color's hcl function `__. + .. _HCL: + https://en.wikipedia.org/wiki/Lab_color_space#CIELAB + .. _d3-color's hcl function: + https://github.com/d3/d3-color#hcl """ return FunctionExpression("hcl", args) @classmethod - def luminance(cls, *args) -> FunctionExpression: + def luminance(cls, specifier: IntoExpression, /) -> Expression: """ - Returns the luminance for the given color *specifier* (compatible with `d3-color's rgb function `__. + Returns the luminance for the given color ``specifier`` (compatible with `d3-color's rgb function`_). + + The luminance is calculated according to the `W3C Web Content Accessibility Guidelines`_. - The luminance is calculated according to the `W3C Web Content Accessibility Guidelines `__. + .. _d3-color's rgb function: + https://github.com/d3/d3-color#rgb + .. _W3C Web Content Accessibility Guidelines: + https://www.w3.org/TR/2008/REC-WCAG20-20081211/#relativeluminancedef """ - return FunctionExpression("luminance", args) + return FunctionExpression("luminance", (specifier,)) @classmethod - def contrast(cls, *args) -> FunctionExpression: + def contrast( + cls, specifier1: IntoExpression, specifier2: IntoExpression, / + ) -> Expression: """ Returns the contrast ratio between the input color specifiers as a float between 1 and 21. - The contrast is calculated according to the `W3C Web Content Accessibility Guidelines `__. + The contrast is calculated according to the `W3C Web Content Accessibility Guidelines`_. + + .. _W3C Web Content Accessibility Guidelines: + https://www.w3.org/TR/2008/REC-WCAG20-20081211/#contrast-ratiodef """ - return FunctionExpression("contrast", args) + return FunctionExpression("contrast", (specifier1, specifier2)) @classmethod - def item(cls, *args) -> FunctionExpression: + def item(cls) -> Expression: """Returns the current scenegraph item that is the target of the event.""" - return FunctionExpression("item", args) + return FunctionExpression("item", ()) @classmethod - def group(cls, *args) -> FunctionExpression: + def group(cls, name: IntoExpression = None, /) -> Expression: """ Returns the scenegraph group mark item in which the current event has occurred. - If no arguments are provided, the immediate parent group is returned. - If a group name is provided, the matching ancestor group item is returned. + If no arguments are provided, the immediate parent group is returned. If a group name is + provided, the matching ancestor group item is returned. """ - return FunctionExpression("group", args) + return FunctionExpression("group", (name,)) @classmethod - def xy(cls, *args) -> FunctionExpression: + def xy(cls, item: IntoExpression = None, /) -> Expression: """ Returns the x- and y-coordinates for the current event as a two-element array. - If no arguments are provided, the top-level coordinate space of the view is used. - If a scenegraph *item* (or string group name) is provided, the coordinate space of the group item is used. + If no arguments are provided, the top-level coordinate space of the view is used. If a + scenegraph ``item`` (or string group name) is provided, the coordinate space of the group + item is used. """ - return FunctionExpression("xy", args) + return FunctionExpression("xy", (item,)) @classmethod - def x(cls, *args) -> FunctionExpression: + def x(cls, item: IntoExpression = None, /) -> Expression: """ Returns the x coordinate for the current event. - If no arguments are provided, the top-level coordinate space of the view is used. - If a scenegraph *item* (or string group name) is provided, the coordinate space of the group item is used. + If no arguments are provided, the top-level coordinate space of the view is used. If a + scenegraph ``item`` (or string group name) is provided, the coordinate space of the group + item is used. """ - return FunctionExpression("x", args) + return FunctionExpression("x", (item,)) @classmethod - def y(cls, *args) -> FunctionExpression: + def y(cls, item: IntoExpression = None, /) -> Expression: """ Returns the y coordinate for the current event. - If no arguments are provided, the top-level coordinate space of the view is used. - If a scenegraph *item* (or string group name) is provided, the coordinate space of the group item is used. + If no arguments are provided, the top-level coordinate space of the view is used. If a + scenegraph ``item`` (or string group name) is provided, the coordinate space of the group + item is used. """ - return FunctionExpression("y", args) + return FunctionExpression("y", (item,)) @classmethod - def pinchDistance(cls, *args) -> FunctionExpression: + def pinchDistance(cls, event: IntoExpression, /) -> Expression: """Returns the pixel distance between the first two touch points of a multi-touch event.""" - return FunctionExpression("pinchDistance", args) + return FunctionExpression("pinchDistance", (event,)) @classmethod - def pinchAngle(cls, *args) -> FunctionExpression: + def pinchAngle(cls, event: IntoExpression, /) -> Expression: """Returns the angle of the line connecting the first two touch points of a multi-touch event.""" - return FunctionExpression("pinchAngle", args) + return FunctionExpression("pinchAngle", (event,)) @classmethod - def inScope(cls, *args) -> FunctionExpression: - """Returns true if the given scenegraph *item* is a descendant of the group mark in which the event handler was defined, false otherwise.""" - return FunctionExpression("inScope", args) + def inScope(cls, item: IntoExpression, /) -> Expression: + """Returns true if the given scenegraph ``item`` is a descendant of the group mark in which the event handler was defined, false otherwise.""" + return FunctionExpression("inScope", (item,)) @classmethod - def data(cls, *args) -> FunctionExpression: + def data(cls, name: IntoExpression, /) -> Expression: """ - Returns the array of data objects for the Vega data set with the given *name*. + Returns the array of data objects for the Vega data set with the given ``name``. If the data set is not found, returns an empty array. """ - return FunctionExpression("data", args) + return FunctionExpression("data", (name,)) @classmethod - def indata(cls, *args) -> FunctionExpression: + def indata( + cls, name: IntoExpression, field: IntoExpression, value: IntoExpression, / + ) -> Expression: """ - Tests if the data set with a given *name* contains a datum with a *field* value that matches the input *value*. + Tests if the data set with a given ``name`` contains a datum with a ``field`` value that matches the input ``value``. - For example: `indata('table', 'category', value)`. + For example: ``alt.expr.indata('table', 'category', value)``. """ - return FunctionExpression("indata", args) + return FunctionExpression("indata", (name, field, value)) @classmethod - def scale(cls, *args) -> FunctionExpression: + def scale( + cls, + name: IntoExpression, + value: IntoExpression, + group: IntoExpression = None, + /, + ) -> Expression: """ - Applies the named scale transform (or projection) to the specified *value*. + Applies the named scale transform (or projection) to the specified ``value``. - The optional *group* argument takes a scenegraph group mark item to indicate the specific scope in which to look up the scale or projection. + The optional ``group`` argument takes a scenegraph group mark item to indicate the specific + scope in which to look up the scale or projection. """ - return FunctionExpression("scale", args) + return FunctionExpression("scale", (name, value, group)) @classmethod - def invert(cls, *args) -> FunctionExpression: + def invert( + cls, + name: IntoExpression, + value: IntoExpression, + group: IntoExpression = None, + /, + ) -> Expression: """ - Inverts the named scale transform (or projection) for the specified *value*. + Inverts the named scale transform (or projection) for the specified ``value``. - The optional *group* argument takes a scenegraph group mark item to indicate the specific scope in which to look up the scale or projection. + The optional ``group`` argument takes a scenegraph group mark item to indicate the specific + scope in which to look up the scale or projection. """ - return FunctionExpression("invert", args) + return FunctionExpression("invert", (name, value, group)) @classmethod - def copy(cls, *args) -> FunctionExpression: # type: ignore[override] + def copy(cls, name: IntoExpression, group: IntoExpression = None, /) -> Expression: # type: ignore[override] """ - Returns a copy (a new cloned instance) of the named scale transform of projection, or `undefined` if no scale or projection is found. + Returns a copy (a new cloned instance) of the named scale transform of projection, or ``undefined`` if no scale or projection is found. - The optional *group* argument takes a scenegraph group mark item to indicate the specific scope in which to look up the scale or projection. + The optional ``group`` argument takes a scenegraph group mark item to indicate the specific + scope in which to look up the scale or projection. """ - # error: Signature of "copy" incompatible with supertype "SchemaBase" [override] - # note: def copy(self, deep: bool | Iterable[Any] = ..., ignore: list[str] | None = ...) -> expr - # NOTE: Not relevant as `expr() -> ExprRef` - # this method is only accesible via `expr.copy()` - return FunctionExpression("copy", args) + return FunctionExpression("copy", (name, group)) @classmethod - def domain(cls, *args) -> FunctionExpression: + def domain( + cls, name: IntoExpression, group: IntoExpression = None, / + ) -> Expression: """ Returns the scale domain array for the named scale transform, or an empty array if the scale is not found. - The optional *group* argument takes a scenegraph group mark item to indicate the specific scope in which to look up the scale. + The optional ``group`` argument takes a scenegraph group mark item to indicate the specific + scope in which to look up the scale. """ - return FunctionExpression("domain", args) + return FunctionExpression("domain", (name, group)) @classmethod - def range(cls, *args) -> FunctionExpression: + def range(cls, name: IntoExpression, group: IntoExpression = None, /) -> Expression: """ Returns the scale range array for the named scale transform, or an empty array if the scale is not found. - The optional *group* argument takes a scenegraph group mark item to indicate the specific scope in which to look up the scale. + The optional ``group`` argument takes a scenegraph group mark item to indicate the specific + scope in which to look up the scale. """ - return FunctionExpression("range", args) + return FunctionExpression("range", (name, group)) @classmethod - def bandwidth(cls, *args) -> FunctionExpression: + def bandwidth( + cls, name: IntoExpression, group: IntoExpression = None, / + ) -> Expression: """ Returns the current band width for the named band scale transform, or zero if the scale is not found or is not a band scale. - The optional *group* argument takes a scenegraph group mark item to indicate the specific scope in which to look up the scale. + The optional ``group`` argument takes a scenegraph group mark item to indicate the specific + scope in which to look up the scale. """ - return FunctionExpression("bandwidth", args) + return FunctionExpression("bandwidth", (name, group)) @classmethod - def bandspace(cls, *args) -> FunctionExpression: + def bandspace( + cls, + count: IntoExpression, + paddingInner: IntoExpression = None, + paddingOuter: IntoExpression = None, + /, + ) -> Expression: """ - Returns the number of steps needed within a band scale, based on the *count* of domain elements and the inner and outer padding values. + Returns the number of steps needed within a band scale, based on the ``count`` of domain elements and the inner and outer padding values. - While normally calculated within the scale itself, this function can be helpful for determining the size of a chart's layout. + While normally calculated within the scale itself, this function can be helpful for + determining the size of a chart's layout. """ - return FunctionExpression("bandspace", args) + return FunctionExpression("bandspace", (count, paddingInner, paddingOuter)) @classmethod - def gradient(cls, *args) -> FunctionExpression: + def gradient( + cls, + scale: IntoExpression, + p0: IntoExpression, + p1: IntoExpression, + count: IntoExpression = None, + /, + ) -> Expression: """ - Returns a linear color gradient for the *scale* (whose range must be a `continuous color scheme `__ and starting and ending points *p0* and *p1*, each an `[x, y]` array. + Returns a linear color gradient for the ``scale`` (whose range must be a `continuous color scheme`_) and starting and ending points ``p0`` and ``p1``, each an *[x, y]* array. - The points *p0* and *p1* should be expressed in normalized coordinates in the domain `[0, 1]`, relative to the bounds of the item being colored. + The points ``p0`` and ``p1`` should be expressed in normalized coordinates in the domain [0, + 1], relative to the bounds of the item being colored. If unspecified, ``p0`` defaults to + ``[0, 0]`` and ``p1`` defaults to ``[1, 0]``, for a horizontal gradient that spans the full + bounds of an item. The optional ``count`` argument indicates a desired target number of + sample points to take from the color scale. - If unspecified, *p0* defaults to `[0, 0]` and *p1* defaults to `[1, 0]`, for a horizontal gradient that spans the full bounds of an item. - The optional *count* argument indicates a desired target number of sample points to take from the color scale. + .. _continuous color scheme: + https://vega.github.io/vega/docs/schemes """ - return FunctionExpression("gradient", args) + return FunctionExpression("gradient", (scale, p0, p1, count)) @classmethod - def panLinear(cls, *args) -> FunctionExpression: + def panLinear(cls, domain: IntoExpression, delta: IntoExpression, /) -> Expression: """ - Given a linear scale *domain* array with numeric or datetime values, returns a new two-element domain array that is the result of panning the domain by a fractional *delta*. + Given a linear scale ``domain`` array with numeric or datetime values, returns a new two-element domain array that is the result of panning the domain by a fractional ``delta``. - The *delta* value represents fractional units of the scale range; for example, `0.5` indicates panning the scale domain to the right by half the scale range. + The ``delta`` value represents fractional units of the scale range; for example, ``0.5`` + indicates panning the scale domain to the right by half the scale range. """ - return FunctionExpression("panLinear", args) + return FunctionExpression("panLinear", (domain, delta)) @classmethod - def panLog(cls, *args) -> FunctionExpression: + def panLog(cls, domain: IntoExpression, delta: IntoExpression, /) -> Expression: """ - Given a log scale *domain* array with numeric or datetime values, returns a new two-element domain array that is the result of panning the domain by a fractional *delta*. + Given a log scale ``domain`` array with numeric or datetime values, returns a new two-element domain array that is the result of panning the domain by a fractional ``delta``. - The *delta* value represents fractional units of the scale range; for example, `0.5` indicates panning the scale domain to the right by half the scale range. + The ``delta`` value represents fractional units of the scale range; for example, ``0.5`` + indicates panning the scale domain to the right by half the scale range. """ - return FunctionExpression("panLog", args) + return FunctionExpression("panLog", (domain, delta)) @classmethod - def panPow(cls, *args) -> FunctionExpression: + def panPow( + cls, domain: IntoExpression, delta: IntoExpression, exponent: IntoExpression, / + ) -> Expression: """ - Given a power scale *domain* array with numeric or datetime values and the given *exponent*, returns a new two-element domain array that is the result of panning the domain by a fractional *delta*. + Given a power scale ``domain`` array with numeric or datetime values and the given ``exponent``, returns a new two-element domain array that is the result of panning the domain by a fractional ``delta``. - The *delta* value represents fractional units of the scale range; for example, `0.5` indicates panning the scale domain to the right by half the scale range. + The ``delta`` value represents fractional units of the scale range; for example, ``0.5`` + indicates panning the scale domain to the right by half the scale range. """ - return FunctionExpression("panPow", args) + return FunctionExpression("panPow", (domain, delta, exponent)) @classmethod - def panSymlog(cls, *args) -> FunctionExpression: + def panSymlog( + cls, domain: IntoExpression, delta: IntoExpression, constant: IntoExpression, / + ) -> Expression: """ - Given a symmetric log scale *domain* array with numeric or datetime values parameterized by the given *constant*, returns a new two-element domain array that is the result of panning the domain by a fractional *delta*. + Given a symmetric log scale ``domain`` array with numeric or datetime values parameterized by the given ``constant``, returns a new two-element domain array that is the result of panning the domain by a fractional ``delta``. - The *delta* value represents fractional units of the scale range; for example, `0.5` indicates panning the scale domain to the right by half the scale range. + The ``delta`` value represents fractional units of the scale range; for example, ``0.5`` + indicates panning the scale domain to the right by half the scale range. """ - return FunctionExpression("panSymlog", args) + return FunctionExpression("panSymlog", (domain, delta, constant)) @classmethod - def zoomLinear(cls, *args) -> FunctionExpression: + def zoomLinear( + cls, + domain: IntoExpression, + anchor: IntoExpression, + scaleFactor: IntoExpression, + /, + ) -> Expression: """ - Given a linear scale *domain* array with numeric or datetime values, returns a new two-element domain array that is the result of zooming the domain by a *scaleFactor*, centered at the provided fractional *anchor*. + Given a linear scale ``domain`` array with numeric or datetime values, returns a new two-element domain array that is the result of zooming the domain by a ``scaleFactor``, centered at the provided fractional ``anchor``. - The *anchor* value represents the zoom position in terms of fractional units of the scale range; for example, `0.5` indicates a zoom centered on the mid-point of the scale range. + The ``anchor`` value represents the zoom position in terms of fractional units of the scale + range; for example, ``0.5`` indicates a zoom centered on the mid-point of the scale range. """ - return FunctionExpression("zoomLinear", args) + return FunctionExpression("zoomLinear", (domain, anchor, scaleFactor)) @classmethod - def zoomLog(cls, *args) -> FunctionExpression: + def zoomLog( + cls, + domain: IntoExpression, + anchor: IntoExpression, + scaleFactor: IntoExpression, + /, + ) -> Expression: """ - Given a log scale *domain* array with numeric or datetime values, returns a new two-element domain array that is the result of zooming the domain by a *scaleFactor*, centered at the provided fractional *anchor*. + Given a log scale ``domain`` array with numeric or datetime values, returns a new two-element domain array that is the result of zooming the domain by a ``scaleFactor``, centered at the provided fractional ``anchor``. - The *anchor* value represents the zoom position in terms of fractional units of the scale range; for example, `0.5` indicates a zoom centered on the mid-point of the scale range. + The ``anchor`` value represents the zoom position in terms of fractional units of the scale + range; for example, ``0.5`` indicates a zoom centered on the mid-point of the scale range. """ - return FunctionExpression("zoomLog", args) + return FunctionExpression("zoomLog", (domain, anchor, scaleFactor)) @classmethod - def zoomPow(cls, *args) -> FunctionExpression: + def zoomPow( + cls, + domain: IntoExpression, + anchor: IntoExpression, + scaleFactor: IntoExpression, + exponent: IntoExpression, + /, + ) -> Expression: """ - Given a power scale *domain* array with numeric or datetime values and the given *exponent*, returns a new two-element domain array that is the result of zooming the domain by a *scaleFactor*, centered at the provided fractional *anchor*. + Given a power scale ``domain`` array with numeric or datetime values and the given ``exponent``, returns a new two-element domain array that is the result of zooming the domain by a ``scaleFactor``, centered at the provided fractional ``anchor``. - The *anchor* value represents the zoom position in terms of fractional units of the scale range; for example, `0.5` indicates a zoom centered on the mid-point of the scale range. + The ``anchor`` value represents the zoom position in terms of fractional units of the scale + range; for example, ``0.5`` indicates a zoom centered on the mid-point of the scale range. """ - return FunctionExpression("zoomPow", args) + return FunctionExpression("zoomPow", (domain, anchor, scaleFactor, exponent)) @classmethod - def zoomSymlog(cls, *args) -> FunctionExpression: + def zoomSymlog( + cls, + domain: IntoExpression, + anchor: IntoExpression, + scaleFactor: IntoExpression, + constant: IntoExpression, + /, + ) -> Expression: """ - Given a symmetric log scale *domain* array with numeric or datetime values parameterized by the given *constant*, returns a new two-element domain array that is the result of zooming the domain by a *scaleFactor*, centered at the provided fractional *anchor*. + Given a symmetric log scale ``domain`` array with numeric or datetime values parameterized by the given ``constant``, returns a new two-element domain array that is the result of zooming the domain by a ``scaleFactor``, centered at the provided fractional ``anchor``. - The *anchor* value represents the zoom position in terms of fractional units of the scale range; for example, `0.5` indicates a zoom centered on the mid-point of the scale range. + The ``anchor`` value represents the zoom position in terms of fractional units of the scale + range; for example, ``0.5`` indicates a zoom centered on the mid-point of the scale range. """ - return FunctionExpression("zoomSymlog", args) + return FunctionExpression("zoomSymlog", (domain, anchor, scaleFactor, constant)) @classmethod - def geoArea(cls, *args) -> FunctionExpression: + def geoArea( + cls, + projection: IntoExpression, + feature: IntoExpression, + group: IntoExpression = None, + /, + ) -> Expression: """ - Returns the projected planar area (typically in square pixels) of a GeoJSON *feature* according to the named *projection*. + Returns the projected planar area (typically in square pixels) of a GeoJSON ``feature`` according to the named ``projection``. + + If the ``projection`` argument is ``null``, computes the spherical area in steradians using + unprojected longitude, latitude coordinates. The optional ``group`` argument takes a + scenegraph group mark item to indicate the specific scope in which to look up the + projection. Uses d3-geo's `geoArea`_ and `path.area`_ methods. - If the *projection* argument is `null`, computes the spherical area in steradians using unprojected longitude, latitude coordinates. - The optional *group* argument takes a scenegraph group mark item to indicate the specific scope in which to look up the projection. - Uses d3-geo's `geoArea `__ and `path.area `__ methods. + .. _geoArea: + https://github.com/d3/d3-geo#geoArea + .. _path.area: + https://github.com/d3/d3-geo#path_area """ - return FunctionExpression("geoArea", args) + return FunctionExpression("geoArea", (projection, feature, group)) @classmethod - def geoBounds(cls, *args) -> FunctionExpression: + def geoBounds( + cls, + projection: IntoExpression, + feature: IntoExpression, + group: IntoExpression = None, + /, + ) -> Expression: """ - Returns the projected planar bounding box (typically in pixels) for the specified GeoJSON *feature*, according to the named *projection*. + Returns the projected planar bounding box (typically in pixels) for the specified GeoJSON ``feature``, according to the named ``projection``. - The bounding box is represented by a two-dimensional array: `[[x0, y0], [x1, y1]]`, - where *x0* is the minimum x-coordinate, *y0* is the minimum y-coordinate, - *x1* is the maximum x-coordinate, and *y1* is the maximum y-coordinate. + The bounding box is represented by a two-dimensional array: [[*x₀*, *y₀*], [*x₁*, *y₁*]], + where *x₀* is the minimum x-coordinate, *y₀* is the minimum y-coordinate, *x₁* is the + maximum x-coordinate, and *y₁* is the maximum y-coordinate. If the ``projection`` argument + is ``null``, computes the spherical bounding box using unprojected longitude, latitude + coordinates. The optional ``group`` argument takes a scenegraph group mark item to indicate + the specific scope in which to look up the projection. Uses d3-geo's `geoBounds`_ and + `path.bounds`_ methods. - If the *projection* argument is `null`, computes the spherical bounding box using unprojected longitude, latitude coordinates. - The optional *group* argument takes a scenegraph group mark item to indicate the specific scope in which to look up the projection. - Uses d3-geo's `geoBounds `__ and `path.bounds `__ methods. + .. _geoBounds: + https://github.com/d3/d3-geo#geoBounds + .. _path.bounds: + https://github.com/d3/d3-geo#path_bounds """ - return FunctionExpression("geoBounds", args) + return FunctionExpression("geoBounds", (projection, feature, group)) @classmethod - def geoCentroid(cls, *args) -> FunctionExpression: + def geoCentroid( + cls, + projection: IntoExpression, + feature: IntoExpression, + group: IntoExpression = None, + /, + ) -> Expression: """ - Returns the projected planar centroid (typically in pixels) for the specified GeoJSON *feature*, according to the named *projection*. + Returns the projected planar centroid (typically in pixels) for the specified GeoJSON ``feature``, according to the named ``projection``. + + If the ``projection`` argument is ``null``, computes the spherical centroid using + unprojected longitude, latitude coordinates. The optional ``group`` argument takes a + scenegraph group mark item to indicate the specific scope in which to look up the + projection. Uses d3-geo's `geoCentroid`_ and `path.centroid`_ methods. - If the *projection* argument is `null`, computes the spherical centroid using unprojected longitude, latitude coordinates. - The optional *group* argument takes a scenegraph group mark item to indicate the specific scope in which to look up the projection. - Uses d3-geo's `geoCentroid `__ and `path.centroid `__ methods. + .. _geoCentroid: + https://github.com/d3/d3-geo#geoCentroid + .. _path.centroid: + https://github.com/d3/d3-geo#path_centroid """ - return FunctionExpression("geoCentroid", args) + return FunctionExpression("geoCentroid", (projection, feature, group)) @classmethod - def treePath(cls, *args) -> FunctionExpression: + def geoScale( + cls, projection: IntoExpression, group: IntoExpression = None, / + ) -> Expression: """ - For the hierarchy data set with the given *name*, returns the shortest path through from the *source* node id to the *target* node id. + Returns the scale value for the named ``projection``. - The path starts at the *source* node, ascends to the least common ancestor of the *source* node and the *target* node, and then descends to the *target* node. + The optional ``group`` argument takes a scenegraph group mark item to indicate the specific + scope in which to look up the projection. """ - return FunctionExpression("treePath", args) + return FunctionExpression("geoScale", (projection, group)) @classmethod - def treeAncestors(cls, *args) -> FunctionExpression: - """For the hierarchy data set with the given *name*, returns the array of ancestors nodes, starting with the input *node*, then followed by each parent up to the root.""" - return FunctionExpression("treeAncestors", args) + def treePath( + cls, name: IntoExpression, source: IntoExpression, target: IntoExpression, / + ) -> Expression: + """ + For the hierarchy data set with the given ``name``, returns the shortest path through from the ``source`` node id to the ``target`` node id. + + The path starts at the ``source`` node, ascends to the least common ancestor of the + ``source`` node and the ``target`` node, and then descends to the ``target`` node. + """ + return FunctionExpression("treePath", (name, source, target)) @classmethod - def containerSize(cls, *args) -> FunctionExpression: + def treeAncestors(cls, name: IntoExpression, node: IntoExpression, /) -> Expression: + """For the hierarchy data set with the given ``name``, returns the array of ancestors nodes, starting with the input ``node``, then followed by each parent up to the root.""" + return FunctionExpression("treeAncestors", (name, node)) + + @classmethod + def containerSize(cls) -> Expression: """ - Returns the current CSS box size (`[el.clientWidth, el.clientHeight]`) of the parent DOM element that contains the Vega view. + Returns the current CSS box size (``[el.clientWidth, el.clientHeight]``) of the parent DOM element that contains the Vega view. - If there is no container element, returns `[undefined, undefined]`. + If there is no container element, returns ``[undefined, undefined]``. """ - return FunctionExpression("containerSize", args) + return FunctionExpression("containerSize", ()) @classmethod - def screen(cls, *args) -> FunctionExpression: - """Returns the `window.screen `__ object, or `{}` if Vega is not running in a browser environment.""" - return FunctionExpression("screen", args) + def screen(cls) -> Expression: + """ + Returns the `window.screen`_ object, or ``{}`` if Vega is not running in a browser environment. + + .. _window.screen: + https://developer.mozilla.org/en-US/docs/Web/API/Window/screen + """ + return FunctionExpression("screen", ()) @classmethod - def windowSize(cls, *args) -> FunctionExpression: - """Returns the current window size (`[window.innerWidth, window.innerHeight]`) or `[undefined, undefined]` if Vega is not running in a browser environment.""" - return FunctionExpression("windowSize", args) + def windowSize(cls) -> Expression: + """Returns the current window size (``[window.innerWidth, window.innerHeight]``) or ``[undefined, undefined]`` if Vega is not running in a browser environment.""" + return FunctionExpression("windowSize", ()) @classmethod - def warn(cls, *args) -> FunctionExpression: + def warn( + cls, value1: IntoExpression, value2: IntoExpression = None, *args: Any + ) -> Expression: """ Logs a warning message and returns the last argument. - For the message to appear in the console, the visualization view must have the appropriate logging level set. + For the message to appear in the console, the visualization view must have the appropriate + logging level set. """ - return FunctionExpression("warn", args) + return FunctionExpression("warn", (value1, value2, *args)) @classmethod - def info(cls, *args) -> FunctionExpression: + def info( + cls, value1: IntoExpression, value2: IntoExpression = None, *args: Any + ) -> Expression: """ Logs an informative message and returns the last argument. - For the message to appear in the console, the visualization view must have the appropriate logging level set. + For the message to appear in the console, the visualization view must have the appropriate + logging level set. """ - return FunctionExpression("info", args) + return FunctionExpression("info", (value1, value2, *args)) @classmethod - def debug(cls, *args) -> FunctionExpression: + def debug( + cls, value1: IntoExpression, value2: IntoExpression = None, *args: Any + ) -> Expression: """ Logs a debugging message and returns the last argument. - For the message to appear in the console, the visualization view must have the appropriate logging level set. + For the message to appear in the console, the visualization view must have the appropriate + logging level set. """ - return FunctionExpression("debug", args) + return FunctionExpression("debug", (value1, value2, *args)) _ExprType = expr diff --git a/altair/expr/core.py b/altair/expr/core.py index e7872ada6..429766b8a 100644 --- a/altair/expr/core.py +++ b/altair/expr/core.py @@ -1,6 +1,6 @@ from __future__ import annotations -from typing import Any, Dict, Union +from typing import Any, Union from typing_extensions import TypeAlias from altair.utils import SchemaBase @@ -237,4 +237,4 @@ def __repr__(self) -> str: return f"{self.group}[{self.name!r}]" -IntoExpression: TypeAlias = Union[bool, None, str, float, OperatorMixin, Dict[str, Any]] +IntoExpression: TypeAlias = Union[bool, None, str, float, OperatorMixin, dict[str, Any]] diff --git a/altair/utils/_dfi_types.py b/altair/utils/_dfi_types.py index c9aaa0176..086db6800 100644 --- a/altair/utils/_dfi_types.py +++ b/altair/utils/_dfi_types.py @@ -7,7 +7,10 @@ from __future__ import annotations import enum -from typing import Any, Iterable, Protocol +from typing import TYPE_CHECKING, Any, Protocol + +if TYPE_CHECKING: + from collections.abc import Iterable class DtypeKind(enum.IntEnum): diff --git a/altair/utils/_importers.py b/altair/utils/_importers.py index 14085ebcf..c02cc7011 100644 --- a/altair/utils/_importers.py +++ b/altair/utils/_importers.py @@ -12,6 +12,8 @@ def import_vegafusion() -> ModuleType: min_version = "1.5.0" try: + import vegafusion as vf + version = importlib_version("vegafusion") embed_version = importlib_version("vegafusion-python-embed") if version != embed_version or Version(version) < Version(min_version): @@ -23,7 +25,6 @@ def import_vegafusion() -> ModuleType: f" - vegafusion-python-embed=={embed_version}\n" ) raise RuntimeError(msg) - import vegafusion as vf # type: ignore return vf except ImportError as err: diff --git a/altair/utils/_show.py b/altair/utils/_show.py index 39345d1ce..e61798054 100644 --- a/altair/utils/_show.py +++ b/altair/utils/_show.py @@ -2,7 +2,10 @@ import webbrowser from http.server import BaseHTTPRequestHandler, HTTPServer -from typing import Iterable +from typing import TYPE_CHECKING + +if TYPE_CHECKING: + from collections.abc import Iterable def open_html_in_browser( diff --git a/altair/utils/_transformed_data.py b/altair/utils/_transformed_data.py index 3839a13d2..a1460f2c4 100644 --- a/altair/utils/_transformed_data.py +++ b/altair/utils/_transformed_data.py @@ -1,6 +1,6 @@ from __future__ import annotations -from typing import TYPE_CHECKING, Any, Dict, Iterable, Tuple, overload +from typing import TYPE_CHECKING, Any, overload from typing_extensions import TypeAlias from altair import ( @@ -31,11 +31,13 @@ from altair.utils.schemapi import Undefined if TYPE_CHECKING: + from collections.abc import Iterable + from altair.typing import ChartType from altair.utils.core import DataFrameLike -Scope: TypeAlias = Tuple[int, ...] -FacetMapping: TypeAlias = Dict[Tuple[str, Scope], Tuple[str, Scope]] +Scope: TypeAlias = tuple[int, ...] +FacetMapping: TypeAlias = dict[tuple[str, Scope], tuple[str, Scope]] # For the transformed_data functionality, the chart classes in the values diff --git a/altair/utils/_vegafusion_data.py b/altair/utils/_vegafusion_data.py index 970098d33..66e3d99fb 100644 --- a/altair/utils/_vegafusion_data.py +++ b/altair/utils/_vegafusion_data.py @@ -1,16 +1,7 @@ from __future__ import annotations import uuid -from typing import ( - TYPE_CHECKING, - Any, - Callable, - Final, - MutableMapping, - TypedDict, - Union, - overload, -) +from typing import TYPE_CHECKING, Any, Callable, Final, TypedDict, Union, overload from weakref import WeakValueDictionary from altair.utils._importers import import_vegafusion @@ -24,9 +15,11 @@ from altair.vegalite.data import default_data_transformer if TYPE_CHECKING: + from collections.abc import MutableMapping + from narwhals.typing import IntoDataFrame - from vegafusion.runtime import ChartState # type: ignore + from vegafusion.runtime import ChartState # Temporary storage for dataframes that have been extracted # from charts by the vegafusion data transformer. Use a WeakValueDictionary diff --git a/altair/utils/compiler.py b/altair/utils/compiler.py index a022651e6..c8af2d3de 100644 --- a/altair/utils/compiler.py +++ b/altair/utils/compiler.py @@ -1,12 +1,12 @@ -from typing import Any, Callable, Dict +from typing import Any, Callable from altair.utils import PluginRegistry # ============================================================================== # Vega-Lite to Vega compiler registry # ============================================================================== -VegaLiteCompilerType = Callable[[Dict[str, Any]], Dict[str, Any]] +VegaLiteCompilerType = Callable[[dict[str, Any]], dict[str, Any]] -class VegaLiteCompilerRegistry(PluginRegistry[VegaLiteCompilerType, Dict[str, Any]]): +class VegaLiteCompilerRegistry(PluginRegistry[VegaLiteCompilerType, dict[str, Any]]): pass diff --git a/altair/utils/core.py b/altair/utils/core.py index 24ab7cadb..acc7c2810 100644 --- a/altair/utils/core.py +++ b/altair/utils/core.py @@ -8,20 +8,11 @@ import sys import traceback import warnings -from collections.abc import Mapping, MutableMapping +from collections.abc import Iterator, Mapping, MutableMapping from copy import deepcopy from itertools import groupby from operator import itemgetter -from typing import ( - TYPE_CHECKING, - Any, - Callable, - Iterator, - Literal, - TypeVar, - cast, - overload, -) +from typing import TYPE_CHECKING, Any, Callable, Literal, TypeVar, cast, overload import jsonschema import narwhals.stable.v1 as nw diff --git a/altair/utils/data.py b/altair/utils/data.py index 42c87ece4..91ed54a51 100644 --- a/altair/utils/data.py +++ b/altair/utils/data.py @@ -4,18 +4,15 @@ import json import random import sys +from collections.abc import MutableMapping, Sequence from functools import partial from pathlib import Path from typing import ( TYPE_CHECKING, Any, Callable, - Dict, - List, Literal, - MutableMapping, Protocol, - Sequence, TypedDict, TypeVar, Union, @@ -54,17 +51,17 @@ class SupportsGeoInterface(Protocol): DataType: TypeAlias = Union[ - Dict[Any, Any], IntoDataFrame, SupportsGeoInterface, DataFrameLike + dict[Any, Any], IntoDataFrame, SupportsGeoInterface, DataFrameLike ] TDataType = TypeVar("TDataType", bound=DataType) TIntoDataFrame = TypeVar("TIntoDataFrame", bound=IntoDataFrame) -VegaLiteDataDict: TypeAlias = Dict[ - str, Union[str, Dict[Any, Any], List[Dict[Any, Any]]] +VegaLiteDataDict: TypeAlias = dict[ + str, Union[str, dict[Any, Any], list[dict[Any, Any]]] ] -ToValuesReturnType: TypeAlias = Dict[str, Union[Dict[Any, Any], List[Dict[Any, Any]]]] -SampleReturnType = Union[IntoDataFrame, Dict[str, Sequence], None] +ToValuesReturnType: TypeAlias = dict[str, Union[dict[Any, Any], list[dict[Any, Any]]]] +SampleReturnType = Union[IntoDataFrame, dict[str, Sequence], None] def is_data_type(obj: Any) -> TypeIs[DataType]: diff --git a/altair/utils/display.py b/altair/utils/display.py index 91727318e..b6d6d39f5 100644 --- a/altair/utils/display.py +++ b/altair/utils/display.py @@ -4,7 +4,7 @@ import pkgutil import textwrap import uuid -from typing import Any, Callable, Dict, Tuple, Union +from typing import Any, Callable, Union from typing_extensions import TypeAlias from ._vegafusion_data import compile_with_vegafusion, using_vegafusion @@ -18,16 +18,16 @@ # MimeBundleType needs to be the same as what are acceptable return values # for _repr_mimebundle_, # see https://ipython.readthedocs.io/en/stable/config/integrating.html#MyObject._repr_mimebundle_ -MimeBundleDataType: TypeAlias = Dict[str, Any] -MimeBundleMetaDataType: TypeAlias = Dict[str, Any] +MimeBundleDataType: TypeAlias = dict[str, Any] +MimeBundleMetaDataType: TypeAlias = dict[str, Any] MimeBundleType: TypeAlias = Union[ - MimeBundleDataType, Tuple[MimeBundleDataType, MimeBundleMetaDataType] + MimeBundleDataType, tuple[MimeBundleDataType, MimeBundleMetaDataType] ] RendererType: TypeAlias = Callable[..., MimeBundleType] # Subtype of MimeBundleType as more specific in the values of the dictionaries -DefaultRendererReturnType: TypeAlias = Tuple[ - Dict[str, Union[str, Dict[str, Any]]], Dict[str, Dict[str, Any]] +DefaultRendererReturnType: TypeAlias = tuple[ + dict[str, Union[str, dict[str, Any]]], dict[str, dict[str, Any]] ] diff --git a/altair/utils/schemapi.py b/altair/utils/schemapi.py index ffe28ffa2..7eaab77c1 100644 --- a/altair/utils/schemapi.py +++ b/altair/utils/schemapi.py @@ -4,11 +4,13 @@ import contextlib import copy +import datetime as dt import inspect import json import sys import textwrap from collections import defaultdict +from collections.abc import Iterable, Iterator, Mapping, Sequence from functools import partial from importlib.metadata import version as importlib_version from itertools import chain, zip_longest @@ -16,15 +18,9 @@ from typing import ( TYPE_CHECKING, Any, - Dict, Final, Generic, - Iterable, - Iterator, - List, Literal, - Mapping, - Sequence, TypeVar, Union, cast, @@ -67,8 +63,8 @@ from typing_extensions import Never, Self _OptionalModule: TypeAlias = "ModuleType | None" -ValidationErrorList: TypeAlias = List[jsonschema.exceptions.ValidationError] -GroupedValidationErrors: TypeAlias = Dict[str, ValidationErrorList] +ValidationErrorList: TypeAlias = list[jsonschema.exceptions.ValidationError] +GroupedValidationErrors: TypeAlias = dict[str, ValidationErrorList] # This URI is arbitrary and could be anything else. It just cannot be an empty # string as we need to reference the schema registered in @@ -507,6 +503,34 @@ def _from_array_like(obj: Iterable[Any], /) -> list[Any]: return list(obj) +def _from_date_datetime(obj: dt.date | dt.datetime, /) -> dict[str, Any]: + """ + Parse native `datetime.(date|datetime)` into a `DateTime`_ schema. + + .. _DateTime: + https://vega.github.io/vega-lite/docs/datetime.html + """ + result: dict[str, Any] = {"year": obj.year, "month": obj.month, "date": obj.day} + if isinstance(obj, dt.datetime): + if obj.time() != dt.time.min: + us = obj.microsecond + ms = us if us == 0 else us // 1_000 + result.update( + hours=obj.hour, minutes=obj.minute, seconds=obj.second, milliseconds=ms + ) + if tzinfo := obj.tzinfo: + if tzinfo is dt.timezone.utc: + result["utc"] = True + else: + msg = ( + f"Unsupported timezone {tzinfo!r}.\n" + "Only `'UTC'` or naive (local) datetimes are permitted.\n" + "See https://altair-viz.github.io/user_guide/generated/core/altair.DateTime.html" + ) + raise TypeError(msg) + return result + + def _todict(obj: Any, context: dict[str, Any] | None, np_opt: Any, pd_opt: Any) -> Any: # noqa: C901 """Convert an object to a dict representation.""" if np_opt is not None: @@ -537,6 +561,8 @@ def _todict(obj: Any, context: dict[str, Any] | None, np_opt: Any, pd_opt: Any) return pd_opt.Timestamp(obj).isoformat() elif _is_iterable(obj, exclude=(str, bytes)): return _todict(_from_array_like(obj), context, np_opt, pd_opt) + elif isinstance(obj, dt.date): + return _from_date_datetime(obj) else: return obj @@ -1351,7 +1377,7 @@ def _replace_parsed_shorthand( TSchemaBase = TypeVar("TSchemaBase", bound=SchemaBase) -_CopyImpl = TypeVar("_CopyImpl", SchemaBase, Dict[Any, Any], List[Any]) +_CopyImpl = TypeVar("_CopyImpl", SchemaBase, dict[Any, Any], list[Any]) """ Types which have an implementation in ``SchemaBase.copy()``. diff --git a/altair/utils/selection.py b/altair/utils/selection.py index 13b9d5b8e..120d57ef2 100644 --- a/altair/utils/selection.py +++ b/altair/utils/selection.py @@ -1,11 +1,11 @@ from __future__ import annotations from dataclasses import dataclass -from typing import Any, Dict, List, NewType +from typing import Any, NewType # Type representing the "{selection}_store" dataset that corresponds to a # Vega-Lite selection -Store = NewType("Store", List[Dict[str, Any]]) +Store = NewType("Store", list[dict[str, Any]]) @dataclass(frozen=True, eq=True) diff --git a/altair/vegalite/v5/api.py b/altair/vegalite/v5/api.py index 592a0b800..761d59de4 100644 --- a/altair/vegalite/v5/api.py +++ b/altair/vegalite/v5/api.py @@ -9,8 +9,9 @@ import sys import typing as t import warnings +from collections.abc import Mapping, Sequence from copy import deepcopy as _deepcopy -from typing import TYPE_CHECKING, Any, Literal, Sequence, TypeVar, Union, overload +from typing import TYPE_CHECKING, Any, Literal, TypeVar, Union, overload import jsonschema import narwhals.stable.v1 as nw @@ -30,7 +31,7 @@ from .data import data_transformers from .display import VEGA_VERSION, VEGAEMBED_VERSION, VEGALITE_VERSION, renderers from .schema import SCHEMA_URL, channels, core, mixins -from .schema._typing import Map +from .schema._typing import Map, PrimitiveValue_T, SingleDefUnitChannel_T, Temporal from .theme import themes if sys.version_info >= (3, 14): @@ -38,17 +39,26 @@ else: from typing_extensions import TypedDict if sys.version_info >= (3, 12): - from typing import Protocol, runtime_checkable + from typing import Protocol, TypeAliasType, runtime_checkable else: - from typing_extensions import Protocol, runtime_checkable # noqa: F401 + from typing_extensions import ( # noqa: F401 + Protocol, + TypeAliasType, + runtime_checkable, + ) +if sys.version_info >= (3, 11): + from typing import LiteralString +else: + from typing_extensions import LiteralString if sys.version_info >= (3, 10): from typing import TypeAlias else: from typing_extensions import TypeAlias if TYPE_CHECKING: + from collections.abc import Iterable, Iterator from pathlib import Path - from typing import IO, Iterable, Iterator + from typing import IO from altair.utils.core import DataFrameLike @@ -84,7 +94,6 @@ ResolveMode_T, SelectionResolution_T, SelectionType_T, - SingleDefUnitChannel_T, SingleTimeUnit_T, StackOffset_T, ) @@ -98,6 +107,7 @@ BindRadioSelect, BindRange, BinParams, + DateTime, Expr, ExprRef, FacetedEncoding, @@ -538,10 +548,8 @@ def check_fields_and_encodings(parameter: Parameter, field_name: str) -> bool: ``` """ -_LiteralValue: TypeAlias = Union[str, bool, float, int] -"""Primitive python value types.""" -_FieldEqualType: TypeAlias = Union[_LiteralValue, Map, Parameter, SchemaBase] +_FieldEqualType: TypeAlias = Union[PrimitiveValue_T, Map, Parameter, SchemaBase] """Permitted types for equality checks on field values: - `datum.field == ...` @@ -632,7 +640,7 @@ class _ConditionExtra(TypedDict, closed=True, total=False): # type: ignore[call param: Parameter | str test: _TestPredicateType value: Any - __extra_items__: _StatementType | OneOrSeq[_LiteralValue] + __extra_items__: _StatementType | OneOrSeq[PrimitiveValue_T] _Condition: TypeAlias = _ConditionExtra @@ -661,7 +669,7 @@ class _ConditionClosed(TypedDict, closed=True, total=False): # type: ignore[cal value: Any -_Conditions: TypeAlias = t.List[_ConditionClosed] +_Conditions: TypeAlias = list[_ConditionClosed] """ Chainable conditions produced by ``.when()`` and ``Then.when()``. @@ -1435,9 +1443,63 @@ def selection(type: Optional[SelectionType_T] = Undefined, **kwds: Any) -> Param return _selection(type=type, **kwds) +_SelectionPointValue: TypeAlias = "PrimitiveValue_T | Temporal | DateTime | Sequence[Mapping[SingleDefUnitChannel_T | LiteralString, PrimitiveValue_T | Temporal | DateTime]]" +""" +Point selections can be initialized with a single primitive value: + + import altair as alt + + alt.selection_point(fields=["year"], value=1980) + + +You can also provide a sequence of mappings between ``encodings`` or ``fields`` to **values**: + + alt.selection_point( + fields=["cylinders", "year"], + value=[{"cylinders": 4, "year": 1981}, {"cylinders": 8, "year": 1972}], + ) +""" + +_SelectionIntervalValueMap: TypeAlias = Mapping[ + SingleDefUnitChannel_T, + Union[ + tuple[bool, bool], + tuple[float, float], + tuple[str, str], + tuple["Temporal | DateTime", "Temporal | DateTime"], + Sequence[bool], + Sequence[float], + Sequence[str], + Sequence["Temporal | DateTime"], + ], +] +""" +Interval selections are initialized with a mapping between ``encodings`` to **values**: + + import altair as alt + + alt.selection_interval( + encodings=["longitude"], + empty=False, + value={"longitude": [-50, -110]}, + ) + +The values specify the **start** and **end** of the interval selection. + +You can use a ``tuple`` for type-checking each sequence has **two** elements: + + alt.selection_interval(value={"x": (55, 160), "y": (13, 37)}) + + +.. note:: + + Unlike :func:`.selection_point()`, the use of ``None`` is not permitted. +""" + + def selection_interval( name: str | None = None, - value: Optional[Any] = Undefined, + value: Optional[_SelectionIntervalValueMap] = Undefined, bind: Optional[Binding | str] = Undefined, empty: Optional[bool] = Undefined, expr: Optional[str | Expr | Expression] = Undefined, @@ -1550,7 +1612,7 @@ def selection_interval( def selection_point( name: str | None = None, - value: Optional[Any] = Undefined, + value: Optional[_SelectionPointValue] = Undefined, bind: Optional[Binding | str] = Undefined, empty: Optional[bool] = Undefined, expr: Optional[Expr] = Undefined, diff --git a/altair/vegalite/v5/schema/_config.py b/altair/vegalite/v5/schema/_config.py index 80864718d..96da254c2 100644 --- a/altair/vegalite/v5/schema/_config.py +++ b/altair/vegalite/v5/schema/_config.py @@ -4,7 +4,7 @@ from __future__ import annotations import sys -from typing import TYPE_CHECKING, Any, Literal, Sequence, TypedDict +from typing import TYPE_CHECKING, Any, Literal, TypedDict if sys.version_info >= (3, 14): from typing import TypedDict @@ -14,6 +14,8 @@ if TYPE_CHECKING: # ruff: noqa: F405 + from collections.abc import Sequence + from ._typing import * # noqa: F403 @@ -513,7 +515,7 @@ class AreaConfigKwds(TypedDict, total=False): dy: float ellipsis: str endAngle: float - fill: None | ColorHex | LinearGradientKwds | RadialGradientKwds | ColorName_T + fill: ColorHex | LinearGradientKwds | RadialGradientKwds | ColorName_T | None fillOpacity: float filled: bool font: str @@ -524,7 +526,7 @@ class AreaConfigKwds(TypedDict, total=False): href: str innerRadius: float interpolate: Interpolate_T - invalid: None | MarkInvalidDataMode_T + invalid: MarkInvalidDataMode_T | None limit: float line: bool | OverlayMarkDefKwds lineBreak: str @@ -541,7 +543,7 @@ class AreaConfigKwds(TypedDict, total=False): size: float smooth: bool startAngle: float - stroke: None | ColorHex | LinearGradientKwds | RadialGradientKwds | ColorName_T + stroke: ColorHex | LinearGradientKwds | RadialGradientKwds | ColorName_T | None strokeCap: StrokeCap_T strokeDash: Sequence[float] strokeDashOffset: float @@ -556,7 +558,7 @@ class AreaConfigKwds(TypedDict, total=False): theta2: float timeUnitBandPosition: float timeUnitBandSize: float - tooltip: str | bool | None | float | TooltipContentKwds + tooltip: str | bool | float | TooltipContentKwds | None url: str width: float x: float | Literal["width"] @@ -980,7 +982,7 @@ class AxisConfigKwds(TypedDict, total=False): disable: bool domain: bool domainCap: StrokeCap_T - domainColor: None | ColorHex | ColorName_T + domainColor: ColorHex | ColorName_T | None domainDash: Sequence[float] domainDashOffset: float domainOpacity: float @@ -989,7 +991,7 @@ class AxisConfigKwds(TypedDict, total=False): formatType: str grid: bool gridCap: StrokeCap_T - gridColor: None | ColorHex | ColorName_T + gridColor: ColorHex | ColorName_T | None gridDash: Sequence[float] gridDashOffset: float gridOpacity: float @@ -998,7 +1000,7 @@ class AxisConfigKwds(TypedDict, total=False): labelAngle: float labelBaseline: TextBaseline_T labelBound: bool | float - labelColor: None | ColorHex | ColorName_T + labelColor: ColorHex | ColorName_T | None labelExpr: str labelFlush: bool | float labelFlushOffset: float @@ -1022,7 +1024,7 @@ class AxisConfigKwds(TypedDict, total=False): style: str | Sequence[str] tickBand: Literal["center", "extent"] tickCap: StrokeCap_T - tickColor: None | ColorHex | ColorName_T + tickColor: ColorHex | ColorName_T | None tickCount: float | TimeIntervalStepKwds | TimeInterval_T tickDash: Sequence[float] tickDashOffset: float @@ -1034,12 +1036,12 @@ class AxisConfigKwds(TypedDict, total=False): tickSize: float tickWidth: float ticks: bool - title: str | None | Sequence[str] + title: str | Sequence[str] | None titleAlign: Align_T titleAnchor: TitleAnchor_T titleAngle: float titleBaseline: TextBaseline_T - titleColor: None | ColorHex | ColorName_T + titleColor: ColorHex | ColorName_T | None titleFont: str titleFontSize: float titleFontStyle: str @@ -1491,7 +1493,7 @@ class BarConfigKwds(TypedDict, total=False): dy: float ellipsis: str endAngle: float - fill: None | ColorHex | LinearGradientKwds | RadialGradientKwds | ColorName_T + fill: ColorHex | LinearGradientKwds | RadialGradientKwds | ColorName_T | None fillOpacity: float filled: bool font: str @@ -1502,7 +1504,7 @@ class BarConfigKwds(TypedDict, total=False): href: str innerRadius: float interpolate: Interpolate_T - invalid: None | MarkInvalidDataMode_T + invalid: MarkInvalidDataMode_T | None limit: float lineBreak: str lineHeight: float @@ -1518,7 +1520,7 @@ class BarConfigKwds(TypedDict, total=False): size: float smooth: bool startAngle: float - stroke: None | ColorHex | LinearGradientKwds | RadialGradientKwds | ColorName_T + stroke: ColorHex | LinearGradientKwds | RadialGradientKwds | ColorName_T | None strokeCap: StrokeCap_T strokeDash: Sequence[float] strokeDashOffset: float @@ -1533,7 +1535,7 @@ class BarConfigKwds(TypedDict, total=False): theta2: float timeUnitBandPosition: float timeUnitBandSize: float - tooltip: str | bool | None | float | TooltipContentKwds + tooltip: str | bool | float | TooltipContentKwds | None url: str width: float x: float | Literal["width"] @@ -3283,7 +3285,7 @@ class LegendConfigKwds(TypedDict, total=False): description: str direction: Orientation_T disable: bool - fillColor: None | ColorHex | ColorName_T + fillColor: ColorHex | ColorName_T | None gradientDirection: Orientation_T gradientHorizontalMaxLength: float gradientHorizontalMinLength: float @@ -3291,7 +3293,7 @@ class LegendConfigKwds(TypedDict, total=False): gradientLabelOffset: float gradientLength: float gradientOpacity: float - gradientStrokeColor: None | ColorHex | ColorName_T + gradientStrokeColor: ColorHex | ColorName_T | None gradientStrokeWidth: float gradientThickness: float gradientVerticalMaxLength: float @@ -3299,7 +3301,7 @@ class LegendConfigKwds(TypedDict, total=False): gridAlign: LayoutAlign_T labelAlign: Align_T labelBaseline: TextBaseline_T - labelColor: None | ColorHex | ColorName_T + labelColor: ColorHex | ColorName_T | None labelFont: str labelFontSize: float labelFontStyle: str @@ -3317,20 +3319,20 @@ class LegendConfigKwds(TypedDict, total=False): orient: LegendOrient_T padding: float rowPadding: float - strokeColor: None | ColorHex | ColorName_T + strokeColor: ColorHex | ColorName_T | None strokeDash: Sequence[float] strokeWidth: float - symbolBaseFillColor: None | ColorHex | ColorName_T - symbolBaseStrokeColor: None | ColorHex | ColorName_T + symbolBaseFillColor: ColorHex | ColorName_T | None + symbolBaseStrokeColor: ColorHex | ColorName_T | None symbolDash: Sequence[float] symbolDashOffset: float symbolDirection: Orientation_T - symbolFillColor: None | ColorHex | ColorName_T + symbolFillColor: ColorHex | ColorName_T | None symbolLimit: float symbolOffset: float symbolOpacity: float symbolSize: float - symbolStrokeColor: None | ColorHex | ColorName_T + symbolStrokeColor: ColorHex | ColorName_T | None symbolStrokeWidth: float symbolType: str tickCount: float | TimeIntervalStepKwds | TimeInterval_T @@ -3338,7 +3340,7 @@ class LegendConfigKwds(TypedDict, total=False): titleAlign: Align_T titleAnchor: TitleAnchor_T titleBaseline: TextBaseline_T - titleColor: None | ColorHex | ColorName_T + titleColor: ColorHex | ColorName_T | None titleFont: str titleFontSize: float titleFontStyle: str @@ -3820,7 +3822,7 @@ class LineConfigKwds(TypedDict, total=False): dy: float ellipsis: str endAngle: float - fill: None | ColorHex | LinearGradientKwds | RadialGradientKwds | ColorName_T + fill: ColorHex | LinearGradientKwds | RadialGradientKwds | ColorName_T | None fillOpacity: float filled: bool font: str @@ -3831,7 +3833,7 @@ class LineConfigKwds(TypedDict, total=False): href: str innerRadius: float interpolate: Interpolate_T - invalid: None | MarkInvalidDataMode_T + invalid: MarkInvalidDataMode_T | None limit: float lineBreak: str lineHeight: float @@ -3847,7 +3849,7 @@ class LineConfigKwds(TypedDict, total=False): size: float smooth: bool startAngle: float - stroke: None | ColorHex | LinearGradientKwds | RadialGradientKwds | ColorName_T + stroke: ColorHex | LinearGradientKwds | RadialGradientKwds | ColorName_T | None strokeCap: StrokeCap_T strokeDash: Sequence[float] strokeDashOffset: float @@ -3862,7 +3864,7 @@ class LineConfigKwds(TypedDict, total=False): theta2: float timeUnitBandPosition: float timeUnitBandSize: float - tooltip: str | bool | None | float | TooltipContentKwds + tooltip: str | bool | float | TooltipContentKwds | None url: str width: float x: float | Literal["width"] @@ -4344,7 +4346,7 @@ class MarkConfigKwds(TypedDict, total=False): dy: float ellipsis: str endAngle: float - fill: None | ColorHex | LinearGradientKwds | RadialGradientKwds | ColorName_T + fill: ColorHex | LinearGradientKwds | RadialGradientKwds | ColorName_T | None fillOpacity: float filled: bool font: str @@ -4355,7 +4357,7 @@ class MarkConfigKwds(TypedDict, total=False): href: str innerRadius: float interpolate: Interpolate_T - invalid: None | MarkInvalidDataMode_T + invalid: MarkInvalidDataMode_T | None limit: float lineBreak: str lineHeight: float @@ -4370,7 +4372,7 @@ class MarkConfigKwds(TypedDict, total=False): size: float smooth: bool startAngle: float - stroke: None | ColorHex | LinearGradientKwds | RadialGradientKwds | ColorName_T + stroke: ColorHex | LinearGradientKwds | RadialGradientKwds | ColorName_T | None strokeCap: StrokeCap_T strokeDash: Sequence[float] strokeDashOffset: float @@ -4385,7 +4387,7 @@ class MarkConfigKwds(TypedDict, total=False): theta2: float timeUnitBandPosition: float timeUnitBandSize: float - tooltip: str | bool | None | float | TooltipContentKwds + tooltip: str | bool | float | TooltipContentKwds | None url: str width: float x: float | Literal["width"] @@ -4953,7 +4955,7 @@ class OverlayMarkDefKwds(TypedDict, total=False): dy: float ellipsis: str endAngle: float - fill: None | ColorHex | LinearGradientKwds | RadialGradientKwds | ColorName_T + fill: ColorHex | LinearGradientKwds | RadialGradientKwds | ColorName_T | None fillOpacity: float filled: bool font: str @@ -4964,7 +4966,7 @@ class OverlayMarkDefKwds(TypedDict, total=False): href: str innerRadius: float interpolate: Interpolate_T - invalid: None | MarkInvalidDataMode_T + invalid: MarkInvalidDataMode_T | None limit: float lineBreak: str lineHeight: float @@ -4981,7 +4983,7 @@ class OverlayMarkDefKwds(TypedDict, total=False): size: float smooth: bool startAngle: float - stroke: None | ColorHex | LinearGradientKwds | RadialGradientKwds | ColorName_T + stroke: ColorHex | LinearGradientKwds | RadialGradientKwds | ColorName_T | None strokeCap: StrokeCap_T strokeDash: Sequence[float] strokeDashOffset: float @@ -4999,7 +5001,7 @@ class OverlayMarkDefKwds(TypedDict, total=False): thetaOffset: float timeUnitBandPosition: float timeUnitBandSize: float - tooltip: str | bool | None | float | TooltipContentKwds + tooltip: str | bool | float | TooltipContentKwds | None url: str width: float x: float | Literal["width"] @@ -5633,27 +5635,27 @@ class RangeConfigKwds(TypedDict, total=False): category: ( Sequence[ColorHex | ColorName_T] - | Sequence[str | bool | None | float | Sequence[float]] + | Sequence[str | bool | float | Sequence[float] | None] | RangeEnum_T ) diverging: ( Sequence[ColorHex | ColorName_T] - | Sequence[str | bool | None | float | Sequence[float]] + | Sequence[str | bool | float | Sequence[float] | None] | RangeEnum_T ) heatmap: ( Sequence[ColorHex | ColorName_T] - | Sequence[str | bool | None | float | Sequence[float]] + | Sequence[str | bool | float | Sequence[float] | None] | RangeEnum_T ) ordinal: ( Sequence[ColorHex | ColorName_T] - | Sequence[str | bool | None | float | Sequence[float]] + | Sequence[str | bool | float | Sequence[float] | None] | RangeEnum_T ) ramp: ( Sequence[ColorHex | ColorName_T] - | Sequence[str | bool | None | float | Sequence[float]] + | Sequence[str | bool | float | Sequence[float] | None] | RangeEnum_T ) symbol: Sequence[str] @@ -6074,7 +6076,7 @@ class RectConfigKwds(TypedDict, total=False): dy: float ellipsis: str endAngle: float - fill: None | ColorHex | LinearGradientKwds | RadialGradientKwds | ColorName_T + fill: ColorHex | LinearGradientKwds | RadialGradientKwds | ColorName_T | None fillOpacity: float filled: bool font: str @@ -6085,7 +6087,7 @@ class RectConfigKwds(TypedDict, total=False): href: str innerRadius: float interpolate: Interpolate_T - invalid: None | MarkInvalidDataMode_T + invalid: MarkInvalidDataMode_T | None limit: float lineBreak: str lineHeight: float @@ -6101,7 +6103,7 @@ class RectConfigKwds(TypedDict, total=False): size: float smooth: bool startAngle: float - stroke: None | ColorHex | LinearGradientKwds | RadialGradientKwds | ColorName_T + stroke: ColorHex | LinearGradientKwds | RadialGradientKwds | ColorName_T | None strokeCap: StrokeCap_T strokeDash: Sequence[float] strokeDashOffset: float @@ -6116,7 +6118,7 @@ class RectConfigKwds(TypedDict, total=False): theta2: float timeUnitBandPosition: float timeUnitBandSize: float - tooltip: str | bool | None | float | TooltipContentKwds + tooltip: str | bool | float | TooltipContentKwds | None url: str width: float x: float | Literal["width"] @@ -6376,7 +6378,7 @@ class ScaleInvalidDataConfigKwds(TypedDict, total=False): ) fill: ( Literal["zero-or-min"] - | Value[None | ColorHex | LinearGradientKwds | RadialGradientKwds | ColorName_T] + | Value[ColorHex | LinearGradientKwds | RadialGradientKwds | ColorName_T | None] ) fillOpacity: Value[float] | Literal["zero-or-min"] opacity: Value[float] | Literal["zero-or-min"] @@ -6385,7 +6387,7 @@ class ScaleInvalidDataConfigKwds(TypedDict, total=False): size: Value[float] | Literal["zero-or-min"] stroke: ( Literal["zero-or-min"] - | Value[None | ColorHex | LinearGradientKwds | RadialGradientKwds | ColorName_T] + | Value[ColorHex | LinearGradientKwds | RadialGradientKwds | ColorName_T | None] ) strokeDash: Literal["zero-or-min"] | Value[Sequence[float]] strokeOpacity: Value[float] | Literal["zero-or-min"] @@ -6986,7 +6988,7 @@ class TickConfigKwds(TypedDict, total=False): dy: float ellipsis: str endAngle: float - fill: None | ColorHex | LinearGradientKwds | RadialGradientKwds | ColorName_T + fill: ColorHex | LinearGradientKwds | RadialGradientKwds | ColorName_T | None fillOpacity: float filled: bool font: str @@ -6997,7 +6999,7 @@ class TickConfigKwds(TypedDict, total=False): href: str innerRadius: float interpolate: Interpolate_T - invalid: None | MarkInvalidDataMode_T + invalid: MarkInvalidDataMode_T | None limit: float lineBreak: str lineHeight: float @@ -7012,7 +7014,7 @@ class TickConfigKwds(TypedDict, total=False): size: float smooth: bool startAngle: float - stroke: None | ColorHex | LinearGradientKwds | RadialGradientKwds | ColorName_T + stroke: ColorHex | LinearGradientKwds | RadialGradientKwds | ColorName_T | None strokeCap: StrokeCap_T strokeDash: Sequence[float] strokeDashOffset: float @@ -7028,7 +7030,7 @@ class TickConfigKwds(TypedDict, total=False): thickness: float timeUnitBandPosition: float timeUnitBandSize: float - tooltip: str | bool | None | float | TooltipContentKwds + tooltip: str | bool | float | TooltipContentKwds | None url: str width: float x: float | Literal["width"] @@ -7173,7 +7175,7 @@ class TitleConfigKwds(TypedDict, total=False): angle: float aria: bool baseline: TextBaseline_T - color: None | ColorHex | ColorName_T + color: ColorHex | ColorName_T | None dx: float dy: float font: str @@ -7185,7 +7187,7 @@ class TitleConfigKwds(TypedDict, total=False): lineHeight: float offset: float orient: TitleOrient_T - subtitleColor: None | ColorHex | ColorName_T + subtitleColor: ColorHex | ColorName_T | None subtitleFont: str subtitleFontSize: float subtitleFontStyle: str @@ -7302,7 +7304,7 @@ class TitleParamsKwds(TypedDict, total=False): angle: float aria: bool baseline: TextBaseline_T - color: None | ColorHex | ColorName_T + color: ColorHex | ColorName_T | None dx: float dy: float font: str @@ -7316,7 +7318,7 @@ class TitleParamsKwds(TypedDict, total=False): orient: TitleOrient_T style: str | Sequence[str] subtitle: str | Sequence[str] - subtitleColor: None | ColorHex | ColorName_T + subtitleColor: ColorHex | ColorName_T | None subtitleFont: str subtitleFontSize: float subtitleFontStyle: str @@ -7397,7 +7399,7 @@ class TopLevelSelectionParameterKwds(TypedDict, total=False): | LegendStreamBindingKwds | Literal["legend", "scales"] ) - value: str | bool | None | float | DateTimeKwds | Sequence[Map] + value: DateTimeKwds | Sequence[Map] | PrimitiveValue_T views: Sequence[str] @@ -7510,10 +7512,10 @@ class ViewBackgroundKwds(TypedDict, total=False): cornerRadius: float cursor: Cursor_T - fill: None | ColorHex | ColorName_T + fill: ColorHex | ColorName_T | None fillOpacity: float opacity: float - stroke: None | ColorHex | ColorName_T + stroke: ColorHex | ColorName_T | None strokeCap: StrokeCap_T strokeDash: Sequence[float] strokeDashOffset: float @@ -7610,11 +7612,11 @@ class ViewConfigKwds(TypedDict, total=False): cursor: Cursor_T discreteHeight: float discreteWidth: float - fill: None | ColorHex | ColorName_T + fill: ColorHex | ColorName_T | None fillOpacity: float opacity: float step: float - stroke: None | ColorHex | ColorName_T + stroke: ColorHex | ColorName_T | None strokeCap: StrokeCap_T strokeDash: Sequence[float] strokeDashOffset: float diff --git a/altair/vegalite/v5/schema/_typing.py b/altair/vegalite/v5/schema/_typing.py index e2ea00ed5..fd6383ad7 100644 --- a/altair/vegalite/v5/schema/_typing.py +++ b/altair/vegalite/v5/schema/_typing.py @@ -5,7 +5,9 @@ import re import sys -from typing import Any, Generic, Literal, Mapping, Sequence, TypeVar, Union +from collections.abc import Mapping, Sequence +from datetime import date, datetime +from typing import Annotated, Any, Generic, Literal, TypeVar, Union, get_args if sys.version_info >= (3, 14): # https://peps.python.org/pep-0728/ from typing import TypedDict @@ -32,11 +34,6 @@ else: from typing_extensions import TypeAlias -if sys.version_info >= (3, 9): - from typing import Annotated, get_args -else: - from typing_extensions import Annotated, get_args - __all__ = [ "AggregateOp_T", @@ -60,8 +57,6 @@ "Interpolate_T", "LayoutAlign_T", "LegendOrient_T", - "LocalMultiTimeUnit_T", - "LocalSingleTimeUnit_T", "Map", "MarkInvalidDataMode_T", "MarkType_T", @@ -72,6 +67,7 @@ "Orient_T", "Orientation_T", "PaddingKwds", + "PrimitiveValue_T", "ProjectionType_T", "RangeEnum_T", "ResolveMode_T", @@ -82,7 +78,6 @@ "SelectionType_T", "SingleDefUnitChannel_T", "SingleTimeUnit_T", - "SortByChannelDesc_T", "SortByChannel_T", "SortOrder_T", "StackOffset_T", @@ -90,6 +85,7 @@ "StepFor_T", "StrokeCap_T", "StrokeJoin_T", + "Temporal", "TextBaseline_T", "TextDirection_T", "TimeInterval_T", @@ -98,8 +94,6 @@ "TitleOrient_T", "TypeForShape_T", "Type_T", - "UtcMultiTimeUnit_T", - "UtcSingleTimeUnit_T", "Value", "VegaThemes", "WindowOnlyOp_T", @@ -201,6 +195,8 @@ class PaddingKwds(TypedDict, total=False): top: float +Temporal: TypeAlias = Union[date, datetime] + VegaThemes: TypeAlias = Literal[ "carbong10", "carbong100", @@ -218,6 +214,7 @@ class PaddingKwds(TypedDict, total=False): "vox", ] Map: TypeAlias = Mapping[str, Any] +PrimitiveValue_T: TypeAlias = Union[str, bool, float, None] AggregateOp_T: TypeAlias = Literal[ "argmax", "argmin", @@ -884,50 +881,6 @@ class PaddingKwds(TypedDict, total=False): "bottom-left", "bottom-right", ] -LocalMultiTimeUnit_T: TypeAlias = Literal[ - "yearquarter", - "yearquartermonth", - "yearmonth", - "yearmonthdate", - "yearmonthdatehours", - "yearmonthdatehoursminutes", - "yearmonthdatehoursminutesseconds", - "yearweek", - "yearweekday", - "yearweekdayhours", - "yearweekdayhoursminutes", - "yearweekdayhoursminutesseconds", - "yeardayofyear", - "quartermonth", - "monthdate", - "monthdatehours", - "monthdatehoursminutes", - "monthdatehoursminutesseconds", - "weekday", - "weekdayhours", - "weekdayhoursminutes", - "weekdayhoursminutesseconds", - "dayhours", - "dayhoursminutes", - "dayhoursminutesseconds", - "hoursminutes", - "hoursminutesseconds", - "minutesseconds", - "secondsmilliseconds", -] -LocalSingleTimeUnit_T: TypeAlias = Literal[ - "year", - "quarter", - "month", - "week", - "day", - "dayofyear", - "date", - "hours", - "minutes", - "seconds", - "milliseconds", -] MarkInvalidDataMode_T: TypeAlias = Literal[ "filter", "break-paths-filter-domains", @@ -1153,20 +1106,6 @@ class PaddingKwds(TypedDict, total=False): "utcseconds", "utcmilliseconds", ] -SortByChannelDesc_T: TypeAlias = Literal[ - "-x", - "-y", - "-color", - "-fill", - "-stroke", - "-strokeWidth", - "-size", - "-shape", - "-fillOpacity", - "-strokeOpacity", - "-opacity", - "-text", -] SortByChannel_T: TypeAlias = Literal[ "x", "y", @@ -1199,50 +1138,6 @@ class PaddingKwds(TypedDict, total=False): TitleOrient_T: TypeAlias = Literal["none", "left", "right", "top", "bottom"] TypeForShape_T: TypeAlias = Literal["nominal", "ordinal", "geojson"] Type_T: TypeAlias = Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"] -UtcMultiTimeUnit_T: TypeAlias = Literal[ - "utcyearquarter", - "utcyearquartermonth", - "utcyearmonth", - "utcyearmonthdate", - "utcyearmonthdatehours", - "utcyearmonthdatehoursminutes", - "utcyearmonthdatehoursminutesseconds", - "utcyearweek", - "utcyearweekday", - "utcyearweekdayhours", - "utcyearweekdayhoursminutes", - "utcyearweekdayhoursminutesseconds", - "utcyeardayofyear", - "utcquartermonth", - "utcmonthdate", - "utcmonthdatehours", - "utcmonthdatehoursminutes", - "utcmonthdatehoursminutesseconds", - "utcweekday", - "utcweekdayhours", - "utcweekdayhoursminutes", - "utcweekdayhoursminutesseconds", - "utcdayhours", - "utcdayhoursminutes", - "utcdayhoursminutesseconds", - "utchoursminutes", - "utchoursminutesseconds", - "utcminutesseconds", - "utcsecondsmilliseconds", -] -UtcSingleTimeUnit_T: TypeAlias = Literal[ - "utcyear", - "utcquarter", - "utcmonth", - "utcweek", - "utcday", - "utcdayofyear", - "utcdate", - "utchours", - "utcminutes", - "utcseconds", - "utcmilliseconds", -] WindowOnlyOp_T: TypeAlias = Literal[ "row_number", "rank", diff --git a/altair/vegalite/v5/schema/channels.py b/altair/vegalite/v5/schema/channels.py index c978330a5..3562bc83e 100644 --- a/altair/vegalite/v5/schema/channels.py +++ b/altair/vegalite/v5/schema/channels.py @@ -11,7 +11,7 @@ # However, we need these overloads due to how the propertysetter works # mypy: disable-error-code="no-overload-impl, empty-body, misc" import sys -from typing import TYPE_CHECKING, Any, Literal, Sequence, TypedDict, Union, overload +from typing import TYPE_CHECKING, Any, Literal, TypedDict, Union, overload if sys.version_info >= (3, 10): from typing import TypeAlias @@ -28,9 +28,21 @@ if TYPE_CHECKING: # ruff: noqa: F405 + from collections.abc import Sequence + from altair import Parameter, SchemaBase from altair.typing import Optional - from altair.vegalite.v5.api import IntoCondition + from altair.vegalite.v5.api import Bin, Impute, IntoCondition + from altair.vegalite.v5.schema.core import ( + Axis, + DateTime, + EncodingSortField, + Header, + Legend, + RepeatRef, + Scale, + TimeUnitParams, + ) if sys.version_info >= (3, 11): from typing import Self @@ -275,7 +287,7 @@ class Angle(FieldChannelMixin, core.FieldOrDatumDefWithConditionMarkPropFieldDef Relative position on a band of a stacked, binned, time unit, or band scale. For example, the marks will be positioned at the beginning of the band if set to ``0``, and at the middle of the band if set to ``0.5``. - bin : bool, dict, None, :class:`BinParams` + bin : bool, dict, :class:`BinParams`, None A flag for binning a ``quantitative`` field, `an object defining binning parameters `__, or indicating that the data for ``x`` or ``y`` channel are binned before they are imported into @@ -318,7 +330,7 @@ class Angle(FieldChannelMixin, core.FieldOrDatumDefWithConditionMarkPropFieldDef about escaping in the `field documentation `__. 2) ``field`` is not required if ``aggregate`` is ``count``. - legend : dict, None, :class:`Legend` + legend : dict, :class:`Legend`, None An object defining properties of the legend. If ``null``, the legend for the encoding channel will be removed. @@ -327,7 +339,7 @@ class Angle(FieldChannelMixin, core.FieldOrDatumDefWithConditionMarkPropFieldDef **See also:** `legend `__ documentation. - scale : dict, None, :class:`Scale` + scale : dict, :class:`Scale`, None An object defining properties of the channel's scale, which is the function that transforms values in the data domain (numbers, dates, strings, etc) to visual values (pixels, colors, sizes) of the encoding channels. @@ -340,7 +352,7 @@ class Angle(FieldChannelMixin, core.FieldOrDatumDefWithConditionMarkPropFieldDef **See also:** `scale `__ documentation. - sort : dict, None, :class:`Sort`, Sequence[str], Sequence[bool], Sequence[float], :class:`SortArray`, :class:`SortOrder`, :class:`AllSortString`, :class:`SortByChannel`, :class:`SortByEncoding`, :class:`EncodingSortField`, :class:`SortByChannelDesc`, Sequence[dict, :class:`DateTime`], Literal['-x', '-y', '-color', '-fill', '-stroke', '-strokeWidth', '-size', '-shape', '-fillOpacity', '-strokeOpacity', '-opacity', '-text', 'ascending', 'descending', 'x', 'y', 'color', 'fill', 'stroke', 'strokeWidth', 'size', 'shape', 'fillOpacity', 'strokeOpacity', 'opacity', 'text'] + sort : dict, :class:`Sort`, Sequence[str], Sequence[bool], Sequence[float], :class:`SortArray`, :class:`SortOrder`, :class:`AllSortString`, :class:`SortByChannel`, :class:`SortByEncoding`, :class:`EncodingSortField`, :class:`SortByChannelDesc`, Sequence[dict, :class:`DateTime`], Literal['-x', '-y', '-color', '-fill', '-stroke', '-strokeWidth', '-size', '-shape', '-fillOpacity', '-strokeOpacity', '-opacity', '-text', 'ascending', 'descending', 'x', 'y', 'color', 'fill', 'stroke', 'strokeWidth', 'size', 'shape', 'fillOpacity', 'strokeOpacity', 'opacity', 'text'], None Sort order for the encoded field. For continuous fields (quantitative or temporal), ``sort`` can be either @@ -387,7 +399,7 @@ class Angle(FieldChannelMixin, core.FieldOrDatumDefWithConditionMarkPropFieldDef **See also:** `timeUnit `__ documentation. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -479,27 +491,19 @@ class Angle(FieldChannelMixin, core.FieldOrDatumDefWithConditionMarkPropFieldDef _encoding_name = "angle" @overload - def aggregate(self, _: NonArgAggregateOp_T, **kwds) -> Angle: ... - + def aggregate(self, _: NonArgAggregateOp_T, /) -> Angle: ... @overload - def aggregate( - self, argmax: Optional[str | SchemaBase] = Undefined, **kwds - ) -> Angle: ... - + def aggregate(self, *, argmax: Optional[str | SchemaBase] = Undefined) -> Angle: ... @overload - def aggregate( - self, argmin: Optional[str | SchemaBase] = Undefined, **kwds - ) -> Angle: ... - + def aggregate(self, *, argmin: Optional[str | SchemaBase] = Undefined) -> Angle: ... @overload - def bandPosition(self, _: float, **kwds) -> Angle: ... - + def bandPosition(self, _: float, /) -> Angle: ... @overload - def bin(self, _: bool, **kwds) -> Angle: ... - + def bin(self, _: bool | Bin | None, /) -> Angle: ... @overload def bin( self, + *, anchor: Optional[float] = Undefined, base: Optional[float] = Undefined, binned: Optional[bool] = Undefined, @@ -510,47 +514,38 @@ def bin( nice: Optional[bool] = Undefined, step: Optional[float] = Undefined, steps: Optional[Sequence[float]] = Undefined, - **kwds, ) -> Angle: ... - - @overload - def bin(self, _: None, **kwds) -> Angle: ... - @overload def condition( self, + *, test: Optional[str | SchemaBase | Map] = Undefined, value: Optional[float | Parameter | SchemaBase | Map] = Undefined, - **kwds, ) -> Angle: ... - @overload def condition( self, + *, empty: Optional[bool] = Undefined, param: Optional[str | SchemaBase] = Undefined, value: Optional[float | Parameter | SchemaBase | Map] = Undefined, - **kwds, ) -> Angle: ... - @overload - def condition( - self, _: list[core.ConditionalValueDefnumberExprRef], **kwds - ) -> Angle: ... - + def condition(self, _: list[core.ConditionalValueDefnumberExprRef], /) -> Angle: ... @overload - def field(self, _: str, **kwds) -> Angle: ... - + def field(self, _: str | RepeatRef, /) -> Angle: ... @overload def field( self, + *, repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined, - **kwds, ) -> Angle: ... - + @overload + def legend(self, _: Legend | None, /) -> Angle: ... @overload def legend( self, + *, aria: Optional[bool | Parameter | SchemaBase | Map] = Undefined, clipHeight: Optional[float | Parameter | SchemaBase | Map] = Undefined, columnPadding: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -559,14 +554,14 @@ def legend( description: Optional[str | Parameter | SchemaBase | Map] = Undefined, direction: Optional[SchemaBase | Orientation_T] = Undefined, fillColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, format: Optional[str | SchemaBase | Map] = Undefined, formatType: Optional[str] = Undefined, gradientLength: Optional[float | Parameter | SchemaBase | Map] = Undefined, gradientOpacity: Optional[float | Parameter | SchemaBase | Map] = Undefined, gradientStrokeColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, gradientStrokeWidth: Optional[float | Parameter | SchemaBase | Map] = Undefined, gradientThickness: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -576,7 +571,7 @@ def legend( Parameter | SchemaBase | Map | TextBaseline_T ] = Undefined, labelColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, labelExpr: Optional[str] = Undefined, labelFont: Optional[str | Parameter | SchemaBase | Map] = Undefined, @@ -600,21 +595,21 @@ def legend( padding: Optional[float | Parameter | SchemaBase | Map] = Undefined, rowPadding: Optional[float | Parameter | SchemaBase | Map] = Undefined, strokeColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, symbolDash: Optional[ Parameter | SchemaBase | Sequence[float] | Map ] = Undefined, symbolDashOffset: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolFillColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, symbolLimit: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolOffset: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolOpacity: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolSize: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolStrokeColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, symbolStrokeWidth: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolType: Optional[str | Parameter | SchemaBase | Map] = Undefined, @@ -622,14 +617,14 @@ def legend( float | Parameter | SchemaBase | Map | TimeInterval_T ] = Undefined, tickMinStep: Optional[float | Parameter | SchemaBase | Map] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, titleAlign: Optional[Parameter | SchemaBase | Map | Align_T] = Undefined, titleAnchor: Optional[Parameter | SchemaBase | Map | TitleAnchor_T] = Undefined, titleBaseline: Optional[ Parameter | SchemaBase | Map | TextBaseline_T ] = Undefined, titleColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, titleFont: Optional[str | Parameter | SchemaBase | Map] = Undefined, titleFontSize: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -649,19 +644,17 @@ def legend( | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map ] = Undefined, zindex: Optional[float] = Undefined, - **kwds, ) -> Angle: ... - @overload - def legend(self, _: None, **kwds) -> Angle: ... - + def scale(self, _: Scale | None, /) -> Angle: ... @overload def scale( self, + *, align: Optional[float | Parameter | SchemaBase | Map] = Undefined, base: Optional[float | Parameter | SchemaBase | Map] = Undefined, bins: Optional[SchemaBase | Sequence[float] | Map] = Undefined, @@ -671,12 +664,18 @@ def scale( Parameter | SchemaBase | Literal["unaggregated"] - | Sequence[str | bool | None | float | Parameter | SchemaBase | Map] + | Sequence[ + str | bool | float | Temporal | Parameter | SchemaBase | Map | None + ] | Map ] = Undefined, - domainMax: Optional[float | Parameter | SchemaBase | Map] = Undefined, + domainMax: Optional[ + float | Temporal | Parameter | SchemaBase | Map + ] = Undefined, domainMid: Optional[float | Parameter | SchemaBase | Map] = Undefined, - domainMin: Optional[float | Parameter | SchemaBase | Map] = Undefined, + domainMin: Optional[ + float | Temporal | Parameter | SchemaBase | Map + ] = Undefined, domainRaw: Optional[Parameter | SchemaBase | Map] = Undefined, exponent: Optional[float | Parameter | SchemaBase | Map] = Undefined, interpolate: Optional[ @@ -701,156 +700,78 @@ def scale( scheme: Optional[Parameter | SchemaBase | Map | ColorScheme_T] = Undefined, type: Optional[SchemaBase | ScaleType_T] = Undefined, zero: Optional[bool | Parameter | SchemaBase | Map] = Undefined, - **kwds, ) -> Angle: ... - - @overload - def scale(self, _: None, **kwds) -> Angle: ... - - @overload - def sort(self, _: list[float], **kwds) -> Angle: ... - - @overload - def sort(self, _: list[str], **kwds) -> Angle: ... - - @overload - def sort(self, _: list[bool], **kwds) -> Angle: ... - - @overload - def sort(self, _: list[core.DateTime], **kwds) -> Angle: ... - - @overload - def sort(self, _: SortOrder_T, **kwds) -> Angle: ... - - @overload - def sort(self, _: SortByChannel_T, **kwds) -> Angle: ... - @overload - def sort(self, _: SortByChannelDesc_T, **kwds) -> Angle: ... - + def sort( + self, + _: Sequence[str] + | Sequence[bool] + | Sequence[float] + | Sequence[DateTime | Temporal] + | AllSortString_T + | None, + /, + ) -> Angle: ... @overload def sort( self, + *, field: Optional[str | SchemaBase | Map] = Undefined, op: Optional[SchemaBase | NonArgAggregateOp_T] = Undefined, - order: Optional[None | SchemaBase | SortOrder_T] = Undefined, - **kwds, + order: Optional[SchemaBase | SortOrder_T | None] = Undefined, ) -> Angle: ... - @overload def sort( self, + *, encoding: Optional[SchemaBase | SortByChannel_T] = Undefined, - order: Optional[None | SchemaBase | SortOrder_T] = Undefined, - **kwds, - ) -> Angle: ... - - @overload - def sort(self, _: None, **kwds) -> Angle: ... - - @overload - def timeUnit(self, _: LocalSingleTimeUnit_T, **kwds) -> Angle: ... - - @overload - def timeUnit(self, _: UtcSingleTimeUnit_T, **kwds) -> Angle: ... - - @overload - def timeUnit(self, _: LocalMultiTimeUnit_T, **kwds) -> Angle: ... - - @overload - def timeUnit(self, _: UtcMultiTimeUnit_T, **kwds) -> Angle: ... - - @overload - def timeUnit( - self, - _: Literal[ - "binnedyear", - "binnedyearquarter", - "binnedyearquartermonth", - "binnedyearmonth", - "binnedyearmonthdate", - "binnedyearmonthdatehours", - "binnedyearmonthdatehoursminutes", - "binnedyearmonthdatehoursminutesseconds", - "binnedyearweek", - "binnedyearweekday", - "binnedyearweekdayhours", - "binnedyearweekdayhoursminutes", - "binnedyearweekdayhoursminutesseconds", - "binnedyeardayofyear", - ], - **kwds, + order: Optional[SchemaBase | SortOrder_T | None] = Undefined, ) -> Angle: ... - @overload def timeUnit( self, - _: Literal[ - "binnedutcyear", - "binnedutcyearquarter", - "binnedutcyearquartermonth", - "binnedutcyearmonth", - "binnedutcyearmonthdate", - "binnedutcyearmonthdatehours", - "binnedutcyearmonthdatehoursminutes", - "binnedutcyearmonthdatehoursminutesseconds", - "binnedutcyearweek", - "binnedutcyearweekday", - "binnedutcyearweekdayhours", - "binnedutcyearweekdayhoursminutes", - "binnedutcyearweekdayhoursminutesseconds", - "binnedutcyeardayofyear", - ], - **kwds, + _: TimeUnitParams | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T, + /, ) -> Angle: ... - @overload def timeUnit( self, + *, binned: Optional[bool] = Undefined, maxbins: Optional[float] = Undefined, step: Optional[float] = Undefined, unit: Optional[SchemaBase | MultiTimeUnit_T | SingleTimeUnit_T] = Undefined, utc: Optional[bool] = Undefined, - **kwds, ) -> Angle: ... - - @overload - def title(self, _: str, **kwds) -> Angle: ... - - @overload - def title(self, _: list[str], **kwds) -> Angle: ... - @overload - def title(self, _: None, **kwds) -> Angle: ... - + def title(self, _: str | Sequence[str] | None, /) -> Angle: ... @overload - def type(self, _: StandardType_T, **kwds) -> Angle: ... + def type(self, _: StandardType_T, /) -> Angle: ... def __init__( self, shorthand: Optional[str | SchemaBase | Sequence[str] | Map] = Undefined, aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Map] = Undefined, + bin: Optional[bool | SchemaBase | Map | None] = Undefined, condition: Optional[SchemaBase | Sequence[SchemaBase | Map] | Map] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, sort: Optional[ - None - | SchemaBase + SchemaBase | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map | AllSortString_T + | None ] = Undefined, timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, **kwds, ): @@ -889,9 +810,9 @@ class AngleDatum(DatumChannelMixin, core.FieldOrDatumDefWithConditionDatumDefnum **Note:** A field definition's ``condition`` property can only contain `conditional value definitions `__ since Vega-Lite only allows at most one encoded field per encoding channel. - datum : str, bool, dict, None, float, :class:`ExprRef`, :class:`DateTime`, :class:`RepeatRef`, :class:`PrimitiveValue` + datum : str, bool, dict, float, :class:`ExprRef`, :class:`DateTime`, :class:`RepeatRef`, :class:`PrimitiveValue`, None A constant value in data domain. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -983,48 +904,37 @@ class AngleDatum(DatumChannelMixin, core.FieldOrDatumDefWithConditionDatumDefnum _encoding_name = "angle" @overload - def bandPosition(self, _: float, **kwds) -> AngleDatum: ... - + def bandPosition(self, _: float, /) -> AngleDatum: ... @overload def condition( self, + *, test: Optional[str | SchemaBase | Map] = Undefined, value: Optional[float | Parameter | SchemaBase | Map] = Undefined, - **kwds, ) -> AngleDatum: ... - @overload def condition( self, + *, empty: Optional[bool] = Undefined, param: Optional[str | SchemaBase] = Undefined, value: Optional[float | Parameter | SchemaBase | Map] = Undefined, - **kwds, ) -> AngleDatum: ... - @overload def condition( - self, _: list[core.ConditionalValueDefnumberExprRef], **kwds + self, _: list[core.ConditionalValueDefnumberExprRef], / ) -> AngleDatum: ... - @overload - def title(self, _: str, **kwds) -> AngleDatum: ... - - @overload - def title(self, _: list[str], **kwds) -> AngleDatum: ... - - @overload - def title(self, _: None, **kwds) -> AngleDatum: ... - + def title(self, _: str | Sequence[str] | None, /) -> AngleDatum: ... @overload - def type(self, _: Type_T, **kwds) -> AngleDatum: ... + def type(self, _: Type_T, /) -> AngleDatum: ... def __init__( self, datum, bandPosition: Optional[float] = Undefined, condition: Optional[SchemaBase | Sequence[SchemaBase | Map] | Map] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | Type_T] = Undefined, **kwds, ): @@ -1061,111 +971,105 @@ class AngleValue( @overload def condition( self, + *, aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Map] = Undefined, + bin: Optional[bool | SchemaBase | Map | None] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, sort: Optional[ - None - | SchemaBase + SchemaBase | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map | AllSortString_T + | None ] = Undefined, test: Optional[str | SchemaBase | Map] = Undefined, timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, - **kwds, ) -> AngleValue: ... - @overload def condition( self, + *, bandPosition: Optional[float] = Undefined, datum: Optional[ - str | bool | None | float | Parameter | SchemaBase | Map + Temporal | Parameter | SchemaBase | Map | PrimitiveValue_T ] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, test: Optional[str | SchemaBase | Map] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | Type_T] = Undefined, - **kwds, ) -> AngleValue: ... - @overload def condition( self, + *, aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Map] = Undefined, + bin: Optional[bool | SchemaBase | Map | None] = Undefined, empty: Optional[bool] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, param: Optional[str | SchemaBase] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, sort: Optional[ - None - | SchemaBase + SchemaBase | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map | AllSortString_T + | None ] = Undefined, timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, - **kwds, ) -> AngleValue: ... - @overload def condition( self, + *, bandPosition: Optional[float] = Undefined, datum: Optional[ - str | bool | None | float | Parameter | SchemaBase | Map + Temporal | Parameter | SchemaBase | Map | PrimitiveValue_T ] = Undefined, empty: Optional[bool] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, param: Optional[str | SchemaBase] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | Type_T] = Undefined, - **kwds, ) -> AngleValue: ... - @overload def condition( self, + *, test: Optional[str | SchemaBase | Map] = Undefined, value: Optional[float | Parameter | SchemaBase | Map] = Undefined, - **kwds, ) -> AngleValue: ... - @overload def condition( self, + *, empty: Optional[bool] = Undefined, param: Optional[str | SchemaBase] = Undefined, value: Optional[float | Parameter | SchemaBase | Map] = Undefined, - **kwds, ) -> AngleValue: ... - @overload def condition( - self, _: list[core.ConditionalValueDefnumberExprRef], **kwds + self, _: list[core.ConditionalValueDefnumberExprRef], / ) -> AngleValue: ... def __init__( @@ -1201,7 +1105,7 @@ class Color( Relative position on a band of a stacked, binned, time unit, or band scale. For example, the marks will be positioned at the beginning of the band if set to ``0``, and at the middle of the band if set to ``0.5``. - bin : bool, dict, None, :class:`BinParams` + bin : bool, dict, :class:`BinParams`, None A flag for binning a ``quantitative`` field, `an object defining binning parameters `__, or indicating that the data for ``x`` or ``y`` channel are binned before they are imported into @@ -1244,7 +1148,7 @@ class Color( about escaping in the `field documentation `__. 2) ``field`` is not required if ``aggregate`` is ``count``. - legend : dict, None, :class:`Legend` + legend : dict, :class:`Legend`, None An object defining properties of the legend. If ``null``, the legend for the encoding channel will be removed. @@ -1253,7 +1157,7 @@ class Color( **See also:** `legend `__ documentation. - scale : dict, None, :class:`Scale` + scale : dict, :class:`Scale`, None An object defining properties of the channel's scale, which is the function that transforms values in the data domain (numbers, dates, strings, etc) to visual values (pixels, colors, sizes) of the encoding channels. @@ -1266,7 +1170,7 @@ class Color( **See also:** `scale `__ documentation. - sort : dict, None, :class:`Sort`, Sequence[str], Sequence[bool], Sequence[float], :class:`SortArray`, :class:`SortOrder`, :class:`AllSortString`, :class:`SortByChannel`, :class:`SortByEncoding`, :class:`EncodingSortField`, :class:`SortByChannelDesc`, Sequence[dict, :class:`DateTime`], Literal['-x', '-y', '-color', '-fill', '-stroke', '-strokeWidth', '-size', '-shape', '-fillOpacity', '-strokeOpacity', '-opacity', '-text', 'ascending', 'descending', 'x', 'y', 'color', 'fill', 'stroke', 'strokeWidth', 'size', 'shape', 'fillOpacity', 'strokeOpacity', 'opacity', 'text'] + sort : dict, :class:`Sort`, Sequence[str], Sequence[bool], Sequence[float], :class:`SortArray`, :class:`SortOrder`, :class:`AllSortString`, :class:`SortByChannel`, :class:`SortByEncoding`, :class:`EncodingSortField`, :class:`SortByChannelDesc`, Sequence[dict, :class:`DateTime`], Literal['-x', '-y', '-color', '-fill', '-stroke', '-strokeWidth', '-size', '-shape', '-fillOpacity', '-strokeOpacity', '-opacity', '-text', 'ascending', 'descending', 'x', 'y', 'color', 'fill', 'stroke', 'strokeWidth', 'size', 'shape', 'fillOpacity', 'strokeOpacity', 'opacity', 'text'], None Sort order for the encoded field. For continuous fields (quantitative or temporal), ``sort`` can be either @@ -1313,7 +1217,7 @@ class Color( **See also:** `timeUnit `__ documentation. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -1405,27 +1309,19 @@ class Color( _encoding_name = "color" @overload - def aggregate(self, _: NonArgAggregateOp_T, **kwds) -> Color: ... - + def aggregate(self, _: NonArgAggregateOp_T, /) -> Color: ... @overload - def aggregate( - self, argmax: Optional[str | SchemaBase] = Undefined, **kwds - ) -> Color: ... - + def aggregate(self, *, argmax: Optional[str | SchemaBase] = Undefined) -> Color: ... @overload - def aggregate( - self, argmin: Optional[str | SchemaBase] = Undefined, **kwds - ) -> Color: ... - + def aggregate(self, *, argmin: Optional[str | SchemaBase] = Undefined) -> Color: ... @overload - def bandPosition(self, _: float, **kwds) -> Color: ... - + def bandPosition(self, _: float, /) -> Color: ... @overload - def bin(self, _: bool, **kwds) -> Color: ... - + def bin(self, _: bool | Bin | None, /) -> Color: ... @overload def bin( self, + *, anchor: Optional[float] = Undefined, base: Optional[float] = Undefined, binned: Optional[bool] = Undefined, @@ -1436,47 +1332,40 @@ def bin( nice: Optional[bool] = Undefined, step: Optional[float] = Undefined, steps: Optional[Sequence[float]] = Undefined, - **kwds, ) -> Color: ... - - @overload - def bin(self, _: None, **kwds) -> Color: ... - @overload def condition( self, + *, test: Optional[str | SchemaBase | Map] = Undefined, - value: Optional[str | None | Parameter | SchemaBase | Map] = Undefined, - **kwds, + value: Optional[str | Parameter | SchemaBase | Map | None] = Undefined, ) -> Color: ... - @overload def condition( self, + *, empty: Optional[bool] = Undefined, param: Optional[str | SchemaBase] = Undefined, - value: Optional[str | None | Parameter | SchemaBase | Map] = Undefined, - **kwds, + value: Optional[str | Parameter | SchemaBase | Map | None] = Undefined, ) -> Color: ... - @overload def condition( - self, _: list[core.ConditionalValueDefGradientstringnullExprRef], **kwds + self, _: list[core.ConditionalValueDefGradientstringnullExprRef], / ) -> Color: ... - @overload - def field(self, _: str, **kwds) -> Color: ... - + def field(self, _: str | RepeatRef, /) -> Color: ... @overload def field( self, + *, repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined, - **kwds, ) -> Color: ... - + @overload + def legend(self, _: Legend | None, /) -> Color: ... @overload def legend( self, + *, aria: Optional[bool | Parameter | SchemaBase | Map] = Undefined, clipHeight: Optional[float | Parameter | SchemaBase | Map] = Undefined, columnPadding: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -1485,14 +1374,14 @@ def legend( description: Optional[str | Parameter | SchemaBase | Map] = Undefined, direction: Optional[SchemaBase | Orientation_T] = Undefined, fillColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, format: Optional[str | SchemaBase | Map] = Undefined, formatType: Optional[str] = Undefined, gradientLength: Optional[float | Parameter | SchemaBase | Map] = Undefined, gradientOpacity: Optional[float | Parameter | SchemaBase | Map] = Undefined, gradientStrokeColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, gradientStrokeWidth: Optional[float | Parameter | SchemaBase | Map] = Undefined, gradientThickness: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -1502,7 +1391,7 @@ def legend( Parameter | SchemaBase | Map | TextBaseline_T ] = Undefined, labelColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, labelExpr: Optional[str] = Undefined, labelFont: Optional[str | Parameter | SchemaBase | Map] = Undefined, @@ -1526,21 +1415,21 @@ def legend( padding: Optional[float | Parameter | SchemaBase | Map] = Undefined, rowPadding: Optional[float | Parameter | SchemaBase | Map] = Undefined, strokeColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, symbolDash: Optional[ Parameter | SchemaBase | Sequence[float] | Map ] = Undefined, symbolDashOffset: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolFillColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, symbolLimit: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolOffset: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolOpacity: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolSize: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolStrokeColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, symbolStrokeWidth: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolType: Optional[str | Parameter | SchemaBase | Map] = Undefined, @@ -1548,14 +1437,14 @@ def legend( float | Parameter | SchemaBase | Map | TimeInterval_T ] = Undefined, tickMinStep: Optional[float | Parameter | SchemaBase | Map] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, titleAlign: Optional[Parameter | SchemaBase | Map | Align_T] = Undefined, titleAnchor: Optional[Parameter | SchemaBase | Map | TitleAnchor_T] = Undefined, titleBaseline: Optional[ Parameter | SchemaBase | Map | TextBaseline_T ] = Undefined, titleColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, titleFont: Optional[str | Parameter | SchemaBase | Map] = Undefined, titleFontSize: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -1575,19 +1464,17 @@ def legend( | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map ] = Undefined, zindex: Optional[float] = Undefined, - **kwds, ) -> Color: ... - @overload - def legend(self, _: None, **kwds) -> Color: ... - + def scale(self, _: Scale | None, /) -> Color: ... @overload def scale( self, + *, align: Optional[float | Parameter | SchemaBase | Map] = Undefined, base: Optional[float | Parameter | SchemaBase | Map] = Undefined, bins: Optional[SchemaBase | Sequence[float] | Map] = Undefined, @@ -1597,12 +1484,18 @@ def scale( Parameter | SchemaBase | Literal["unaggregated"] - | Sequence[str | bool | None | float | Parameter | SchemaBase | Map] + | Sequence[ + str | bool | float | Temporal | Parameter | SchemaBase | Map | None + ] | Map ] = Undefined, - domainMax: Optional[float | Parameter | SchemaBase | Map] = Undefined, + domainMax: Optional[ + float | Temporal | Parameter | SchemaBase | Map + ] = Undefined, domainMid: Optional[float | Parameter | SchemaBase | Map] = Undefined, - domainMin: Optional[float | Parameter | SchemaBase | Map] = Undefined, + domainMin: Optional[ + float | Temporal | Parameter | SchemaBase | Map + ] = Undefined, domainRaw: Optional[Parameter | SchemaBase | Map] = Undefined, exponent: Optional[float | Parameter | SchemaBase | Map] = Undefined, interpolate: Optional[ @@ -1627,156 +1520,78 @@ def scale( scheme: Optional[Parameter | SchemaBase | Map | ColorScheme_T] = Undefined, type: Optional[SchemaBase | ScaleType_T] = Undefined, zero: Optional[bool | Parameter | SchemaBase | Map] = Undefined, - **kwds, ) -> Color: ... - - @overload - def scale(self, _: None, **kwds) -> Color: ... - - @overload - def sort(self, _: list[float], **kwds) -> Color: ... - - @overload - def sort(self, _: list[str], **kwds) -> Color: ... - - @overload - def sort(self, _: list[bool], **kwds) -> Color: ... - - @overload - def sort(self, _: list[core.DateTime], **kwds) -> Color: ... - - @overload - def sort(self, _: SortOrder_T, **kwds) -> Color: ... - - @overload - def sort(self, _: SortByChannel_T, **kwds) -> Color: ... - @overload - def sort(self, _: SortByChannelDesc_T, **kwds) -> Color: ... - + def sort( + self, + _: Sequence[str] + | Sequence[bool] + | Sequence[float] + | Sequence[DateTime | Temporal] + | AllSortString_T + | None, + /, + ) -> Color: ... @overload def sort( self, + *, field: Optional[str | SchemaBase | Map] = Undefined, op: Optional[SchemaBase | NonArgAggregateOp_T] = Undefined, - order: Optional[None | SchemaBase | SortOrder_T] = Undefined, - **kwds, + order: Optional[SchemaBase | SortOrder_T | None] = Undefined, ) -> Color: ... - @overload def sort( self, + *, encoding: Optional[SchemaBase | SortByChannel_T] = Undefined, - order: Optional[None | SchemaBase | SortOrder_T] = Undefined, - **kwds, + order: Optional[SchemaBase | SortOrder_T | None] = Undefined, ) -> Color: ... - - @overload - def sort(self, _: None, **kwds) -> Color: ... - - @overload - def timeUnit(self, _: LocalSingleTimeUnit_T, **kwds) -> Color: ... - - @overload - def timeUnit(self, _: UtcSingleTimeUnit_T, **kwds) -> Color: ... - - @overload - def timeUnit(self, _: LocalMultiTimeUnit_T, **kwds) -> Color: ... - - @overload - def timeUnit(self, _: UtcMultiTimeUnit_T, **kwds) -> Color: ... - - @overload - def timeUnit( - self, - _: Literal[ - "binnedyear", - "binnedyearquarter", - "binnedyearquartermonth", - "binnedyearmonth", - "binnedyearmonthdate", - "binnedyearmonthdatehours", - "binnedyearmonthdatehoursminutes", - "binnedyearmonthdatehoursminutesseconds", - "binnedyearweek", - "binnedyearweekday", - "binnedyearweekdayhours", - "binnedyearweekdayhoursminutes", - "binnedyearweekdayhoursminutesseconds", - "binnedyeardayofyear", - ], - **kwds, - ) -> Color: ... - @overload def timeUnit( self, - _: Literal[ - "binnedutcyear", - "binnedutcyearquarter", - "binnedutcyearquartermonth", - "binnedutcyearmonth", - "binnedutcyearmonthdate", - "binnedutcyearmonthdatehours", - "binnedutcyearmonthdatehoursminutes", - "binnedutcyearmonthdatehoursminutesseconds", - "binnedutcyearweek", - "binnedutcyearweekday", - "binnedutcyearweekdayhours", - "binnedutcyearweekdayhoursminutes", - "binnedutcyearweekdayhoursminutesseconds", - "binnedutcyeardayofyear", - ], - **kwds, + _: TimeUnitParams | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T, + /, ) -> Color: ... - @overload def timeUnit( self, + *, binned: Optional[bool] = Undefined, maxbins: Optional[float] = Undefined, step: Optional[float] = Undefined, unit: Optional[SchemaBase | MultiTimeUnit_T | SingleTimeUnit_T] = Undefined, utc: Optional[bool] = Undefined, - **kwds, ) -> Color: ... - - @overload - def title(self, _: str, **kwds) -> Color: ... - - @overload - def title(self, _: list[str], **kwds) -> Color: ... - @overload - def title(self, _: None, **kwds) -> Color: ... - + def title(self, _: str | Sequence[str] | None, /) -> Color: ... @overload - def type(self, _: StandardType_T, **kwds) -> Color: ... + def type(self, _: StandardType_T, /) -> Color: ... def __init__( self, shorthand: Optional[str | SchemaBase | Sequence[str] | Map] = Undefined, aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Map] = Undefined, + bin: Optional[bool | SchemaBase | Map | None] = Undefined, condition: Optional[SchemaBase | Sequence[SchemaBase | Map] | Map] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, sort: Optional[ - None - | SchemaBase + SchemaBase | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map | AllSortString_T + | None ] = Undefined, timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, **kwds, ): @@ -1817,9 +1632,9 @@ class ColorDatum( **Note:** A field definition's ``condition`` property can only contain `conditional value definitions `__ since Vega-Lite only allows at most one encoded field per encoding channel. - datum : str, bool, dict, None, float, :class:`ExprRef`, :class:`DateTime`, :class:`RepeatRef`, :class:`PrimitiveValue` + datum : str, bool, dict, float, :class:`ExprRef`, :class:`DateTime`, :class:`RepeatRef`, :class:`PrimitiveValue`, None A constant value in data domain. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -1911,48 +1726,37 @@ class ColorDatum( _encoding_name = "color" @overload - def bandPosition(self, _: float, **kwds) -> ColorDatum: ... - + def bandPosition(self, _: float, /) -> ColorDatum: ... @overload def condition( self, + *, test: Optional[str | SchemaBase | Map] = Undefined, - value: Optional[str | None | Parameter | SchemaBase | Map] = Undefined, - **kwds, + value: Optional[str | Parameter | SchemaBase | Map | None] = Undefined, ) -> ColorDatum: ... - @overload def condition( self, + *, empty: Optional[bool] = Undefined, param: Optional[str | SchemaBase] = Undefined, - value: Optional[str | None | Parameter | SchemaBase | Map] = Undefined, - **kwds, + value: Optional[str | Parameter | SchemaBase | Map | None] = Undefined, ) -> ColorDatum: ... - @overload def condition( - self, _: list[core.ConditionalValueDefGradientstringnullExprRef], **kwds + self, _: list[core.ConditionalValueDefGradientstringnullExprRef], / ) -> ColorDatum: ... - - @overload - def title(self, _: str, **kwds) -> ColorDatum: ... - @overload - def title(self, _: list[str], **kwds) -> ColorDatum: ... - - @overload - def title(self, _: None, **kwds) -> ColorDatum: ... - + def title(self, _: str | Sequence[str] | None, /) -> ColorDatum: ... @overload - def type(self, _: Type_T, **kwds) -> ColorDatum: ... + def type(self, _: Type_T, /) -> ColorDatum: ... def __init__( self, datum, bandPosition: Optional[float] = Undefined, condition: Optional[SchemaBase | Sequence[SchemaBase | Map] | Map] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | Type_T] = Undefined, **kwds, ): @@ -1978,7 +1782,7 @@ class ColorValue( ---------- condition : dict, :class:`ConditionalMarkPropFieldOrDatumDef`, :class:`ConditionalParameterMarkPropFieldOrDatumDef`, :class:`ConditionalPredicateMarkPropFieldOrDatumDef`, :class:`ConditionalValueDefGradientstringnullExprRef`, :class:`ConditionalParameterValueDefGradientstringnullExprRef`, :class:`ConditionalPredicateValueDefGradientstringnullExprRef`, Sequence[dict, :class:`ConditionalValueDefGradientstringnullExprRef`, :class:`ConditionalParameterValueDefGradientstringnullExprRef`, :class:`ConditionalPredicateValueDefGradientstringnullExprRef`] A field definition or one or more value definition(s) with a parameter predicate. - value : str, dict, None, :class:`ExprRef`, :class:`Gradient`, :class:`LinearGradient`, :class:`RadialGradient` + value : str, dict, :class:`ExprRef`, :class:`Gradient`, :class:`LinearGradient`, :class:`RadialGradient`, None A constant value in visual domain (e.g., ``"red"`` / ``"#0099ff"`` / `gradient definition `__ for color, values between ``0`` to ``1`` for opacity). @@ -1990,111 +1794,105 @@ class ColorValue( @overload def condition( self, + *, aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Map] = Undefined, + bin: Optional[bool | SchemaBase | Map | None] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, sort: Optional[ - None - | SchemaBase + SchemaBase | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map | AllSortString_T + | None ] = Undefined, test: Optional[str | SchemaBase | Map] = Undefined, timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, - **kwds, ) -> ColorValue: ... - @overload def condition( self, + *, bandPosition: Optional[float] = Undefined, datum: Optional[ - str | bool | None | float | Parameter | SchemaBase | Map + Temporal | Parameter | SchemaBase | Map | PrimitiveValue_T ] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, test: Optional[str | SchemaBase | Map] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | Type_T] = Undefined, - **kwds, ) -> ColorValue: ... - @overload def condition( self, + *, aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Map] = Undefined, + bin: Optional[bool | SchemaBase | Map | None] = Undefined, empty: Optional[bool] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, param: Optional[str | SchemaBase] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, sort: Optional[ - None - | SchemaBase + SchemaBase | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map | AllSortString_T + | None ] = Undefined, timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, - **kwds, ) -> ColorValue: ... - @overload def condition( self, + *, bandPosition: Optional[float] = Undefined, datum: Optional[ - str | bool | None | float | Parameter | SchemaBase | Map + Temporal | Parameter | SchemaBase | Map | PrimitiveValue_T ] = Undefined, empty: Optional[bool] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, param: Optional[str | SchemaBase] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | Type_T] = Undefined, - **kwds, ) -> ColorValue: ... - @overload def condition( self, + *, test: Optional[str | SchemaBase | Map] = Undefined, - value: Optional[str | None | Parameter | SchemaBase | Map] = Undefined, - **kwds, + value: Optional[str | Parameter | SchemaBase | Map | None] = Undefined, ) -> ColorValue: ... - @overload def condition( self, + *, empty: Optional[bool] = Undefined, param: Optional[str | SchemaBase] = Undefined, - value: Optional[str | None | Parameter | SchemaBase | Map] = Undefined, - **kwds, + value: Optional[str | Parameter | SchemaBase | Map | None] = Undefined, ) -> ColorValue: ... - @overload def condition( - self, _: list[core.ConditionalValueDefGradientstringnullExprRef], **kwds + self, _: list[core.ConditionalValueDefGradientstringnullExprRef], / ) -> ColorValue: ... def __init__( @@ -2140,7 +1938,7 @@ class Column(FieldChannelMixin, core.RowColumnEncodingFieldDef): Relative position on a band of a stacked, binned, time unit, or band scale. For example, the marks will be positioned at the beginning of the band if set to ``0``, and at the middle of the band if set to ``0.5``. - bin : bool, dict, None, :class:`BinParams` + bin : bool, dict, :class:`BinParams`, None A flag for binning a ``quantitative`` field, `an object defining binning parameters `__, or indicating that the data for ``x`` or ``y`` channel are binned before they are imported into @@ -2181,9 +1979,9 @@ class Column(FieldChannelMixin, core.RowColumnEncodingFieldDef): about escaping in the `field documentation `__. 2) ``field`` is not required if ``aggregate`` is ``count``. - header : dict, None, :class:`Header` + header : dict, :class:`Header`, None An object defining properties of a facet's header. - sort : dict, None, Sequence[str], Sequence[bool], Sequence[float], :class:`SortArray`, :class:`SortOrder`, :class:`EncodingSortField`, Sequence[dict, :class:`DateTime`], Literal['ascending', 'descending'] + sort : dict, Sequence[str], Sequence[bool], Sequence[float], :class:`SortArray`, :class:`SortOrder`, :class:`EncodingSortField`, Sequence[dict, :class:`DateTime`], Literal['ascending', 'descending'], None Sort order for the encoded field. For continuous fields (quantitative or temporal), ``sort`` can be either @@ -2224,7 +2022,7 @@ class Column(FieldChannelMixin, core.RowColumnEncodingFieldDef): **See also:** `timeUnit `__ documentation. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -2316,30 +2114,25 @@ class Column(FieldChannelMixin, core.RowColumnEncodingFieldDef): _encoding_name = "column" @overload - def aggregate(self, _: NonArgAggregateOp_T, **kwds) -> Column: ... - + def aggregate(self, _: NonArgAggregateOp_T, /) -> Column: ... @overload def aggregate( - self, argmax: Optional[str | SchemaBase] = Undefined, **kwds + self, *, argmax: Optional[str | SchemaBase] = Undefined ) -> Column: ... - @overload def aggregate( - self, argmin: Optional[str | SchemaBase] = Undefined, **kwds + self, *, argmin: Optional[str | SchemaBase] = Undefined ) -> Column: ... - @overload - def align(self, _: LayoutAlign_T, **kwds) -> Column: ... - + def align(self, _: LayoutAlign_T, /) -> Column: ... @overload - def bandPosition(self, _: float, **kwds) -> Column: ... - + def bandPosition(self, _: float, /) -> Column: ... @overload - def bin(self, _: bool, **kwds) -> Column: ... - + def bin(self, _: bool | Bin | None, /) -> Column: ... @overload def bin( self, + *, anchor: Optional[float] = Undefined, base: Optional[float] = Undefined, binned: Optional[bool] = Undefined, @@ -2350,28 +2143,23 @@ def bin( nice: Optional[bool] = Undefined, step: Optional[float] = Undefined, steps: Optional[Sequence[float]] = Undefined, - **kwds, ) -> Column: ... - - @overload - def bin(self, _: None, **kwds) -> Column: ... - @overload - def center(self, _: bool, **kwds) -> Column: ... - + def center(self, _: bool, /) -> Column: ... @overload - def field(self, _: str, **kwds) -> Column: ... - + def field(self, _: str | RepeatRef, /) -> Column: ... @overload def field( self, + *, repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined, - **kwds, ) -> Column: ... - + @overload + def header(self, _: Header | None, /) -> Column: ... @overload def header( self, + *, format: Optional[str | SchemaBase | Map] = Undefined, formatType: Optional[str] = Undefined, labelAlign: Optional[Parameter | SchemaBase | Map | Align_T] = Undefined, @@ -2396,7 +2184,7 @@ def header( labelPadding: Optional[float | Parameter | SchemaBase | Map] = Undefined, labels: Optional[bool] = Undefined, orient: Optional[SchemaBase | Orient_T] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, titleAlign: Optional[Parameter | SchemaBase | Map | Align_T] = Undefined, titleAnchor: Optional[SchemaBase | TitleAnchor_T] = Undefined, titleAngle: Optional[float] = Undefined, @@ -2416,120 +2204,49 @@ def header( titleLineHeight: Optional[float | Parameter | SchemaBase | Map] = Undefined, titleOrient: Optional[SchemaBase | Orient_T] = Undefined, titlePadding: Optional[float | Parameter | SchemaBase | Map] = Undefined, - **kwds, ) -> Column: ... - - @overload - def header(self, _: None, **kwds) -> Column: ... - - @overload - def sort(self, _: list[float], **kwds) -> Column: ... - - @overload - def sort(self, _: list[str], **kwds) -> Column: ... - - @overload - def sort(self, _: list[bool], **kwds) -> Column: ... - @overload - def sort(self, _: list[core.DateTime], **kwds) -> Column: ... - - @overload - def sort(self, _: SortOrder_T, **kwds) -> Column: ... - + def sort( + self, + _: Sequence[str] + | Sequence[bool] + | Sequence[float] + | EncodingSortField + | Sequence[DateTime | Temporal] + | SortOrder_T + | None, + /, + ) -> Column: ... @overload def sort( self, + *, field: Optional[str | SchemaBase | Map] = Undefined, op: Optional[SchemaBase | NonArgAggregateOp_T] = Undefined, - order: Optional[None | SchemaBase | SortOrder_T] = Undefined, - **kwds, + order: Optional[SchemaBase | SortOrder_T | None] = Undefined, ) -> Column: ... - @overload - def sort(self, _: None, **kwds) -> Column: ... - - @overload - def spacing(self, _: float, **kwds) -> Column: ... - + def spacing(self, _: float, /) -> Column: ... @overload - def timeUnit(self, _: LocalSingleTimeUnit_T, **kwds) -> Column: ... - - @overload - def timeUnit(self, _: UtcSingleTimeUnit_T, **kwds) -> Column: ... - - @overload - def timeUnit(self, _: LocalMultiTimeUnit_T, **kwds) -> Column: ... - - @overload - def timeUnit(self, _: UtcMultiTimeUnit_T, **kwds) -> Column: ... - - @overload - def timeUnit( - self, - _: Literal[ - "binnedyear", - "binnedyearquarter", - "binnedyearquartermonth", - "binnedyearmonth", - "binnedyearmonthdate", - "binnedyearmonthdatehours", - "binnedyearmonthdatehoursminutes", - "binnedyearmonthdatehoursminutesseconds", - "binnedyearweek", - "binnedyearweekday", - "binnedyearweekdayhours", - "binnedyearweekdayhoursminutes", - "binnedyearweekdayhoursminutesseconds", - "binnedyeardayofyear", - ], - **kwds, - ) -> Column: ... - - @overload - def timeUnit( - self, - _: Literal[ - "binnedutcyear", - "binnedutcyearquarter", - "binnedutcyearquartermonth", - "binnedutcyearmonth", - "binnedutcyearmonthdate", - "binnedutcyearmonthdatehours", - "binnedutcyearmonthdatehoursminutes", - "binnedutcyearmonthdatehoursminutesseconds", - "binnedutcyearweek", - "binnedutcyearweekday", - "binnedutcyearweekdayhours", - "binnedutcyearweekdayhoursminutes", - "binnedutcyearweekdayhoursminutesseconds", - "binnedutcyeardayofyear", - ], - **kwds, - ) -> Column: ... - + def timeUnit( + self, + _: TimeUnitParams | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T, + /, + ) -> Column: ... @overload def timeUnit( self, + *, binned: Optional[bool] = Undefined, maxbins: Optional[float] = Undefined, step: Optional[float] = Undefined, unit: Optional[SchemaBase | MultiTimeUnit_T | SingleTimeUnit_T] = Undefined, utc: Optional[bool] = Undefined, - **kwds, ) -> Column: ... - @overload - def title(self, _: str, **kwds) -> Column: ... - + def title(self, _: str | Sequence[str] | None, /) -> Column: ... @overload - def title(self, _: list[str], **kwds) -> Column: ... - - @overload - def title(self, _: None, **kwds) -> Column: ... - - @overload - def type(self, _: StandardType_T, **kwds) -> Column: ... + def type(self, _: StandardType_T, /) -> Column: ... def __init__( self, @@ -2537,25 +2254,25 @@ def __init__( aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, align: Optional[SchemaBase | LayoutAlign_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Map] = Undefined, + bin: Optional[bool | SchemaBase | Map | None] = Undefined, center: Optional[bool] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, - header: Optional[None | SchemaBase | Map] = Undefined, + header: Optional[SchemaBase | Map | None] = Undefined, sort: Optional[ - None - | SchemaBase + SchemaBase | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map | SortOrder_T + | None ] = Undefined, spacing: Optional[float] = Undefined, timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, **kwds, ): @@ -2598,7 +2315,7 @@ class Description(FieldChannelMixin, core.StringFieldDefWithCondition): Relative position on a band of a stacked, binned, time unit, or band scale. For example, the marks will be positioned at the beginning of the band if set to ``0``, and at the middle of the band if set to ``0.5``. - bin : bool, dict, None, Literal['binned'], :class:`BinParams` + bin : bool, dict, Literal['binned'], :class:`BinParams`, None A flag for binning a ``quantitative`` field, `an object defining binning parameters `__, or indicating that the data for ``x`` or ``y`` channel are binned before they are imported into @@ -2682,7 +2399,7 @@ class Description(FieldChannelMixin, core.StringFieldDefWithCondition): **See also:** `timeUnit `__ documentation. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -2774,27 +2491,23 @@ class Description(FieldChannelMixin, core.StringFieldDefWithCondition): _encoding_name = "description" @overload - def aggregate(self, _: NonArgAggregateOp_T, **kwds) -> Description: ... - + def aggregate(self, _: NonArgAggregateOp_T, /) -> Description: ... @overload def aggregate( - self, argmax: Optional[str | SchemaBase] = Undefined, **kwds + self, *, argmax: Optional[str | SchemaBase] = Undefined ) -> Description: ... - @overload def aggregate( - self, argmin: Optional[str | SchemaBase] = Undefined, **kwds + self, *, argmin: Optional[str | SchemaBase] = Undefined ) -> Description: ... - @overload - def bandPosition(self, _: float, **kwds) -> Description: ... - + def bandPosition(self, _: float, /) -> Description: ... @overload - def bin(self, _: bool, **kwds) -> Description: ... - + def bin(self, _: bool | Bin | Literal["binned"] | None, /) -> Description: ... @overload def bin( self, + *, anchor: Optional[float] = Undefined, base: Optional[float] = Undefined, binned: Optional[bool] = Undefined, @@ -2805,141 +2518,67 @@ def bin( nice: Optional[bool] = Undefined, step: Optional[float] = Undefined, steps: Optional[Sequence[float]] = Undefined, - **kwds, ) -> Description: ... - - @overload - def bin(self, _: Literal["binned"], **kwds) -> Description: ... - - @overload - def bin(self, _: None, **kwds) -> Description: ... - @overload def condition( self, + *, test: Optional[str | SchemaBase | Map] = Undefined, value: Optional[str | Parameter | SchemaBase | Map] = Undefined, - **kwds, ) -> Description: ... - @overload def condition( self, + *, empty: Optional[bool] = Undefined, param: Optional[str | SchemaBase] = Undefined, value: Optional[str | Parameter | SchemaBase | Map] = Undefined, - **kwds, ) -> Description: ... - @overload def condition( - self, _: list[core.ConditionalValueDefstringExprRef], **kwds + self, _: list[core.ConditionalValueDefstringExprRef], / ) -> Description: ... - @overload - def field(self, _: str, **kwds) -> Description: ... - + def field(self, _: str | RepeatRef, /) -> Description: ... @overload def field( self, + *, repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined, - **kwds, ) -> Description: ... - - @overload - def format(self, _: str, **kwds) -> Description: ... - - @overload - def format(self, _: Map, **kwds) -> Description: ... - - @overload - def formatType(self, _: str, **kwds) -> Description: ... - - @overload - def timeUnit(self, _: LocalSingleTimeUnit_T, **kwds) -> Description: ... - @overload - def timeUnit(self, _: UtcSingleTimeUnit_T, **kwds) -> Description: ... - + def format(self, _: str, /) -> Description: ... @overload - def timeUnit(self, _: LocalMultiTimeUnit_T, **kwds) -> Description: ... - + def format(self, _: Map, /) -> Description: ... @overload - def timeUnit(self, _: UtcMultiTimeUnit_T, **kwds) -> Description: ... - + def formatType(self, _: str, /) -> Description: ... @overload def timeUnit( self, - _: Literal[ - "binnedyear", - "binnedyearquarter", - "binnedyearquartermonth", - "binnedyearmonth", - "binnedyearmonthdate", - "binnedyearmonthdatehours", - "binnedyearmonthdatehoursminutes", - "binnedyearmonthdatehoursminutesseconds", - "binnedyearweek", - "binnedyearweekday", - "binnedyearweekdayhours", - "binnedyearweekdayhoursminutes", - "binnedyearweekdayhoursminutesseconds", - "binnedyeardayofyear", - ], - **kwds, + _: TimeUnitParams | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T, + /, ) -> Description: ... - - @overload - def timeUnit( - self, - _: Literal[ - "binnedutcyear", - "binnedutcyearquarter", - "binnedutcyearquartermonth", - "binnedutcyearmonth", - "binnedutcyearmonthdate", - "binnedutcyearmonthdatehours", - "binnedutcyearmonthdatehoursminutes", - "binnedutcyearmonthdatehoursminutesseconds", - "binnedutcyearweek", - "binnedutcyearweekday", - "binnedutcyearweekdayhours", - "binnedutcyearweekdayhoursminutes", - "binnedutcyearweekdayhoursminutesseconds", - "binnedutcyeardayofyear", - ], - **kwds, - ) -> Description: ... - @overload def timeUnit( self, + *, binned: Optional[bool] = Undefined, maxbins: Optional[float] = Undefined, step: Optional[float] = Undefined, unit: Optional[SchemaBase | MultiTimeUnit_T | SingleTimeUnit_T] = Undefined, utc: Optional[bool] = Undefined, - **kwds, ) -> Description: ... - - @overload - def title(self, _: str, **kwds) -> Description: ... - - @overload - def title(self, _: list[str], **kwds) -> Description: ... - @overload - def title(self, _: None, **kwds) -> Description: ... - + def title(self, _: str | Sequence[str] | None, /) -> Description: ... @overload - def type(self, _: StandardType_T, **kwds) -> Description: ... + def type(self, _: StandardType_T, /) -> Description: ... def __init__( self, shorthand: Optional[str | SchemaBase | Sequence[str] | Map] = Undefined, aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Literal["binned"] | Map] = Undefined, + bin: Optional[bool | SchemaBase | Literal["binned"] | Map | None] = Undefined, condition: Optional[SchemaBase | Sequence[SchemaBase | Map] | Map] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, format: Optional[str | SchemaBase | Map] = Undefined, @@ -2947,7 +2586,7 @@ def __init__( timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, **kwds, ): @@ -2976,7 +2615,7 @@ class DescriptionValue(ValueChannelMixin, core.StringValueDefWithCondition): ---------- condition : dict, :class:`ConditionalMarkPropFieldOrDatumDef`, :class:`ConditionalValueDefstringnullExprRef`, :class:`ConditionalParameterMarkPropFieldOrDatumDef`, :class:`ConditionalPredicateMarkPropFieldOrDatumDef`, :class:`ConditionalParameterValueDefstringnullExprRef`, :class:`ConditionalPredicateValueDefstringnullExprRef`, Sequence[dict, :class:`ConditionalValueDefstringnullExprRef`, :class:`ConditionalParameterValueDefstringnullExprRef`, :class:`ConditionalPredicateValueDefstringnullExprRef`] A field definition or one or more value definition(s) with a parameter predicate. - value : str, dict, None, :class:`ExprRef` + value : str, dict, :class:`ExprRef`, None A constant value in visual domain (e.g., ``"red"`` / ``"#0099ff"`` / `gradient definition `__ for color, values between ``0`` to ``1`` for opacity). @@ -2988,111 +2627,105 @@ class DescriptionValue(ValueChannelMixin, core.StringValueDefWithCondition): @overload def condition( self, + *, aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Map] = Undefined, + bin: Optional[bool | SchemaBase | Map | None] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, sort: Optional[ - None - | SchemaBase + SchemaBase | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map | AllSortString_T + | None ] = Undefined, test: Optional[str | SchemaBase | Map] = Undefined, timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, - **kwds, ) -> DescriptionValue: ... - @overload def condition( self, + *, bandPosition: Optional[float] = Undefined, datum: Optional[ - str | bool | None | float | Parameter | SchemaBase | Map + Temporal | Parameter | SchemaBase | Map | PrimitiveValue_T ] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, test: Optional[str | SchemaBase | Map] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | Type_T] = Undefined, - **kwds, ) -> DescriptionValue: ... - @overload def condition( self, + *, aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Map] = Undefined, + bin: Optional[bool | SchemaBase | Map | None] = Undefined, empty: Optional[bool] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, param: Optional[str | SchemaBase] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, sort: Optional[ - None - | SchemaBase + SchemaBase | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map | AllSortString_T + | None ] = Undefined, timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, - **kwds, ) -> DescriptionValue: ... - @overload def condition( self, + *, bandPosition: Optional[float] = Undefined, datum: Optional[ - str | bool | None | float | Parameter | SchemaBase | Map + Temporal | Parameter | SchemaBase | Map | PrimitiveValue_T ] = Undefined, empty: Optional[bool] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, param: Optional[str | SchemaBase] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | Type_T] = Undefined, - **kwds, ) -> DescriptionValue: ... - @overload def condition( self, + *, test: Optional[str | SchemaBase | Map] = Undefined, - value: Optional[str | None | Parameter | SchemaBase | Map] = Undefined, - **kwds, + value: Optional[str | Parameter | SchemaBase | Map | None] = Undefined, ) -> DescriptionValue: ... - @overload def condition( self, + *, empty: Optional[bool] = Undefined, param: Optional[str | SchemaBase] = Undefined, - value: Optional[str | None | Parameter | SchemaBase | Map] = Undefined, - **kwds, + value: Optional[str | Parameter | SchemaBase | Map | None] = Undefined, ) -> DescriptionValue: ... - @overload def condition( - self, _: list[core.ConditionalValueDefstringnullExprRef], **kwds + self, _: list[core.ConditionalValueDefstringnullExprRef], / ) -> DescriptionValue: ... def __init__( @@ -3127,7 +2760,7 @@ class Detail(FieldChannelMixin, core.FieldDefWithoutScale): Relative position on a band of a stacked, binned, time unit, or band scale. For example, the marks will be positioned at the beginning of the band if set to ``0``, and at the middle of the band if set to ``0.5``. - bin : bool, dict, None, Literal['binned'], :class:`BinParams` + bin : bool, dict, Literal['binned'], :class:`BinParams`, None A flag for binning a ``quantitative`` field, `an object defining binning parameters `__, or indicating that the data for ``x`` or ``y`` channel are binned before they are imported into @@ -3172,7 +2805,7 @@ class Detail(FieldChannelMixin, core.FieldDefWithoutScale): **See also:** `timeUnit `__ documentation. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -3264,27 +2897,23 @@ class Detail(FieldChannelMixin, core.FieldDefWithoutScale): _encoding_name = "detail" @overload - def aggregate(self, _: NonArgAggregateOp_T, **kwds) -> Detail: ... - + def aggregate(self, _: NonArgAggregateOp_T, /) -> Detail: ... @overload def aggregate( - self, argmax: Optional[str | SchemaBase] = Undefined, **kwds + self, *, argmax: Optional[str | SchemaBase] = Undefined ) -> Detail: ... - @overload def aggregate( - self, argmin: Optional[str | SchemaBase] = Undefined, **kwds + self, *, argmin: Optional[str | SchemaBase] = Undefined ) -> Detail: ... - @overload - def bandPosition(self, _: float, **kwds) -> Detail: ... - + def bandPosition(self, _: float, /) -> Detail: ... @overload - def bin(self, _: bool, **kwds) -> Detail: ... - + def bin(self, _: bool | Bin | Literal["binned"] | None, /) -> Detail: ... @overload def bin( self, + *, anchor: Optional[float] = Undefined, base: Optional[float] = Undefined, binned: Optional[bool] = Undefined, @@ -3295,115 +2924,47 @@ def bin( nice: Optional[bool] = Undefined, step: Optional[float] = Undefined, steps: Optional[Sequence[float]] = Undefined, - **kwds, ) -> Detail: ... - @overload - def bin(self, _: Literal["binned"], **kwds) -> Detail: ... - - @overload - def bin(self, _: None, **kwds) -> Detail: ... - - @overload - def field(self, _: str, **kwds) -> Detail: ... - + def field(self, _: str | RepeatRef, /) -> Detail: ... @overload def field( self, + *, repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined, - **kwds, ) -> Detail: ... - - @overload - def timeUnit(self, _: LocalSingleTimeUnit_T, **kwds) -> Detail: ... - - @overload - def timeUnit(self, _: UtcSingleTimeUnit_T, **kwds) -> Detail: ... - - @overload - def timeUnit(self, _: LocalMultiTimeUnit_T, **kwds) -> Detail: ... - - @overload - def timeUnit(self, _: UtcMultiTimeUnit_T, **kwds) -> Detail: ... - @overload def timeUnit( self, - _: Literal[ - "binnedyear", - "binnedyearquarter", - "binnedyearquartermonth", - "binnedyearmonth", - "binnedyearmonthdate", - "binnedyearmonthdatehours", - "binnedyearmonthdatehoursminutes", - "binnedyearmonthdatehoursminutesseconds", - "binnedyearweek", - "binnedyearweekday", - "binnedyearweekdayhours", - "binnedyearweekdayhoursminutes", - "binnedyearweekdayhoursminutesseconds", - "binnedyeardayofyear", - ], - **kwds, + _: TimeUnitParams | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T, + /, ) -> Detail: ... - - @overload - def timeUnit( - self, - _: Literal[ - "binnedutcyear", - "binnedutcyearquarter", - "binnedutcyearquartermonth", - "binnedutcyearmonth", - "binnedutcyearmonthdate", - "binnedutcyearmonthdatehours", - "binnedutcyearmonthdatehoursminutes", - "binnedutcyearmonthdatehoursminutesseconds", - "binnedutcyearweek", - "binnedutcyearweekday", - "binnedutcyearweekdayhours", - "binnedutcyearweekdayhoursminutes", - "binnedutcyearweekdayhoursminutesseconds", - "binnedutcyeardayofyear", - ], - **kwds, - ) -> Detail: ... - @overload def timeUnit( self, + *, binned: Optional[bool] = Undefined, maxbins: Optional[float] = Undefined, step: Optional[float] = Undefined, unit: Optional[SchemaBase | MultiTimeUnit_T | SingleTimeUnit_T] = Undefined, utc: Optional[bool] = Undefined, - **kwds, ) -> Detail: ... - - @overload - def title(self, _: str, **kwds) -> Detail: ... - @overload - def title(self, _: list[str], **kwds) -> Detail: ... - - @overload - def title(self, _: None, **kwds) -> Detail: ... - + def title(self, _: str | Sequence[str] | None, /) -> Detail: ... @overload - def type(self, _: StandardType_T, **kwds) -> Detail: ... + def type(self, _: StandardType_T, /) -> Detail: ... def __init__( self, shorthand: Optional[str | SchemaBase | Sequence[str] | Map] = Undefined, aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Literal["binned"] | Map] = Undefined, + bin: Optional[bool | SchemaBase | Literal["binned"] | Map | None] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, **kwds, ): @@ -3457,7 +3018,7 @@ class Facet(FieldChannelMixin, core.FacetEncodingFieldDef): Relative position on a band of a stacked, binned, time unit, or band scale. For example, the marks will be positioned at the beginning of the band if set to ``0``, and at the middle of the band if set to ``0.5``. - bin : bool, dict, None, :class:`BinParams` + bin : bool, dict, :class:`BinParams`, None A flag for binning a ``quantitative`` field, `an object defining binning parameters `__, or indicating that the data for ``x`` or ``y`` channel are binned before they are imported into @@ -3529,9 +3090,9 @@ class Facet(FieldChannelMixin, core.FacetEncodingFieldDef): about escaping in the `field documentation `__. 2) ``field`` is not required if ``aggregate`` is ``count``. - header : dict, None, :class:`Header` + header : dict, :class:`Header`, None An object defining properties of a facet's header. - sort : dict, None, Sequence[str], Sequence[bool], Sequence[float], :class:`SortArray`, :class:`SortOrder`, :class:`EncodingSortField`, Sequence[dict, :class:`DateTime`], Literal['ascending', 'descending'] + sort : dict, Sequence[str], Sequence[bool], Sequence[float], :class:`SortArray`, :class:`SortOrder`, :class:`EncodingSortField`, Sequence[dict, :class:`DateTime`], Literal['ascending', 'descending'], None Sort order for the encoded field. For continuous fields (quantitative or temporal), ``sort`` can be either @@ -3574,7 +3135,7 @@ class Facet(FieldChannelMixin, core.FacetEncodingFieldDef): **See also:** `timeUnit `__ documentation. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -3666,38 +3227,28 @@ class Facet(FieldChannelMixin, core.FacetEncodingFieldDef): _encoding_name = "facet" @overload - def aggregate(self, _: NonArgAggregateOp_T, **kwds) -> Facet: ... - + def aggregate(self, _: NonArgAggregateOp_T, /) -> Facet: ... @overload - def aggregate( - self, argmax: Optional[str | SchemaBase] = Undefined, **kwds - ) -> Facet: ... - + def aggregate(self, *, argmax: Optional[str | SchemaBase] = Undefined) -> Facet: ... @overload - def aggregate( - self, argmin: Optional[str | SchemaBase] = Undefined, **kwds - ) -> Facet: ... - + def aggregate(self, *, argmin: Optional[str | SchemaBase] = Undefined) -> Facet: ... @overload - def align(self, _: LayoutAlign_T, **kwds) -> Facet: ... - + def align(self, _: RowColKwds[LayoutAlign_T] | LayoutAlign_T, /) -> Facet: ... @overload def align( self, + *, column: Optional[SchemaBase | LayoutAlign_T] = Undefined, row: Optional[SchemaBase | LayoutAlign_T] = Undefined, - **kwds, ) -> Facet: ... - @overload - def bandPosition(self, _: float, **kwds) -> Facet: ... - + def bandPosition(self, _: float, /) -> Facet: ... @overload - def bin(self, _: bool, **kwds) -> Facet: ... - + def bin(self, _: bool | Bin | None, /) -> Facet: ... @overload def bin( self, + *, anchor: Optional[float] = Undefined, base: Optional[float] = Undefined, binned: Optional[bool] = Undefined, @@ -3708,42 +3259,31 @@ def bin( nice: Optional[bool] = Undefined, step: Optional[float] = Undefined, steps: Optional[Sequence[float]] = Undefined, - **kwds, ) -> Facet: ... - @overload - def bin(self, _: None, **kwds) -> Facet: ... - + def bounds(self, _: Literal["full", "flush"], /) -> Facet: ... @overload - def bounds(self, _: Literal["full", "flush"], **kwds) -> Facet: ... - - @overload - def center(self, _: bool, **kwds) -> Facet: ... - + def center(self, _: bool | RowColKwds[bool], /) -> Facet: ... @overload def center( - self, - column: Optional[bool] = Undefined, - row: Optional[bool] = Undefined, - **kwds, + self, *, column: Optional[bool] = Undefined, row: Optional[bool] = Undefined ) -> Facet: ... - @overload - def columns(self, _: float, **kwds) -> Facet: ... - + def columns(self, _: float, /) -> Facet: ... @overload - def field(self, _: str, **kwds) -> Facet: ... - + def field(self, _: str | RepeatRef, /) -> Facet: ... @overload def field( self, + *, repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined, - **kwds, ) -> Facet: ... - + @overload + def header(self, _: Header | None, /) -> Facet: ... @overload def header( self, + *, format: Optional[str | SchemaBase | Map] = Undefined, formatType: Optional[str] = Undefined, labelAlign: Optional[Parameter | SchemaBase | Map | Align_T] = Undefined, @@ -3768,7 +3308,7 @@ def header( labelPadding: Optional[float | Parameter | SchemaBase | Map] = Undefined, labels: Optional[bool] = Undefined, orient: Optional[SchemaBase | Orient_T] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, titleAlign: Optional[Parameter | SchemaBase | Map | Align_T] = Undefined, titleAnchor: Optional[SchemaBase | TitleAnchor_T] = Undefined, titleAngle: Optional[float] = Undefined, @@ -3788,128 +3328,53 @@ def header( titleLineHeight: Optional[float | Parameter | SchemaBase | Map] = Undefined, titleOrient: Optional[SchemaBase | Orient_T] = Undefined, titlePadding: Optional[float | Parameter | SchemaBase | Map] = Undefined, - **kwds, ) -> Facet: ... - - @overload - def header(self, _: None, **kwds) -> Facet: ... - - @overload - def sort(self, _: list[float], **kwds) -> Facet: ... - @overload - def sort(self, _: list[str], **kwds) -> Facet: ... - - @overload - def sort(self, _: list[bool], **kwds) -> Facet: ... - - @overload - def sort(self, _: list[core.DateTime], **kwds) -> Facet: ... - - @overload - def sort(self, _: SortOrder_T, **kwds) -> Facet: ... - + def sort( + self, + _: Sequence[str] + | Sequence[bool] + | Sequence[float] + | EncodingSortField + | Sequence[DateTime | Temporal] + | SortOrder_T + | None, + /, + ) -> Facet: ... @overload def sort( self, + *, field: Optional[str | SchemaBase | Map] = Undefined, op: Optional[SchemaBase | NonArgAggregateOp_T] = Undefined, - order: Optional[None | SchemaBase | SortOrder_T] = Undefined, - **kwds, + order: Optional[SchemaBase | SortOrder_T | None] = Undefined, ) -> Facet: ... - - @overload - def sort(self, _: None, **kwds) -> Facet: ... - @overload - def spacing(self, _: float, **kwds) -> Facet: ... - + def spacing(self, _: float | RowColKwds[float], /) -> Facet: ... @overload def spacing( - self, - column: Optional[float] = Undefined, - row: Optional[float] = Undefined, - **kwds, + self, *, column: Optional[float] = Undefined, row: Optional[float] = Undefined ) -> Facet: ... - - @overload - def timeUnit(self, _: LocalSingleTimeUnit_T, **kwds) -> Facet: ... - - @overload - def timeUnit(self, _: UtcSingleTimeUnit_T, **kwds) -> Facet: ... - - @overload - def timeUnit(self, _: LocalMultiTimeUnit_T, **kwds) -> Facet: ... - - @overload - def timeUnit(self, _: UtcMultiTimeUnit_T, **kwds) -> Facet: ... - @overload def timeUnit( self, - _: Literal[ - "binnedyear", - "binnedyearquarter", - "binnedyearquartermonth", - "binnedyearmonth", - "binnedyearmonthdate", - "binnedyearmonthdatehours", - "binnedyearmonthdatehoursminutes", - "binnedyearmonthdatehoursminutesseconds", - "binnedyearweek", - "binnedyearweekday", - "binnedyearweekdayhours", - "binnedyearweekdayhoursminutes", - "binnedyearweekdayhoursminutesseconds", - "binnedyeardayofyear", - ], - **kwds, - ) -> Facet: ... - - @overload - def timeUnit( - self, - _: Literal[ - "binnedutcyear", - "binnedutcyearquarter", - "binnedutcyearquartermonth", - "binnedutcyearmonth", - "binnedutcyearmonthdate", - "binnedutcyearmonthdatehours", - "binnedutcyearmonthdatehoursminutes", - "binnedutcyearmonthdatehoursminutesseconds", - "binnedutcyearweek", - "binnedutcyearweekday", - "binnedutcyearweekdayhours", - "binnedutcyearweekdayhoursminutes", - "binnedutcyearweekdayhoursminutesseconds", - "binnedutcyeardayofyear", - ], - **kwds, + _: TimeUnitParams | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T, + /, ) -> Facet: ... - @overload def timeUnit( self, + *, binned: Optional[bool] = Undefined, maxbins: Optional[float] = Undefined, step: Optional[float] = Undefined, unit: Optional[SchemaBase | MultiTimeUnit_T | SingleTimeUnit_T] = Undefined, utc: Optional[bool] = Undefined, - **kwds, ) -> Facet: ... - @overload - def title(self, _: str, **kwds) -> Facet: ... - - @overload - def title(self, _: list[str], **kwds) -> Facet: ... - + def title(self, _: str | Sequence[str] | None, /) -> Facet: ... @overload - def title(self, _: None, **kwds) -> Facet: ... - - @overload - def type(self, _: StandardType_T, **kwds) -> Facet: ... + def type(self, _: StandardType_T, /) -> Facet: ... def __init__( self, @@ -3917,27 +3382,27 @@ def __init__( aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, align: Optional[SchemaBase | Map | LayoutAlign_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Map] = Undefined, + bin: Optional[bool | SchemaBase | Map | None] = Undefined, bounds: Optional[Literal["full", "flush"]] = Undefined, center: Optional[bool | SchemaBase | Map] = Undefined, columns: Optional[float] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, - header: Optional[None | SchemaBase | Map] = Undefined, + header: Optional[SchemaBase | Map | None] = Undefined, sort: Optional[ - None - | SchemaBase + SchemaBase | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map | SortOrder_T + | None ] = Undefined, spacing: Optional[float | SchemaBase | Map] = Undefined, timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, **kwds, ): @@ -3985,7 +3450,7 @@ class Fill( Relative position on a band of a stacked, binned, time unit, or band scale. For example, the marks will be positioned at the beginning of the band if set to ``0``, and at the middle of the band if set to ``0.5``. - bin : bool, dict, None, :class:`BinParams` + bin : bool, dict, :class:`BinParams`, None A flag for binning a ``quantitative`` field, `an object defining binning parameters `__, or indicating that the data for ``x`` or ``y`` channel are binned before they are imported into @@ -4028,7 +3493,7 @@ class Fill( about escaping in the `field documentation `__. 2) ``field`` is not required if ``aggregate`` is ``count``. - legend : dict, None, :class:`Legend` + legend : dict, :class:`Legend`, None An object defining properties of the legend. If ``null``, the legend for the encoding channel will be removed. @@ -4037,7 +3502,7 @@ class Fill( **See also:** `legend `__ documentation. - scale : dict, None, :class:`Scale` + scale : dict, :class:`Scale`, None An object defining properties of the channel's scale, which is the function that transforms values in the data domain (numbers, dates, strings, etc) to visual values (pixels, colors, sizes) of the encoding channels. @@ -4050,7 +3515,7 @@ class Fill( **See also:** `scale `__ documentation. - sort : dict, None, :class:`Sort`, Sequence[str], Sequence[bool], Sequence[float], :class:`SortArray`, :class:`SortOrder`, :class:`AllSortString`, :class:`SortByChannel`, :class:`SortByEncoding`, :class:`EncodingSortField`, :class:`SortByChannelDesc`, Sequence[dict, :class:`DateTime`], Literal['-x', '-y', '-color', '-fill', '-stroke', '-strokeWidth', '-size', '-shape', '-fillOpacity', '-strokeOpacity', '-opacity', '-text', 'ascending', 'descending', 'x', 'y', 'color', 'fill', 'stroke', 'strokeWidth', 'size', 'shape', 'fillOpacity', 'strokeOpacity', 'opacity', 'text'] + sort : dict, :class:`Sort`, Sequence[str], Sequence[bool], Sequence[float], :class:`SortArray`, :class:`SortOrder`, :class:`AllSortString`, :class:`SortByChannel`, :class:`SortByEncoding`, :class:`EncodingSortField`, :class:`SortByChannelDesc`, Sequence[dict, :class:`DateTime`], Literal['-x', '-y', '-color', '-fill', '-stroke', '-strokeWidth', '-size', '-shape', '-fillOpacity', '-strokeOpacity', '-opacity', '-text', 'ascending', 'descending', 'x', 'y', 'color', 'fill', 'stroke', 'strokeWidth', 'size', 'shape', 'fillOpacity', 'strokeOpacity', 'opacity', 'text'], None Sort order for the encoded field. For continuous fields (quantitative or temporal), ``sort`` can be either @@ -4097,7 +3562,7 @@ class Fill( **See also:** `timeUnit `__ documentation. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -4189,27 +3654,19 @@ class Fill( _encoding_name = "fill" @overload - def aggregate(self, _: NonArgAggregateOp_T, **kwds) -> Fill: ... - + def aggregate(self, _: NonArgAggregateOp_T, /) -> Fill: ... @overload - def aggregate( - self, argmax: Optional[str | SchemaBase] = Undefined, **kwds - ) -> Fill: ... - + def aggregate(self, *, argmax: Optional[str | SchemaBase] = Undefined) -> Fill: ... @overload - def aggregate( - self, argmin: Optional[str | SchemaBase] = Undefined, **kwds - ) -> Fill: ... - + def aggregate(self, *, argmin: Optional[str | SchemaBase] = Undefined) -> Fill: ... @overload - def bandPosition(self, _: float, **kwds) -> Fill: ... - + def bandPosition(self, _: float, /) -> Fill: ... @overload - def bin(self, _: bool, **kwds) -> Fill: ... - + def bin(self, _: bool | Bin | None, /) -> Fill: ... @overload def bin( self, + *, anchor: Optional[float] = Undefined, base: Optional[float] = Undefined, binned: Optional[bool] = Undefined, @@ -4220,47 +3677,40 @@ def bin( nice: Optional[bool] = Undefined, step: Optional[float] = Undefined, steps: Optional[Sequence[float]] = Undefined, - **kwds, ) -> Fill: ... - - @overload - def bin(self, _: None, **kwds) -> Fill: ... - @overload def condition( self, + *, test: Optional[str | SchemaBase | Map] = Undefined, - value: Optional[str | None | Parameter | SchemaBase | Map] = Undefined, - **kwds, + value: Optional[str | Parameter | SchemaBase | Map | None] = Undefined, ) -> Fill: ... - @overload def condition( self, + *, empty: Optional[bool] = Undefined, param: Optional[str | SchemaBase] = Undefined, - value: Optional[str | None | Parameter | SchemaBase | Map] = Undefined, - **kwds, + value: Optional[str | Parameter | SchemaBase | Map | None] = Undefined, ) -> Fill: ... - @overload def condition( - self, _: list[core.ConditionalValueDefGradientstringnullExprRef], **kwds + self, _: list[core.ConditionalValueDefGradientstringnullExprRef], / ) -> Fill: ... - @overload - def field(self, _: str, **kwds) -> Fill: ... - + def field(self, _: str | RepeatRef, /) -> Fill: ... @overload def field( self, + *, repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined, - **kwds, ) -> Fill: ... - + @overload + def legend(self, _: Legend | None, /) -> Fill: ... @overload def legend( self, + *, aria: Optional[bool | Parameter | SchemaBase | Map] = Undefined, clipHeight: Optional[float | Parameter | SchemaBase | Map] = Undefined, columnPadding: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -4269,14 +3719,14 @@ def legend( description: Optional[str | Parameter | SchemaBase | Map] = Undefined, direction: Optional[SchemaBase | Orientation_T] = Undefined, fillColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, format: Optional[str | SchemaBase | Map] = Undefined, formatType: Optional[str] = Undefined, gradientLength: Optional[float | Parameter | SchemaBase | Map] = Undefined, gradientOpacity: Optional[float | Parameter | SchemaBase | Map] = Undefined, gradientStrokeColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, gradientStrokeWidth: Optional[float | Parameter | SchemaBase | Map] = Undefined, gradientThickness: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -4286,7 +3736,7 @@ def legend( Parameter | SchemaBase | Map | TextBaseline_T ] = Undefined, labelColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, labelExpr: Optional[str] = Undefined, labelFont: Optional[str | Parameter | SchemaBase | Map] = Undefined, @@ -4310,21 +3760,21 @@ def legend( padding: Optional[float | Parameter | SchemaBase | Map] = Undefined, rowPadding: Optional[float | Parameter | SchemaBase | Map] = Undefined, strokeColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, symbolDash: Optional[ Parameter | SchemaBase | Sequence[float] | Map ] = Undefined, symbolDashOffset: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolFillColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, symbolLimit: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolOffset: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolOpacity: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolSize: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolStrokeColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, symbolStrokeWidth: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolType: Optional[str | Parameter | SchemaBase | Map] = Undefined, @@ -4332,14 +3782,14 @@ def legend( float | Parameter | SchemaBase | Map | TimeInterval_T ] = Undefined, tickMinStep: Optional[float | Parameter | SchemaBase | Map] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, titleAlign: Optional[Parameter | SchemaBase | Map | Align_T] = Undefined, titleAnchor: Optional[Parameter | SchemaBase | Map | TitleAnchor_T] = Undefined, titleBaseline: Optional[ Parameter | SchemaBase | Map | TextBaseline_T ] = Undefined, titleColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, titleFont: Optional[str | Parameter | SchemaBase | Map] = Undefined, titleFontSize: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -4359,19 +3809,17 @@ def legend( | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map ] = Undefined, zindex: Optional[float] = Undefined, - **kwds, ) -> Fill: ... - @overload - def legend(self, _: None, **kwds) -> Fill: ... - + def scale(self, _: Scale | None, /) -> Fill: ... @overload def scale( self, + *, align: Optional[float | Parameter | SchemaBase | Map] = Undefined, base: Optional[float | Parameter | SchemaBase | Map] = Undefined, bins: Optional[SchemaBase | Sequence[float] | Map] = Undefined, @@ -4381,12 +3829,18 @@ def scale( Parameter | SchemaBase | Literal["unaggregated"] - | Sequence[str | bool | None | float | Parameter | SchemaBase | Map] + | Sequence[ + str | bool | float | Temporal | Parameter | SchemaBase | Map | None + ] | Map ] = Undefined, - domainMax: Optional[float | Parameter | SchemaBase | Map] = Undefined, + domainMax: Optional[ + float | Temporal | Parameter | SchemaBase | Map + ] = Undefined, domainMid: Optional[float | Parameter | SchemaBase | Map] = Undefined, - domainMin: Optional[float | Parameter | SchemaBase | Map] = Undefined, + domainMin: Optional[ + float | Temporal | Parameter | SchemaBase | Map + ] = Undefined, domainRaw: Optional[Parameter | SchemaBase | Map] = Undefined, exponent: Optional[float | Parameter | SchemaBase | Map] = Undefined, interpolate: Optional[ @@ -4411,156 +3865,78 @@ def scale( scheme: Optional[Parameter | SchemaBase | Map | ColorScheme_T] = Undefined, type: Optional[SchemaBase | ScaleType_T] = Undefined, zero: Optional[bool | Parameter | SchemaBase | Map] = Undefined, - **kwds, ) -> Fill: ... - - @overload - def scale(self, _: None, **kwds) -> Fill: ... - - @overload - def sort(self, _: list[float], **kwds) -> Fill: ... - - @overload - def sort(self, _: list[str], **kwds) -> Fill: ... - - @overload - def sort(self, _: list[bool], **kwds) -> Fill: ... - - @overload - def sort(self, _: list[core.DateTime], **kwds) -> Fill: ... - - @overload - def sort(self, _: SortOrder_T, **kwds) -> Fill: ... - @overload - def sort(self, _: SortByChannel_T, **kwds) -> Fill: ... - - @overload - def sort(self, _: SortByChannelDesc_T, **kwds) -> Fill: ... - + def sort( + self, + _: Sequence[str] + | Sequence[bool] + | Sequence[float] + | Sequence[DateTime | Temporal] + | AllSortString_T + | None, + /, + ) -> Fill: ... @overload def sort( self, + *, field: Optional[str | SchemaBase | Map] = Undefined, op: Optional[SchemaBase | NonArgAggregateOp_T] = Undefined, - order: Optional[None | SchemaBase | SortOrder_T] = Undefined, - **kwds, + order: Optional[SchemaBase | SortOrder_T | None] = Undefined, ) -> Fill: ... - @overload def sort( self, + *, encoding: Optional[SchemaBase | SortByChannel_T] = Undefined, - order: Optional[None | SchemaBase | SortOrder_T] = Undefined, - **kwds, - ) -> Fill: ... - - @overload - def sort(self, _: None, **kwds) -> Fill: ... - - @overload - def timeUnit(self, _: LocalSingleTimeUnit_T, **kwds) -> Fill: ... - - @overload - def timeUnit(self, _: UtcSingleTimeUnit_T, **kwds) -> Fill: ... - - @overload - def timeUnit(self, _: LocalMultiTimeUnit_T, **kwds) -> Fill: ... - - @overload - def timeUnit(self, _: UtcMultiTimeUnit_T, **kwds) -> Fill: ... - - @overload - def timeUnit( - self, - _: Literal[ - "binnedyear", - "binnedyearquarter", - "binnedyearquartermonth", - "binnedyearmonth", - "binnedyearmonthdate", - "binnedyearmonthdatehours", - "binnedyearmonthdatehoursminutes", - "binnedyearmonthdatehoursminutesseconds", - "binnedyearweek", - "binnedyearweekday", - "binnedyearweekdayhours", - "binnedyearweekdayhoursminutes", - "binnedyearweekdayhoursminutesseconds", - "binnedyeardayofyear", - ], - **kwds, + order: Optional[SchemaBase | SortOrder_T | None] = Undefined, ) -> Fill: ... - @overload def timeUnit( self, - _: Literal[ - "binnedutcyear", - "binnedutcyearquarter", - "binnedutcyearquartermonth", - "binnedutcyearmonth", - "binnedutcyearmonthdate", - "binnedutcyearmonthdatehours", - "binnedutcyearmonthdatehoursminutes", - "binnedutcyearmonthdatehoursminutesseconds", - "binnedutcyearweek", - "binnedutcyearweekday", - "binnedutcyearweekdayhours", - "binnedutcyearweekdayhoursminutes", - "binnedutcyearweekdayhoursminutesseconds", - "binnedutcyeardayofyear", - ], - **kwds, + _: TimeUnitParams | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T, + /, ) -> Fill: ... - @overload def timeUnit( self, + *, binned: Optional[bool] = Undefined, maxbins: Optional[float] = Undefined, step: Optional[float] = Undefined, unit: Optional[SchemaBase | MultiTimeUnit_T | SingleTimeUnit_T] = Undefined, utc: Optional[bool] = Undefined, - **kwds, ) -> Fill: ... - - @overload - def title(self, _: str, **kwds) -> Fill: ... - - @overload - def title(self, _: list[str], **kwds) -> Fill: ... - @overload - def title(self, _: None, **kwds) -> Fill: ... - + def title(self, _: str | Sequence[str] | None, /) -> Fill: ... @overload - def type(self, _: StandardType_T, **kwds) -> Fill: ... + def type(self, _: StandardType_T, /) -> Fill: ... def __init__( self, shorthand: Optional[str | SchemaBase | Sequence[str] | Map] = Undefined, aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Map] = Undefined, + bin: Optional[bool | SchemaBase | Map | None] = Undefined, condition: Optional[SchemaBase | Sequence[SchemaBase | Map] | Map] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, sort: Optional[ - None - | SchemaBase + SchemaBase | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map | AllSortString_T + | None ] = Undefined, timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, **kwds, ): @@ -4601,9 +3977,9 @@ class FillDatum( **Note:** A field definition's ``condition`` property can only contain `conditional value definitions `__ since Vega-Lite only allows at most one encoded field per encoding channel. - datum : str, bool, dict, None, float, :class:`ExprRef`, :class:`DateTime`, :class:`RepeatRef`, :class:`PrimitiveValue` + datum : str, bool, dict, float, :class:`ExprRef`, :class:`DateTime`, :class:`RepeatRef`, :class:`PrimitiveValue`, None A constant value in data domain. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -4695,48 +4071,37 @@ class FillDatum( _encoding_name = "fill" @overload - def bandPosition(self, _: float, **kwds) -> FillDatum: ... - + def bandPosition(self, _: float, /) -> FillDatum: ... @overload def condition( self, + *, test: Optional[str | SchemaBase | Map] = Undefined, - value: Optional[str | None | Parameter | SchemaBase | Map] = Undefined, - **kwds, + value: Optional[str | Parameter | SchemaBase | Map | None] = Undefined, ) -> FillDatum: ... - @overload def condition( self, + *, empty: Optional[bool] = Undefined, param: Optional[str | SchemaBase] = Undefined, - value: Optional[str | None | Parameter | SchemaBase | Map] = Undefined, - **kwds, + value: Optional[str | Parameter | SchemaBase | Map | None] = Undefined, ) -> FillDatum: ... - @overload def condition( - self, _: list[core.ConditionalValueDefGradientstringnullExprRef], **kwds + self, _: list[core.ConditionalValueDefGradientstringnullExprRef], / ) -> FillDatum: ... - - @overload - def title(self, _: str, **kwds) -> FillDatum: ... - - @overload - def title(self, _: list[str], **kwds) -> FillDatum: ... - @overload - def title(self, _: None, **kwds) -> FillDatum: ... - + def title(self, _: str | Sequence[str] | None, /) -> FillDatum: ... @overload - def type(self, _: Type_T, **kwds) -> FillDatum: ... + def type(self, _: Type_T, /) -> FillDatum: ... def __init__( self, datum, bandPosition: Optional[float] = Undefined, condition: Optional[SchemaBase | Sequence[SchemaBase | Map] | Map] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | Type_T] = Undefined, **kwds, ): @@ -4762,7 +4127,7 @@ class FillValue( ---------- condition : dict, :class:`ConditionalMarkPropFieldOrDatumDef`, :class:`ConditionalParameterMarkPropFieldOrDatumDef`, :class:`ConditionalPredicateMarkPropFieldOrDatumDef`, :class:`ConditionalValueDefGradientstringnullExprRef`, :class:`ConditionalParameterValueDefGradientstringnullExprRef`, :class:`ConditionalPredicateValueDefGradientstringnullExprRef`, Sequence[dict, :class:`ConditionalValueDefGradientstringnullExprRef`, :class:`ConditionalParameterValueDefGradientstringnullExprRef`, :class:`ConditionalPredicateValueDefGradientstringnullExprRef`] A field definition or one or more value definition(s) with a parameter predicate. - value : str, dict, None, :class:`ExprRef`, :class:`Gradient`, :class:`LinearGradient`, :class:`RadialGradient` + value : str, dict, :class:`ExprRef`, :class:`Gradient`, :class:`LinearGradient`, :class:`RadialGradient`, None A constant value in visual domain (e.g., ``"red"`` / ``"#0099ff"`` / `gradient definition `__ for color, values between ``0`` to ``1`` for opacity). @@ -4774,111 +4139,105 @@ class FillValue( @overload def condition( self, + *, aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Map] = Undefined, + bin: Optional[bool | SchemaBase | Map | None] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, sort: Optional[ - None - | SchemaBase + SchemaBase | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map | AllSortString_T + | None ] = Undefined, test: Optional[str | SchemaBase | Map] = Undefined, timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, - **kwds, ) -> FillValue: ... - @overload def condition( self, + *, bandPosition: Optional[float] = Undefined, datum: Optional[ - str | bool | None | float | Parameter | SchemaBase | Map + Temporal | Parameter | SchemaBase | Map | PrimitiveValue_T ] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, test: Optional[str | SchemaBase | Map] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | Type_T] = Undefined, - **kwds, ) -> FillValue: ... - @overload def condition( self, + *, aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Map] = Undefined, + bin: Optional[bool | SchemaBase | Map | None] = Undefined, empty: Optional[bool] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, param: Optional[str | SchemaBase] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, sort: Optional[ - None - | SchemaBase + SchemaBase | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map | AllSortString_T + | None ] = Undefined, timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, - **kwds, ) -> FillValue: ... - @overload def condition( self, + *, bandPosition: Optional[float] = Undefined, datum: Optional[ - str | bool | None | float | Parameter | SchemaBase | Map + Temporal | Parameter | SchemaBase | Map | PrimitiveValue_T ] = Undefined, empty: Optional[bool] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, param: Optional[str | SchemaBase] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | Type_T] = Undefined, - **kwds, ) -> FillValue: ... - @overload def condition( self, + *, test: Optional[str | SchemaBase | Map] = Undefined, - value: Optional[str | None | Parameter | SchemaBase | Map] = Undefined, - **kwds, + value: Optional[str | Parameter | SchemaBase | Map | None] = Undefined, ) -> FillValue: ... - @overload def condition( self, + *, empty: Optional[bool] = Undefined, param: Optional[str | SchemaBase] = Undefined, - value: Optional[str | None | Parameter | SchemaBase | Map] = Undefined, - **kwds, + value: Optional[str | Parameter | SchemaBase | Map | None] = Undefined, ) -> FillValue: ... - @overload def condition( - self, _: list[core.ConditionalValueDefGradientstringnullExprRef], **kwds + self, _: list[core.ConditionalValueDefGradientstringnullExprRef], / ) -> FillValue: ... def __init__( @@ -4913,7 +4272,7 @@ class FillOpacity( Relative position on a band of a stacked, binned, time unit, or band scale. For example, the marks will be positioned at the beginning of the band if set to ``0``, and at the middle of the band if set to ``0.5``. - bin : bool, dict, None, :class:`BinParams` + bin : bool, dict, :class:`BinParams`, None A flag for binning a ``quantitative`` field, `an object defining binning parameters `__, or indicating that the data for ``x`` or ``y`` channel are binned before they are imported into @@ -4956,7 +4315,7 @@ class FillOpacity( about escaping in the `field documentation `__. 2) ``field`` is not required if ``aggregate`` is ``count``. - legend : dict, None, :class:`Legend` + legend : dict, :class:`Legend`, None An object defining properties of the legend. If ``null``, the legend for the encoding channel will be removed. @@ -4965,7 +4324,7 @@ class FillOpacity( **See also:** `legend `__ documentation. - scale : dict, None, :class:`Scale` + scale : dict, :class:`Scale`, None An object defining properties of the channel's scale, which is the function that transforms values in the data domain (numbers, dates, strings, etc) to visual values (pixels, colors, sizes) of the encoding channels. @@ -4978,7 +4337,7 @@ class FillOpacity( **See also:** `scale `__ documentation. - sort : dict, None, :class:`Sort`, Sequence[str], Sequence[bool], Sequence[float], :class:`SortArray`, :class:`SortOrder`, :class:`AllSortString`, :class:`SortByChannel`, :class:`SortByEncoding`, :class:`EncodingSortField`, :class:`SortByChannelDesc`, Sequence[dict, :class:`DateTime`], Literal['-x', '-y', '-color', '-fill', '-stroke', '-strokeWidth', '-size', '-shape', '-fillOpacity', '-strokeOpacity', '-opacity', '-text', 'ascending', 'descending', 'x', 'y', 'color', 'fill', 'stroke', 'strokeWidth', 'size', 'shape', 'fillOpacity', 'strokeOpacity', 'opacity', 'text'] + sort : dict, :class:`Sort`, Sequence[str], Sequence[bool], Sequence[float], :class:`SortArray`, :class:`SortOrder`, :class:`AllSortString`, :class:`SortByChannel`, :class:`SortByEncoding`, :class:`EncodingSortField`, :class:`SortByChannelDesc`, Sequence[dict, :class:`DateTime`], Literal['-x', '-y', '-color', '-fill', '-stroke', '-strokeWidth', '-size', '-shape', '-fillOpacity', '-strokeOpacity', '-opacity', '-text', 'ascending', 'descending', 'x', 'y', 'color', 'fill', 'stroke', 'strokeWidth', 'size', 'shape', 'fillOpacity', 'strokeOpacity', 'opacity', 'text'], None Sort order for the encoded field. For continuous fields (quantitative or temporal), ``sort`` can be either @@ -5025,7 +4384,7 @@ class FillOpacity( **See also:** `timeUnit `__ documentation. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -5117,27 +4476,23 @@ class FillOpacity( _encoding_name = "fillOpacity" @overload - def aggregate(self, _: NonArgAggregateOp_T, **kwds) -> FillOpacity: ... - + def aggregate(self, _: NonArgAggregateOp_T, /) -> FillOpacity: ... @overload def aggregate( - self, argmax: Optional[str | SchemaBase] = Undefined, **kwds + self, *, argmax: Optional[str | SchemaBase] = Undefined ) -> FillOpacity: ... - @overload def aggregate( - self, argmin: Optional[str | SchemaBase] = Undefined, **kwds + self, *, argmin: Optional[str | SchemaBase] = Undefined ) -> FillOpacity: ... - @overload - def bandPosition(self, _: float, **kwds) -> FillOpacity: ... - + def bandPosition(self, _: float, /) -> FillOpacity: ... @overload - def bin(self, _: bool, **kwds) -> FillOpacity: ... - + def bin(self, _: bool | Bin | None, /) -> FillOpacity: ... @overload def bin( self, + *, anchor: Optional[float] = Undefined, base: Optional[float] = Undefined, binned: Optional[bool] = Undefined, @@ -5148,47 +4503,40 @@ def bin( nice: Optional[bool] = Undefined, step: Optional[float] = Undefined, steps: Optional[Sequence[float]] = Undefined, - **kwds, ) -> FillOpacity: ... - - @overload - def bin(self, _: None, **kwds) -> FillOpacity: ... - @overload def condition( self, + *, test: Optional[str | SchemaBase | Map] = Undefined, value: Optional[float | Parameter | SchemaBase | Map] = Undefined, - **kwds, ) -> FillOpacity: ... - @overload def condition( self, + *, empty: Optional[bool] = Undefined, param: Optional[str | SchemaBase] = Undefined, value: Optional[float | Parameter | SchemaBase | Map] = Undefined, - **kwds, ) -> FillOpacity: ... - @overload def condition( - self, _: list[core.ConditionalValueDefnumberExprRef], **kwds + self, _: list[core.ConditionalValueDefnumberExprRef], / ) -> FillOpacity: ... - @overload - def field(self, _: str, **kwds) -> FillOpacity: ... - + def field(self, _: str | RepeatRef, /) -> FillOpacity: ... @overload def field( self, + *, repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined, - **kwds, ) -> FillOpacity: ... - + @overload + def legend(self, _: Legend | None, /) -> FillOpacity: ... @overload def legend( self, + *, aria: Optional[bool | Parameter | SchemaBase | Map] = Undefined, clipHeight: Optional[float | Parameter | SchemaBase | Map] = Undefined, columnPadding: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -5197,14 +4545,14 @@ def legend( description: Optional[str | Parameter | SchemaBase | Map] = Undefined, direction: Optional[SchemaBase | Orientation_T] = Undefined, fillColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, format: Optional[str | SchemaBase | Map] = Undefined, formatType: Optional[str] = Undefined, gradientLength: Optional[float | Parameter | SchemaBase | Map] = Undefined, gradientOpacity: Optional[float | Parameter | SchemaBase | Map] = Undefined, gradientStrokeColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, gradientStrokeWidth: Optional[float | Parameter | SchemaBase | Map] = Undefined, gradientThickness: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -5214,7 +4562,7 @@ def legend( Parameter | SchemaBase | Map | TextBaseline_T ] = Undefined, labelColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, labelExpr: Optional[str] = Undefined, labelFont: Optional[str | Parameter | SchemaBase | Map] = Undefined, @@ -5238,21 +4586,21 @@ def legend( padding: Optional[float | Parameter | SchemaBase | Map] = Undefined, rowPadding: Optional[float | Parameter | SchemaBase | Map] = Undefined, strokeColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, symbolDash: Optional[ Parameter | SchemaBase | Sequence[float] | Map ] = Undefined, symbolDashOffset: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolFillColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, symbolLimit: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolOffset: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolOpacity: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolSize: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolStrokeColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, symbolStrokeWidth: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolType: Optional[str | Parameter | SchemaBase | Map] = Undefined, @@ -5260,14 +4608,14 @@ def legend( float | Parameter | SchemaBase | Map | TimeInterval_T ] = Undefined, tickMinStep: Optional[float | Parameter | SchemaBase | Map] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, titleAlign: Optional[Parameter | SchemaBase | Map | Align_T] = Undefined, titleAnchor: Optional[Parameter | SchemaBase | Map | TitleAnchor_T] = Undefined, titleBaseline: Optional[ Parameter | SchemaBase | Map | TextBaseline_T ] = Undefined, titleColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, titleFont: Optional[str | Parameter | SchemaBase | Map] = Undefined, titleFontSize: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -5287,19 +4635,17 @@ def legend( | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map ] = Undefined, zindex: Optional[float] = Undefined, - **kwds, ) -> FillOpacity: ... - @overload - def legend(self, _: None, **kwds) -> FillOpacity: ... - + def scale(self, _: Scale | None, /) -> FillOpacity: ... @overload def scale( self, + *, align: Optional[float | Parameter | SchemaBase | Map] = Undefined, base: Optional[float | Parameter | SchemaBase | Map] = Undefined, bins: Optional[SchemaBase | Sequence[float] | Map] = Undefined, @@ -5309,12 +4655,18 @@ def scale( Parameter | SchemaBase | Literal["unaggregated"] - | Sequence[str | bool | None | float | Parameter | SchemaBase | Map] + | Sequence[ + str | bool | float | Temporal | Parameter | SchemaBase | Map | None + ] | Map ] = Undefined, - domainMax: Optional[float | Parameter | SchemaBase | Map] = Undefined, + domainMax: Optional[ + float | Temporal | Parameter | SchemaBase | Map + ] = Undefined, domainMid: Optional[float | Parameter | SchemaBase | Map] = Undefined, - domainMin: Optional[float | Parameter | SchemaBase | Map] = Undefined, + domainMin: Optional[ + float | Temporal | Parameter | SchemaBase | Map + ] = Undefined, domainRaw: Optional[Parameter | SchemaBase | Map] = Undefined, exponent: Optional[float | Parameter | SchemaBase | Map] = Undefined, interpolate: Optional[ @@ -5339,156 +4691,78 @@ def scale( scheme: Optional[Parameter | SchemaBase | Map | ColorScheme_T] = Undefined, type: Optional[SchemaBase | ScaleType_T] = Undefined, zero: Optional[bool | Parameter | SchemaBase | Map] = Undefined, - **kwds, ) -> FillOpacity: ... - - @overload - def scale(self, _: None, **kwds) -> FillOpacity: ... - - @overload - def sort(self, _: list[float], **kwds) -> FillOpacity: ... - - @overload - def sort(self, _: list[str], **kwds) -> FillOpacity: ... - - @overload - def sort(self, _: list[bool], **kwds) -> FillOpacity: ... - @overload - def sort(self, _: list[core.DateTime], **kwds) -> FillOpacity: ... - - @overload - def sort(self, _: SortOrder_T, **kwds) -> FillOpacity: ... - - @overload - def sort(self, _: SortByChannel_T, **kwds) -> FillOpacity: ... - - @overload - def sort(self, _: SortByChannelDesc_T, **kwds) -> FillOpacity: ... - + def sort( + self, + _: Sequence[str] + | Sequence[bool] + | Sequence[float] + | Sequence[DateTime | Temporal] + | AllSortString_T + | None, + /, + ) -> FillOpacity: ... @overload def sort( self, + *, field: Optional[str | SchemaBase | Map] = Undefined, op: Optional[SchemaBase | NonArgAggregateOp_T] = Undefined, - order: Optional[None | SchemaBase | SortOrder_T] = Undefined, - **kwds, + order: Optional[SchemaBase | SortOrder_T | None] = Undefined, ) -> FillOpacity: ... - @overload def sort( self, + *, encoding: Optional[SchemaBase | SortByChannel_T] = Undefined, - order: Optional[None | SchemaBase | SortOrder_T] = Undefined, - **kwds, - ) -> FillOpacity: ... - - @overload - def sort(self, _: None, **kwds) -> FillOpacity: ... - - @overload - def timeUnit(self, _: LocalSingleTimeUnit_T, **kwds) -> FillOpacity: ... - - @overload - def timeUnit(self, _: UtcSingleTimeUnit_T, **kwds) -> FillOpacity: ... - - @overload - def timeUnit(self, _: LocalMultiTimeUnit_T, **kwds) -> FillOpacity: ... - - @overload - def timeUnit(self, _: UtcMultiTimeUnit_T, **kwds) -> FillOpacity: ... - - @overload - def timeUnit( - self, - _: Literal[ - "binnedyear", - "binnedyearquarter", - "binnedyearquartermonth", - "binnedyearmonth", - "binnedyearmonthdate", - "binnedyearmonthdatehours", - "binnedyearmonthdatehoursminutes", - "binnedyearmonthdatehoursminutesseconds", - "binnedyearweek", - "binnedyearweekday", - "binnedyearweekdayhours", - "binnedyearweekdayhoursminutes", - "binnedyearweekdayhoursminutesseconds", - "binnedyeardayofyear", - ], - **kwds, + order: Optional[SchemaBase | SortOrder_T | None] = Undefined, ) -> FillOpacity: ... - @overload def timeUnit( self, - _: Literal[ - "binnedutcyear", - "binnedutcyearquarter", - "binnedutcyearquartermonth", - "binnedutcyearmonth", - "binnedutcyearmonthdate", - "binnedutcyearmonthdatehours", - "binnedutcyearmonthdatehoursminutes", - "binnedutcyearmonthdatehoursminutesseconds", - "binnedutcyearweek", - "binnedutcyearweekday", - "binnedutcyearweekdayhours", - "binnedutcyearweekdayhoursminutes", - "binnedutcyearweekdayhoursminutesseconds", - "binnedutcyeardayofyear", - ], - **kwds, + _: TimeUnitParams | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T, + /, ) -> FillOpacity: ... - @overload def timeUnit( self, + *, binned: Optional[bool] = Undefined, maxbins: Optional[float] = Undefined, step: Optional[float] = Undefined, unit: Optional[SchemaBase | MultiTimeUnit_T | SingleTimeUnit_T] = Undefined, utc: Optional[bool] = Undefined, - **kwds, ) -> FillOpacity: ... - - @overload - def title(self, _: str, **kwds) -> FillOpacity: ... - @overload - def title(self, _: list[str], **kwds) -> FillOpacity: ... - - @overload - def title(self, _: None, **kwds) -> FillOpacity: ... - + def title(self, _: str | Sequence[str] | None, /) -> FillOpacity: ... @overload - def type(self, _: StandardType_T, **kwds) -> FillOpacity: ... + def type(self, _: StandardType_T, /) -> FillOpacity: ... def __init__( self, shorthand: Optional[str | SchemaBase | Sequence[str] | Map] = Undefined, aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Map] = Undefined, + bin: Optional[bool | SchemaBase | Map | None] = Undefined, condition: Optional[SchemaBase | Sequence[SchemaBase | Map] | Map] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, sort: Optional[ - None - | SchemaBase + SchemaBase | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map | AllSortString_T + | None ] = Undefined, timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, **kwds, ): @@ -5529,9 +4803,9 @@ class FillOpacityDatum( **Note:** A field definition's ``condition`` property can only contain `conditional value definitions `__ since Vega-Lite only allows at most one encoded field per encoding channel. - datum : str, bool, dict, None, float, :class:`ExprRef`, :class:`DateTime`, :class:`RepeatRef`, :class:`PrimitiveValue` + datum : str, bool, dict, float, :class:`ExprRef`, :class:`DateTime`, :class:`RepeatRef`, :class:`PrimitiveValue`, None A constant value in data domain. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -5623,48 +4897,37 @@ class FillOpacityDatum( _encoding_name = "fillOpacity" @overload - def bandPosition(self, _: float, **kwds) -> FillOpacityDatum: ... - + def bandPosition(self, _: float, /) -> FillOpacityDatum: ... @overload def condition( self, + *, test: Optional[str | SchemaBase | Map] = Undefined, value: Optional[float | Parameter | SchemaBase | Map] = Undefined, - **kwds, ) -> FillOpacityDatum: ... - @overload def condition( self, + *, empty: Optional[bool] = Undefined, param: Optional[str | SchemaBase] = Undefined, value: Optional[float | Parameter | SchemaBase | Map] = Undefined, - **kwds, ) -> FillOpacityDatum: ... - @overload def condition( - self, _: list[core.ConditionalValueDefnumberExprRef], **kwds + self, _: list[core.ConditionalValueDefnumberExprRef], / ) -> FillOpacityDatum: ... - - @overload - def title(self, _: str, **kwds) -> FillOpacityDatum: ... - - @overload - def title(self, _: list[str], **kwds) -> FillOpacityDatum: ... - @overload - def title(self, _: None, **kwds) -> FillOpacityDatum: ... - + def title(self, _: str | Sequence[str] | None, /) -> FillOpacityDatum: ... @overload - def type(self, _: Type_T, **kwds) -> FillOpacityDatum: ... + def type(self, _: Type_T, /) -> FillOpacityDatum: ... def __init__( self, datum, bandPosition: Optional[float] = Undefined, condition: Optional[SchemaBase | Sequence[SchemaBase | Map] | Map] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | Type_T] = Undefined, **kwds, ): @@ -5701,111 +4964,105 @@ class FillOpacityValue( @overload def condition( self, + *, aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Map] = Undefined, + bin: Optional[bool | SchemaBase | Map | None] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, sort: Optional[ - None - | SchemaBase + SchemaBase | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map | AllSortString_T + | None ] = Undefined, test: Optional[str | SchemaBase | Map] = Undefined, timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, - **kwds, ) -> FillOpacityValue: ... - @overload def condition( self, + *, bandPosition: Optional[float] = Undefined, datum: Optional[ - str | bool | None | float | Parameter | SchemaBase | Map + Temporal | Parameter | SchemaBase | Map | PrimitiveValue_T ] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, test: Optional[str | SchemaBase | Map] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | Type_T] = Undefined, - **kwds, ) -> FillOpacityValue: ... - @overload def condition( self, + *, aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Map] = Undefined, + bin: Optional[bool | SchemaBase | Map | None] = Undefined, empty: Optional[bool] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, param: Optional[str | SchemaBase] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, sort: Optional[ - None - | SchemaBase + SchemaBase | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map | AllSortString_T + | None ] = Undefined, timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, - **kwds, ) -> FillOpacityValue: ... - @overload def condition( self, + *, bandPosition: Optional[float] = Undefined, datum: Optional[ - str | bool | None | float | Parameter | SchemaBase | Map + Temporal | Parameter | SchemaBase | Map | PrimitiveValue_T ] = Undefined, empty: Optional[bool] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, param: Optional[str | SchemaBase] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | Type_T] = Undefined, - **kwds, ) -> FillOpacityValue: ... - @overload def condition( self, + *, test: Optional[str | SchemaBase | Map] = Undefined, value: Optional[float | Parameter | SchemaBase | Map] = Undefined, - **kwds, ) -> FillOpacityValue: ... - @overload def condition( self, + *, empty: Optional[bool] = Undefined, param: Optional[str | SchemaBase] = Undefined, value: Optional[float | Parameter | SchemaBase | Map] = Undefined, - **kwds, ) -> FillOpacityValue: ... - @overload def condition( - self, _: list[core.ConditionalValueDefnumberExprRef], **kwds + self, _: list[core.ConditionalValueDefnumberExprRef], / ) -> FillOpacityValue: ... def __init__( @@ -5838,7 +5095,7 @@ class Href(FieldChannelMixin, core.StringFieldDefWithCondition): Relative position on a band of a stacked, binned, time unit, or band scale. For example, the marks will be positioned at the beginning of the band if set to ``0``, and at the middle of the band if set to ``0.5``. - bin : bool, dict, None, Literal['binned'], :class:`BinParams` + bin : bool, dict, Literal['binned'], :class:`BinParams`, None A flag for binning a ``quantitative`` field, `an object defining binning parameters `__, or indicating that the data for ``x`` or ``y`` channel are binned before they are imported into @@ -5922,7 +5179,7 @@ class Href(FieldChannelMixin, core.StringFieldDefWithCondition): **See also:** `timeUnit `__ documentation. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -6014,27 +5271,19 @@ class Href(FieldChannelMixin, core.StringFieldDefWithCondition): _encoding_name = "href" @overload - def aggregate(self, _: NonArgAggregateOp_T, **kwds) -> Href: ... - + def aggregate(self, _: NonArgAggregateOp_T, /) -> Href: ... @overload - def aggregate( - self, argmax: Optional[str | SchemaBase] = Undefined, **kwds - ) -> Href: ... - + def aggregate(self, *, argmax: Optional[str | SchemaBase] = Undefined) -> Href: ... @overload - def aggregate( - self, argmin: Optional[str | SchemaBase] = Undefined, **kwds - ) -> Href: ... - + def aggregate(self, *, argmin: Optional[str | SchemaBase] = Undefined) -> Href: ... @overload - def bandPosition(self, _: float, **kwds) -> Href: ... - + def bandPosition(self, _: float, /) -> Href: ... @overload - def bin(self, _: bool, **kwds) -> Href: ... - + def bin(self, _: bool | Bin | Literal["binned"] | None, /) -> Href: ... @overload def bin( self, + *, anchor: Optional[float] = Undefined, base: Optional[float] = Undefined, binned: Optional[bool] = Undefined, @@ -6045,141 +5294,65 @@ def bin( nice: Optional[bool] = Undefined, step: Optional[float] = Undefined, steps: Optional[Sequence[float]] = Undefined, - **kwds, ) -> Href: ... - - @overload - def bin(self, _: Literal["binned"], **kwds) -> Href: ... - - @overload - def bin(self, _: None, **kwds) -> Href: ... - @overload def condition( self, + *, test: Optional[str | SchemaBase | Map] = Undefined, value: Optional[str | Parameter | SchemaBase | Map] = Undefined, - **kwds, ) -> Href: ... - @overload def condition( self, + *, empty: Optional[bool] = Undefined, param: Optional[str | SchemaBase] = Undefined, value: Optional[str | Parameter | SchemaBase | Map] = Undefined, - **kwds, ) -> Href: ... - @overload - def condition( - self, _: list[core.ConditionalValueDefstringExprRef], **kwds - ) -> Href: ... - + def condition(self, _: list[core.ConditionalValueDefstringExprRef], /) -> Href: ... @overload - def field(self, _: str, **kwds) -> Href: ... - + def field(self, _: str | RepeatRef, /) -> Href: ... @overload def field( self, + *, repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined, - **kwds, ) -> Href: ... - - @overload - def format(self, _: str, **kwds) -> Href: ... - - @overload - def format(self, _: Map, **kwds) -> Href: ... - - @overload - def formatType(self, _: str, **kwds) -> Href: ... - - @overload - def timeUnit(self, _: LocalSingleTimeUnit_T, **kwds) -> Href: ... - - @overload - def timeUnit(self, _: UtcSingleTimeUnit_T, **kwds) -> Href: ... - @overload - def timeUnit(self, _: LocalMultiTimeUnit_T, **kwds) -> Href: ... - + def format(self, _: str, /) -> Href: ... @overload - def timeUnit(self, _: UtcMultiTimeUnit_T, **kwds) -> Href: ... - + def format(self, _: Map, /) -> Href: ... @overload - def timeUnit( - self, - _: Literal[ - "binnedyear", - "binnedyearquarter", - "binnedyearquartermonth", - "binnedyearmonth", - "binnedyearmonthdate", - "binnedyearmonthdatehours", - "binnedyearmonthdatehoursminutes", - "binnedyearmonthdatehoursminutesseconds", - "binnedyearweek", - "binnedyearweekday", - "binnedyearweekdayhours", - "binnedyearweekdayhoursminutes", - "binnedyearweekdayhoursminutesseconds", - "binnedyeardayofyear", - ], - **kwds, - ) -> Href: ... - + def formatType(self, _: str, /) -> Href: ... @overload def timeUnit( self, - _: Literal[ - "binnedutcyear", - "binnedutcyearquarter", - "binnedutcyearquartermonth", - "binnedutcyearmonth", - "binnedutcyearmonthdate", - "binnedutcyearmonthdatehours", - "binnedutcyearmonthdatehoursminutes", - "binnedutcyearmonthdatehoursminutesseconds", - "binnedutcyearweek", - "binnedutcyearweekday", - "binnedutcyearweekdayhours", - "binnedutcyearweekdayhoursminutes", - "binnedutcyearweekdayhoursminutesseconds", - "binnedutcyeardayofyear", - ], - **kwds, + _: TimeUnitParams | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T, + /, ) -> Href: ... - @overload def timeUnit( self, + *, binned: Optional[bool] = Undefined, maxbins: Optional[float] = Undefined, step: Optional[float] = Undefined, unit: Optional[SchemaBase | MultiTimeUnit_T | SingleTimeUnit_T] = Undefined, utc: Optional[bool] = Undefined, - **kwds, ) -> Href: ... - - @overload - def title(self, _: str, **kwds) -> Href: ... - @overload - def title(self, _: list[str], **kwds) -> Href: ... - - @overload - def title(self, _: None, **kwds) -> Href: ... - + def title(self, _: str | Sequence[str] | None, /) -> Href: ... @overload - def type(self, _: StandardType_T, **kwds) -> Href: ... + def type(self, _: StandardType_T, /) -> Href: ... def __init__( self, shorthand: Optional[str | SchemaBase | Sequence[str] | Map] = Undefined, aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Literal["binned"] | Map] = Undefined, + bin: Optional[bool | SchemaBase | Literal["binned"] | Map | None] = Undefined, condition: Optional[SchemaBase | Sequence[SchemaBase | Map] | Map] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, format: Optional[str | SchemaBase | Map] = Undefined, @@ -6187,7 +5360,7 @@ def __init__( timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, **kwds, ): @@ -6216,7 +5389,7 @@ class HrefValue(ValueChannelMixin, core.StringValueDefWithCondition): ---------- condition : dict, :class:`ConditionalMarkPropFieldOrDatumDef`, :class:`ConditionalValueDefstringnullExprRef`, :class:`ConditionalParameterMarkPropFieldOrDatumDef`, :class:`ConditionalPredicateMarkPropFieldOrDatumDef`, :class:`ConditionalParameterValueDefstringnullExprRef`, :class:`ConditionalPredicateValueDefstringnullExprRef`, Sequence[dict, :class:`ConditionalValueDefstringnullExprRef`, :class:`ConditionalParameterValueDefstringnullExprRef`, :class:`ConditionalPredicateValueDefstringnullExprRef`] A field definition or one or more value definition(s) with a parameter predicate. - value : str, dict, None, :class:`ExprRef` + value : str, dict, :class:`ExprRef`, None A constant value in visual domain (e.g., ``"red"`` / ``"#0099ff"`` / `gradient definition `__ for color, values between ``0`` to ``1`` for opacity). @@ -6228,111 +5401,105 @@ class HrefValue(ValueChannelMixin, core.StringValueDefWithCondition): @overload def condition( self, + *, aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Map] = Undefined, + bin: Optional[bool | SchemaBase | Map | None] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, sort: Optional[ - None - | SchemaBase + SchemaBase | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map | AllSortString_T + | None ] = Undefined, test: Optional[str | SchemaBase | Map] = Undefined, timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, - **kwds, ) -> HrefValue: ... - @overload def condition( self, + *, bandPosition: Optional[float] = Undefined, datum: Optional[ - str | bool | None | float | Parameter | SchemaBase | Map + Temporal | Parameter | SchemaBase | Map | PrimitiveValue_T ] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, test: Optional[str | SchemaBase | Map] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | Type_T] = Undefined, - **kwds, ) -> HrefValue: ... - @overload def condition( self, + *, aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Map] = Undefined, + bin: Optional[bool | SchemaBase | Map | None] = Undefined, empty: Optional[bool] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, param: Optional[str | SchemaBase] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, sort: Optional[ - None - | SchemaBase + SchemaBase | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map | AllSortString_T + | None ] = Undefined, timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, - **kwds, ) -> HrefValue: ... - @overload def condition( self, + *, bandPosition: Optional[float] = Undefined, datum: Optional[ - str | bool | None | float | Parameter | SchemaBase | Map + Temporal | Parameter | SchemaBase | Map | PrimitiveValue_T ] = Undefined, empty: Optional[bool] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, param: Optional[str | SchemaBase] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | Type_T] = Undefined, - **kwds, ) -> HrefValue: ... - @overload def condition( self, + *, test: Optional[str | SchemaBase | Map] = Undefined, - value: Optional[str | None | Parameter | SchemaBase | Map] = Undefined, - **kwds, + value: Optional[str | Parameter | SchemaBase | Map | None] = Undefined, ) -> HrefValue: ... - @overload def condition( self, + *, empty: Optional[bool] = Undefined, param: Optional[str | SchemaBase] = Undefined, - value: Optional[str | None | Parameter | SchemaBase | Map] = Undefined, - **kwds, + value: Optional[str | Parameter | SchemaBase | Map | None] = Undefined, ) -> HrefValue: ... - @overload def condition( - self, _: list[core.ConditionalValueDefstringnullExprRef], **kwds + self, _: list[core.ConditionalValueDefstringnullExprRef], / ) -> HrefValue: ... def __init__( @@ -6367,7 +5534,7 @@ class Key(FieldChannelMixin, core.FieldDefWithoutScale): Relative position on a band of a stacked, binned, time unit, or band scale. For example, the marks will be positioned at the beginning of the band if set to ``0``, and at the middle of the band if set to ``0.5``. - bin : bool, dict, None, Literal['binned'], :class:`BinParams` + bin : bool, dict, Literal['binned'], :class:`BinParams`, None A flag for binning a ``quantitative`` field, `an object defining binning parameters `__, or indicating that the data for ``x`` or ``y`` channel are binned before they are imported into @@ -6412,7 +5579,7 @@ class Key(FieldChannelMixin, core.FieldDefWithoutScale): **See also:** `timeUnit `__ documentation. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -6504,27 +5671,19 @@ class Key(FieldChannelMixin, core.FieldDefWithoutScale): _encoding_name = "key" @overload - def aggregate(self, _: NonArgAggregateOp_T, **kwds) -> Key: ... - + def aggregate(self, _: NonArgAggregateOp_T, /) -> Key: ... @overload - def aggregate( - self, argmax: Optional[str | SchemaBase] = Undefined, **kwds - ) -> Key: ... - + def aggregate(self, *, argmax: Optional[str | SchemaBase] = Undefined) -> Key: ... @overload - def aggregate( - self, argmin: Optional[str | SchemaBase] = Undefined, **kwds - ) -> Key: ... - + def aggregate(self, *, argmin: Optional[str | SchemaBase] = Undefined) -> Key: ... @overload - def bandPosition(self, _: float, **kwds) -> Key: ... - + def bandPosition(self, _: float, /) -> Key: ... @overload - def bin(self, _: bool, **kwds) -> Key: ... - + def bin(self, _: bool | Bin | Literal["binned"] | None, /) -> Key: ... @overload def bin( self, + *, anchor: Optional[float] = Undefined, base: Optional[float] = Undefined, binned: Optional[bool] = Undefined, @@ -6535,115 +5694,47 @@ def bin( nice: Optional[bool] = Undefined, step: Optional[float] = Undefined, steps: Optional[Sequence[float]] = Undefined, - **kwds, ) -> Key: ... - - @overload - def bin(self, _: Literal["binned"], **kwds) -> Key: ... - @overload - def bin(self, _: None, **kwds) -> Key: ... - - @overload - def field(self, _: str, **kwds) -> Key: ... - + def field(self, _: str | RepeatRef, /) -> Key: ... @overload def field( self, + *, repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined, - **kwds, - ) -> Key: ... - - @overload - def timeUnit(self, _: LocalSingleTimeUnit_T, **kwds) -> Key: ... - - @overload - def timeUnit(self, _: UtcSingleTimeUnit_T, **kwds) -> Key: ... - - @overload - def timeUnit(self, _: LocalMultiTimeUnit_T, **kwds) -> Key: ... - - @overload - def timeUnit(self, _: UtcMultiTimeUnit_T, **kwds) -> Key: ... - - @overload - def timeUnit( - self, - _: Literal[ - "binnedyear", - "binnedyearquarter", - "binnedyearquartermonth", - "binnedyearmonth", - "binnedyearmonthdate", - "binnedyearmonthdatehours", - "binnedyearmonthdatehoursminutes", - "binnedyearmonthdatehoursminutesseconds", - "binnedyearweek", - "binnedyearweekday", - "binnedyearweekdayhours", - "binnedyearweekdayhoursminutes", - "binnedyearweekdayhoursminutesseconds", - "binnedyeardayofyear", - ], - **kwds, ) -> Key: ... - @overload def timeUnit( self, - _: Literal[ - "binnedutcyear", - "binnedutcyearquarter", - "binnedutcyearquartermonth", - "binnedutcyearmonth", - "binnedutcyearmonthdate", - "binnedutcyearmonthdatehours", - "binnedutcyearmonthdatehoursminutes", - "binnedutcyearmonthdatehoursminutesseconds", - "binnedutcyearweek", - "binnedutcyearweekday", - "binnedutcyearweekdayhours", - "binnedutcyearweekdayhoursminutes", - "binnedutcyearweekdayhoursminutesseconds", - "binnedutcyeardayofyear", - ], - **kwds, + _: TimeUnitParams | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T, + /, ) -> Key: ... - @overload def timeUnit( self, + *, binned: Optional[bool] = Undefined, maxbins: Optional[float] = Undefined, step: Optional[float] = Undefined, unit: Optional[SchemaBase | MultiTimeUnit_T | SingleTimeUnit_T] = Undefined, utc: Optional[bool] = Undefined, - **kwds, ) -> Key: ... - - @overload - def title(self, _: str, **kwds) -> Key: ... - - @overload - def title(self, _: list[str], **kwds) -> Key: ... - @overload - def title(self, _: None, **kwds) -> Key: ... - + def title(self, _: str | Sequence[str] | None, /) -> Key: ... @overload - def type(self, _: StandardType_T, **kwds) -> Key: ... + def type(self, _: StandardType_T, /) -> Key: ... def __init__( self, shorthand: Optional[str | SchemaBase | Sequence[str] | Map] = Undefined, aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Literal["binned"] | Map] = Undefined, + bin: Optional[bool | SchemaBase | Literal["binned"] | Map | None] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, **kwds, ): @@ -6726,7 +5817,7 @@ class Latitude(FieldChannelMixin, core.LatLongFieldDef): **See also:** `timeUnit `__ documentation. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -6814,116 +5905,51 @@ class Latitude(FieldChannelMixin, core.LatLongFieldDef): documentation. """ - _class_is_valid_at_instantiation = False - _encoding_name = "latitude" - - @overload - def aggregate(self, _: NonArgAggregateOp_T, **kwds) -> Latitude: ... - - @overload - def aggregate( - self, argmax: Optional[str | SchemaBase] = Undefined, **kwds - ) -> Latitude: ... - - @overload - def aggregate( - self, argmin: Optional[str | SchemaBase] = Undefined, **kwds - ) -> Latitude: ... - - @overload - def bandPosition(self, _: float, **kwds) -> Latitude: ... - - @overload - def bin(self, _: None, **kwds) -> Latitude: ... + _class_is_valid_at_instantiation = False + _encoding_name = "latitude" @overload - def field(self, _: str, **kwds) -> Latitude: ... - + def aggregate(self, _: NonArgAggregateOp_T, /) -> Latitude: ... @overload - def field( - self, - repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined, - **kwds, + def aggregate( + self, *, argmax: Optional[str | SchemaBase] = Undefined ) -> Latitude: ... - @overload - def timeUnit(self, _: LocalSingleTimeUnit_T, **kwds) -> Latitude: ... - + def aggregate( + self, *, argmin: Optional[str | SchemaBase] = Undefined + ) -> Latitude: ... @overload - def timeUnit(self, _: UtcSingleTimeUnit_T, **kwds) -> Latitude: ... - + def bandPosition(self, _: float, /) -> Latitude: ... @overload - def timeUnit(self, _: LocalMultiTimeUnit_T, **kwds) -> Latitude: ... - + def bin(self, _: None, /) -> Latitude: ... @overload - def timeUnit(self, _: UtcMultiTimeUnit_T, **kwds) -> Latitude: ... - + def field(self, _: str | RepeatRef, /) -> Latitude: ... @overload - def timeUnit( + def field( self, - _: Literal[ - "binnedyear", - "binnedyearquarter", - "binnedyearquartermonth", - "binnedyearmonth", - "binnedyearmonthdate", - "binnedyearmonthdatehours", - "binnedyearmonthdatehoursminutes", - "binnedyearmonthdatehoursminutesseconds", - "binnedyearweek", - "binnedyearweekday", - "binnedyearweekdayhours", - "binnedyearweekdayhoursminutes", - "binnedyearweekdayhoursminutesseconds", - "binnedyeardayofyear", - ], - **kwds, + *, + repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined, ) -> Latitude: ... - @overload def timeUnit( self, - _: Literal[ - "binnedutcyear", - "binnedutcyearquarter", - "binnedutcyearquartermonth", - "binnedutcyearmonth", - "binnedutcyearmonthdate", - "binnedutcyearmonthdatehours", - "binnedutcyearmonthdatehoursminutes", - "binnedutcyearmonthdatehoursminutesseconds", - "binnedutcyearweek", - "binnedutcyearweekday", - "binnedutcyearweekdayhours", - "binnedutcyearweekdayhoursminutes", - "binnedutcyearweekdayhoursminutesseconds", - "binnedutcyeardayofyear", - ], - **kwds, + _: TimeUnitParams | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T, + /, ) -> Latitude: ... - @overload def timeUnit( self, + *, binned: Optional[bool] = Undefined, maxbins: Optional[float] = Undefined, step: Optional[float] = Undefined, unit: Optional[SchemaBase | MultiTimeUnit_T | SingleTimeUnit_T] = Undefined, utc: Optional[bool] = Undefined, - **kwds, ) -> Latitude: ... - @overload - def title(self, _: str, **kwds) -> Latitude: ... - - @overload - def title(self, _: list[str], **kwds) -> Latitude: ... - - @overload - def title(self, _: None, **kwds) -> Latitude: ... - + def title(self, _: str | Sequence[str] | None, /) -> Latitude: ... @overload - def type(self, _: Literal["quantitative"], **kwds) -> Latitude: ... + def type(self, _: Literal["quantitative"], /) -> Latitude: ... def __init__( self, @@ -6935,7 +5961,7 @@ def __init__( timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[Literal["quantitative"]] = Undefined, **kwds, ): @@ -6963,9 +5989,9 @@ class LatitudeDatum(DatumChannelMixin, core.DatumDef): Relative position on a band of a stacked, binned, time unit, or band scale. For example, the marks will be positioned at the beginning of the band if set to ``0``, and at the middle of the band if set to ``0.5``. - datum : str, bool, dict, None, float, :class:`ExprRef`, :class:`DateTime`, :class:`RepeatRef`, :class:`PrimitiveValue` + datum : str, bool, dict, float, :class:`ExprRef`, :class:`DateTime`, :class:`RepeatRef`, :class:`PrimitiveValue`, None A constant value in data domain. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -7057,25 +6083,17 @@ class LatitudeDatum(DatumChannelMixin, core.DatumDef): _encoding_name = "latitude" @overload - def bandPosition(self, _: float, **kwds) -> LatitudeDatum: ... - - @overload - def title(self, _: str, **kwds) -> LatitudeDatum: ... - - @overload - def title(self, _: list[str], **kwds) -> LatitudeDatum: ... - + def bandPosition(self, _: float, /) -> LatitudeDatum: ... @overload - def title(self, _: None, **kwds) -> LatitudeDatum: ... - + def title(self, _: str | Sequence[str] | None, /) -> LatitudeDatum: ... @overload - def type(self, _: Type_T, **kwds) -> LatitudeDatum: ... + def type(self, _: Type_T, /) -> LatitudeDatum: ... def __init__( self, datum, bandPosition: Optional[float] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | Type_T] = Undefined, **kwds, ): @@ -7153,7 +6171,7 @@ class Latitude2(FieldChannelMixin, core.SecondaryFieldDef): **See also:** `timeUnit `__ documentation. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -7179,109 +6197,45 @@ class Latitude2(FieldChannelMixin, core.SecondaryFieldDef): _encoding_name = "latitude2" @overload - def aggregate(self, _: NonArgAggregateOp_T, **kwds) -> Latitude2: ... - + def aggregate(self, _: NonArgAggregateOp_T, /) -> Latitude2: ... @overload def aggregate( - self, argmax: Optional[str | SchemaBase] = Undefined, **kwds + self, *, argmax: Optional[str | SchemaBase] = Undefined ) -> Latitude2: ... - @overload def aggregate( - self, argmin: Optional[str | SchemaBase] = Undefined, **kwds + self, *, argmin: Optional[str | SchemaBase] = Undefined ) -> Latitude2: ... - @overload - def bandPosition(self, _: float, **kwds) -> Latitude2: ... - + def bandPosition(self, _: float, /) -> Latitude2: ... @overload - def bin(self, _: None, **kwds) -> Latitude2: ... - + def bin(self, _: None, /) -> Latitude2: ... @overload - def field(self, _: str, **kwds) -> Latitude2: ... - + def field(self, _: str | RepeatRef, /) -> Latitude2: ... @overload def field( self, + *, repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined, - **kwds, - ) -> Latitude2: ... - - @overload - def timeUnit(self, _: LocalSingleTimeUnit_T, **kwds) -> Latitude2: ... - - @overload - def timeUnit(self, _: UtcSingleTimeUnit_T, **kwds) -> Latitude2: ... - - @overload - def timeUnit(self, _: LocalMultiTimeUnit_T, **kwds) -> Latitude2: ... - - @overload - def timeUnit(self, _: UtcMultiTimeUnit_T, **kwds) -> Latitude2: ... - - @overload - def timeUnit( - self, - _: Literal[ - "binnedyear", - "binnedyearquarter", - "binnedyearquartermonth", - "binnedyearmonth", - "binnedyearmonthdate", - "binnedyearmonthdatehours", - "binnedyearmonthdatehoursminutes", - "binnedyearmonthdatehoursminutesseconds", - "binnedyearweek", - "binnedyearweekday", - "binnedyearweekdayhours", - "binnedyearweekdayhoursminutes", - "binnedyearweekdayhoursminutesseconds", - "binnedyeardayofyear", - ], - **kwds, ) -> Latitude2: ... - @overload def timeUnit( self, - _: Literal[ - "binnedutcyear", - "binnedutcyearquarter", - "binnedutcyearquartermonth", - "binnedutcyearmonth", - "binnedutcyearmonthdate", - "binnedutcyearmonthdatehours", - "binnedutcyearmonthdatehoursminutes", - "binnedutcyearmonthdatehoursminutesseconds", - "binnedutcyearweek", - "binnedutcyearweekday", - "binnedutcyearweekdayhours", - "binnedutcyearweekdayhoursminutes", - "binnedutcyearweekdayhoursminutesseconds", - "binnedutcyeardayofyear", - ], - **kwds, + _: TimeUnitParams | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T, + /, ) -> Latitude2: ... - @overload def timeUnit( self, + *, binned: Optional[bool] = Undefined, maxbins: Optional[float] = Undefined, step: Optional[float] = Undefined, unit: Optional[SchemaBase | MultiTimeUnit_T | SingleTimeUnit_T] = Undefined, utc: Optional[bool] = Undefined, - **kwds, ) -> Latitude2: ... - - @overload - def title(self, _: str, **kwds) -> Latitude2: ... - - @overload - def title(self, _: list[str], **kwds) -> Latitude2: ... - @overload - def title(self, _: None, **kwds) -> Latitude2: ... + def title(self, _: str | Sequence[str] | None, /) -> Latitude2: ... def __init__( self, @@ -7293,7 +6247,7 @@ def __init__( timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, **kwds, ): super().__init__( @@ -7319,9 +6273,9 @@ class Latitude2Datum(DatumChannelMixin, core.DatumDef): Relative position on a band of a stacked, binned, time unit, or band scale. For example, the marks will be positioned at the beginning of the band if set to ``0``, and at the middle of the band if set to ``0.5``. - datum : str, bool, dict, None, float, :class:`ExprRef`, :class:`DateTime`, :class:`RepeatRef`, :class:`PrimitiveValue` + datum : str, bool, dict, float, :class:`ExprRef`, :class:`DateTime`, :class:`RepeatRef`, :class:`PrimitiveValue`, None A constant value in data domain. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -7413,25 +6367,17 @@ class Latitude2Datum(DatumChannelMixin, core.DatumDef): _encoding_name = "latitude2" @overload - def bandPosition(self, _: float, **kwds) -> Latitude2Datum: ... - - @overload - def title(self, _: str, **kwds) -> Latitude2Datum: ... - - @overload - def title(self, _: list[str], **kwds) -> Latitude2Datum: ... - + def bandPosition(self, _: float, /) -> Latitude2Datum: ... @overload - def title(self, _: None, **kwds) -> Latitude2Datum: ... - + def title(self, _: str | Sequence[str] | None, /) -> Latitude2Datum: ... @overload - def type(self, _: Type_T, **kwds) -> Latitude2Datum: ... + def type(self, _: Type_T, /) -> Latitude2Datum: ... def __init__( self, datum, bandPosition: Optional[float] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | Type_T] = Undefined, **kwds, ): @@ -7529,7 +6475,7 @@ class Longitude(FieldChannelMixin, core.LatLongFieldDef): **See also:** `timeUnit `__ documentation. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -7621,112 +6567,47 @@ class Longitude(FieldChannelMixin, core.LatLongFieldDef): _encoding_name = "longitude" @overload - def aggregate(self, _: NonArgAggregateOp_T, **kwds) -> Longitude: ... - + def aggregate(self, _: NonArgAggregateOp_T, /) -> Longitude: ... @overload def aggregate( - self, argmax: Optional[str | SchemaBase] = Undefined, **kwds + self, *, argmax: Optional[str | SchemaBase] = Undefined ) -> Longitude: ... - @overload def aggregate( - self, argmin: Optional[str | SchemaBase] = Undefined, **kwds + self, *, argmin: Optional[str | SchemaBase] = Undefined ) -> Longitude: ... - @overload - def bandPosition(self, _: float, **kwds) -> Longitude: ... - + def bandPosition(self, _: float, /) -> Longitude: ... @overload - def bin(self, _: None, **kwds) -> Longitude: ... - + def bin(self, _: None, /) -> Longitude: ... @overload - def field(self, _: str, **kwds) -> Longitude: ... - + def field(self, _: str | RepeatRef, /) -> Longitude: ... @overload def field( self, + *, repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined, - **kwds, - ) -> Longitude: ... - - @overload - def timeUnit(self, _: LocalSingleTimeUnit_T, **kwds) -> Longitude: ... - - @overload - def timeUnit(self, _: UtcSingleTimeUnit_T, **kwds) -> Longitude: ... - - @overload - def timeUnit(self, _: LocalMultiTimeUnit_T, **kwds) -> Longitude: ... - - @overload - def timeUnit(self, _: UtcMultiTimeUnit_T, **kwds) -> Longitude: ... - - @overload - def timeUnit( - self, - _: Literal[ - "binnedyear", - "binnedyearquarter", - "binnedyearquartermonth", - "binnedyearmonth", - "binnedyearmonthdate", - "binnedyearmonthdatehours", - "binnedyearmonthdatehoursminutes", - "binnedyearmonthdatehoursminutesseconds", - "binnedyearweek", - "binnedyearweekday", - "binnedyearweekdayhours", - "binnedyearweekdayhoursminutes", - "binnedyearweekdayhoursminutesseconds", - "binnedyeardayofyear", - ], - **kwds, ) -> Longitude: ... - @overload def timeUnit( self, - _: Literal[ - "binnedutcyear", - "binnedutcyearquarter", - "binnedutcyearquartermonth", - "binnedutcyearmonth", - "binnedutcyearmonthdate", - "binnedutcyearmonthdatehours", - "binnedutcyearmonthdatehoursminutes", - "binnedutcyearmonthdatehoursminutesseconds", - "binnedutcyearweek", - "binnedutcyearweekday", - "binnedutcyearweekdayhours", - "binnedutcyearweekdayhoursminutes", - "binnedutcyearweekdayhoursminutesseconds", - "binnedutcyeardayofyear", - ], - **kwds, + _: TimeUnitParams | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T, + /, ) -> Longitude: ... - @overload def timeUnit( self, + *, binned: Optional[bool] = Undefined, maxbins: Optional[float] = Undefined, step: Optional[float] = Undefined, unit: Optional[SchemaBase | MultiTimeUnit_T | SingleTimeUnit_T] = Undefined, utc: Optional[bool] = Undefined, - **kwds, ) -> Longitude: ... - - @overload - def title(self, _: str, **kwds) -> Longitude: ... - - @overload - def title(self, _: list[str], **kwds) -> Longitude: ... - @overload - def title(self, _: None, **kwds) -> Longitude: ... - + def title(self, _: str | Sequence[str] | None, /) -> Longitude: ... @overload - def type(self, _: Literal["quantitative"], **kwds) -> Longitude: ... + def type(self, _: Literal["quantitative"], /) -> Longitude: ... def __init__( self, @@ -7738,7 +6619,7 @@ def __init__( timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[Literal["quantitative"]] = Undefined, **kwds, ): @@ -7766,9 +6647,9 @@ class LongitudeDatum(DatumChannelMixin, core.DatumDef): Relative position on a band of a stacked, binned, time unit, or band scale. For example, the marks will be positioned at the beginning of the band if set to ``0``, and at the middle of the band if set to ``0.5``. - datum : str, bool, dict, None, float, :class:`ExprRef`, :class:`DateTime`, :class:`RepeatRef`, :class:`PrimitiveValue` + datum : str, bool, dict, float, :class:`ExprRef`, :class:`DateTime`, :class:`RepeatRef`, :class:`PrimitiveValue`, None A constant value in data domain. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -7860,25 +6741,17 @@ class LongitudeDatum(DatumChannelMixin, core.DatumDef): _encoding_name = "longitude" @overload - def bandPosition(self, _: float, **kwds) -> LongitudeDatum: ... - - @overload - def title(self, _: str, **kwds) -> LongitudeDatum: ... - - @overload - def title(self, _: list[str], **kwds) -> LongitudeDatum: ... - + def bandPosition(self, _: float, /) -> LongitudeDatum: ... @overload - def title(self, _: None, **kwds) -> LongitudeDatum: ... - + def title(self, _: str | Sequence[str] | None, /) -> LongitudeDatum: ... @overload - def type(self, _: Type_T, **kwds) -> LongitudeDatum: ... + def type(self, _: Type_T, /) -> LongitudeDatum: ... def __init__( self, datum, bandPosition: Optional[float] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | Type_T] = Undefined, **kwds, ): @@ -7956,7 +6829,7 @@ class Longitude2(FieldChannelMixin, core.SecondaryFieldDef): **See also:** `timeUnit `__ documentation. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -7982,109 +6855,45 @@ class Longitude2(FieldChannelMixin, core.SecondaryFieldDef): _encoding_name = "longitude2" @overload - def aggregate(self, _: NonArgAggregateOp_T, **kwds) -> Longitude2: ... - + def aggregate(self, _: NonArgAggregateOp_T, /) -> Longitude2: ... @overload def aggregate( - self, argmax: Optional[str | SchemaBase] = Undefined, **kwds + self, *, argmax: Optional[str | SchemaBase] = Undefined ) -> Longitude2: ... - @overload def aggregate( - self, argmin: Optional[str | SchemaBase] = Undefined, **kwds + self, *, argmin: Optional[str | SchemaBase] = Undefined ) -> Longitude2: ... - @overload - def bandPosition(self, _: float, **kwds) -> Longitude2: ... - + def bandPosition(self, _: float, /) -> Longitude2: ... @overload - def bin(self, _: None, **kwds) -> Longitude2: ... - + def bin(self, _: None, /) -> Longitude2: ... @overload - def field(self, _: str, **kwds) -> Longitude2: ... - + def field(self, _: str | RepeatRef, /) -> Longitude2: ... @overload def field( self, + *, repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined, - **kwds, - ) -> Longitude2: ... - - @overload - def timeUnit(self, _: LocalSingleTimeUnit_T, **kwds) -> Longitude2: ... - - @overload - def timeUnit(self, _: UtcSingleTimeUnit_T, **kwds) -> Longitude2: ... - - @overload - def timeUnit(self, _: LocalMultiTimeUnit_T, **kwds) -> Longitude2: ... - - @overload - def timeUnit(self, _: UtcMultiTimeUnit_T, **kwds) -> Longitude2: ... - - @overload - def timeUnit( - self, - _: Literal[ - "binnedyear", - "binnedyearquarter", - "binnedyearquartermonth", - "binnedyearmonth", - "binnedyearmonthdate", - "binnedyearmonthdatehours", - "binnedyearmonthdatehoursminutes", - "binnedyearmonthdatehoursminutesseconds", - "binnedyearweek", - "binnedyearweekday", - "binnedyearweekdayhours", - "binnedyearweekdayhoursminutes", - "binnedyearweekdayhoursminutesseconds", - "binnedyeardayofyear", - ], - **kwds, ) -> Longitude2: ... - @overload def timeUnit( self, - _: Literal[ - "binnedutcyear", - "binnedutcyearquarter", - "binnedutcyearquartermonth", - "binnedutcyearmonth", - "binnedutcyearmonthdate", - "binnedutcyearmonthdatehours", - "binnedutcyearmonthdatehoursminutes", - "binnedutcyearmonthdatehoursminutesseconds", - "binnedutcyearweek", - "binnedutcyearweekday", - "binnedutcyearweekdayhours", - "binnedutcyearweekdayhoursminutes", - "binnedutcyearweekdayhoursminutesseconds", - "binnedutcyeardayofyear", - ], - **kwds, + _: TimeUnitParams | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T, + /, ) -> Longitude2: ... - @overload def timeUnit( self, + *, binned: Optional[bool] = Undefined, maxbins: Optional[float] = Undefined, step: Optional[float] = Undefined, unit: Optional[SchemaBase | MultiTimeUnit_T | SingleTimeUnit_T] = Undefined, utc: Optional[bool] = Undefined, - **kwds, ) -> Longitude2: ... - - @overload - def title(self, _: str, **kwds) -> Longitude2: ... - @overload - def title(self, _: list[str], **kwds) -> Longitude2: ... - - @overload - def title(self, _: None, **kwds) -> Longitude2: ... + def title(self, _: str | Sequence[str] | None, /) -> Longitude2: ... def __init__( self, @@ -8096,7 +6905,7 @@ def __init__( timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, **kwds, ): super().__init__( @@ -8122,9 +6931,9 @@ class Longitude2Datum(DatumChannelMixin, core.DatumDef): Relative position on a band of a stacked, binned, time unit, or band scale. For example, the marks will be positioned at the beginning of the band if set to ``0``, and at the middle of the band if set to ``0.5``. - datum : str, bool, dict, None, float, :class:`ExprRef`, :class:`DateTime`, :class:`RepeatRef`, :class:`PrimitiveValue` + datum : str, bool, dict, float, :class:`ExprRef`, :class:`DateTime`, :class:`RepeatRef`, :class:`PrimitiveValue`, None A constant value in data domain. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -8216,25 +7025,17 @@ class Longitude2Datum(DatumChannelMixin, core.DatumDef): _encoding_name = "longitude2" @overload - def bandPosition(self, _: float, **kwds) -> Longitude2Datum: ... - - @overload - def title(self, _: str, **kwds) -> Longitude2Datum: ... - - @overload - def title(self, _: list[str], **kwds) -> Longitude2Datum: ... - + def bandPosition(self, _: float, /) -> Longitude2Datum: ... @overload - def title(self, _: None, **kwds) -> Longitude2Datum: ... - + def title(self, _: str | Sequence[str] | None, /) -> Longitude2Datum: ... @overload - def type(self, _: Type_T, **kwds) -> Longitude2Datum: ... + def type(self, _: Type_T, /) -> Longitude2Datum: ... def __init__( self, datum, bandPosition: Optional[float] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | Type_T] = Undefined, **kwds, ): @@ -8289,7 +7090,7 @@ class Opacity( Relative position on a band of a stacked, binned, time unit, or band scale. For example, the marks will be positioned at the beginning of the band if set to ``0``, and at the middle of the band if set to ``0.5``. - bin : bool, dict, None, :class:`BinParams` + bin : bool, dict, :class:`BinParams`, None A flag for binning a ``quantitative`` field, `an object defining binning parameters `__, or indicating that the data for ``x`` or ``y`` channel are binned before they are imported into @@ -8332,7 +7133,7 @@ class Opacity( about escaping in the `field documentation `__. 2) ``field`` is not required if ``aggregate`` is ``count``. - legend : dict, None, :class:`Legend` + legend : dict, :class:`Legend`, None An object defining properties of the legend. If ``null``, the legend for the encoding channel will be removed. @@ -8341,7 +7142,7 @@ class Opacity( **See also:** `legend `__ documentation. - scale : dict, None, :class:`Scale` + scale : dict, :class:`Scale`, None An object defining properties of the channel's scale, which is the function that transforms values in the data domain (numbers, dates, strings, etc) to visual values (pixels, colors, sizes) of the encoding channels. @@ -8354,7 +7155,7 @@ class Opacity( **See also:** `scale `__ documentation. - sort : dict, None, :class:`Sort`, Sequence[str], Sequence[bool], Sequence[float], :class:`SortArray`, :class:`SortOrder`, :class:`AllSortString`, :class:`SortByChannel`, :class:`SortByEncoding`, :class:`EncodingSortField`, :class:`SortByChannelDesc`, Sequence[dict, :class:`DateTime`], Literal['-x', '-y', '-color', '-fill', '-stroke', '-strokeWidth', '-size', '-shape', '-fillOpacity', '-strokeOpacity', '-opacity', '-text', 'ascending', 'descending', 'x', 'y', 'color', 'fill', 'stroke', 'strokeWidth', 'size', 'shape', 'fillOpacity', 'strokeOpacity', 'opacity', 'text'] + sort : dict, :class:`Sort`, Sequence[str], Sequence[bool], Sequence[float], :class:`SortArray`, :class:`SortOrder`, :class:`AllSortString`, :class:`SortByChannel`, :class:`SortByEncoding`, :class:`EncodingSortField`, :class:`SortByChannelDesc`, Sequence[dict, :class:`DateTime`], Literal['-x', '-y', '-color', '-fill', '-stroke', '-strokeWidth', '-size', '-shape', '-fillOpacity', '-strokeOpacity', '-opacity', '-text', 'ascending', 'descending', 'x', 'y', 'color', 'fill', 'stroke', 'strokeWidth', 'size', 'shape', 'fillOpacity', 'strokeOpacity', 'opacity', 'text'], None Sort order for the encoded field. For continuous fields (quantitative or temporal), ``sort`` can be either @@ -8401,7 +7202,7 @@ class Opacity( **See also:** `timeUnit `__ documentation. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -8493,27 +7294,23 @@ class Opacity( _encoding_name = "opacity" @overload - def aggregate(self, _: NonArgAggregateOp_T, **kwds) -> Opacity: ... - + def aggregate(self, _: NonArgAggregateOp_T, /) -> Opacity: ... @overload def aggregate( - self, argmax: Optional[str | SchemaBase] = Undefined, **kwds + self, *, argmax: Optional[str | SchemaBase] = Undefined ) -> Opacity: ... - @overload def aggregate( - self, argmin: Optional[str | SchemaBase] = Undefined, **kwds + self, *, argmin: Optional[str | SchemaBase] = Undefined ) -> Opacity: ... - @overload - def bandPosition(self, _: float, **kwds) -> Opacity: ... - + def bandPosition(self, _: float, /) -> Opacity: ... @overload - def bin(self, _: bool, **kwds) -> Opacity: ... - + def bin(self, _: bool | Bin | None, /) -> Opacity: ... @overload def bin( self, + *, anchor: Optional[float] = Undefined, base: Optional[float] = Undefined, binned: Optional[bool] = Undefined, @@ -8524,47 +7321,40 @@ def bin( nice: Optional[bool] = Undefined, step: Optional[float] = Undefined, steps: Optional[Sequence[float]] = Undefined, - **kwds, ) -> Opacity: ... - - @overload - def bin(self, _: None, **kwds) -> Opacity: ... - @overload def condition( self, + *, test: Optional[str | SchemaBase | Map] = Undefined, value: Optional[float | Parameter | SchemaBase | Map] = Undefined, - **kwds, ) -> Opacity: ... - @overload def condition( self, + *, empty: Optional[bool] = Undefined, param: Optional[str | SchemaBase] = Undefined, value: Optional[float | Parameter | SchemaBase | Map] = Undefined, - **kwds, ) -> Opacity: ... - @overload def condition( - self, _: list[core.ConditionalValueDefnumberExprRef], **kwds + self, _: list[core.ConditionalValueDefnumberExprRef], / ) -> Opacity: ... - @overload - def field(self, _: str, **kwds) -> Opacity: ... - + def field(self, _: str | RepeatRef, /) -> Opacity: ... @overload def field( self, + *, repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined, - **kwds, ) -> Opacity: ... - + @overload + def legend(self, _: Legend | None, /) -> Opacity: ... @overload def legend( self, + *, aria: Optional[bool | Parameter | SchemaBase | Map] = Undefined, clipHeight: Optional[float | Parameter | SchemaBase | Map] = Undefined, columnPadding: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -8573,14 +7363,14 @@ def legend( description: Optional[str | Parameter | SchemaBase | Map] = Undefined, direction: Optional[SchemaBase | Orientation_T] = Undefined, fillColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, format: Optional[str | SchemaBase | Map] = Undefined, formatType: Optional[str] = Undefined, gradientLength: Optional[float | Parameter | SchemaBase | Map] = Undefined, gradientOpacity: Optional[float | Parameter | SchemaBase | Map] = Undefined, gradientStrokeColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, gradientStrokeWidth: Optional[float | Parameter | SchemaBase | Map] = Undefined, gradientThickness: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -8590,7 +7380,7 @@ def legend( Parameter | SchemaBase | Map | TextBaseline_T ] = Undefined, labelColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, labelExpr: Optional[str] = Undefined, labelFont: Optional[str | Parameter | SchemaBase | Map] = Undefined, @@ -8614,21 +7404,21 @@ def legend( padding: Optional[float | Parameter | SchemaBase | Map] = Undefined, rowPadding: Optional[float | Parameter | SchemaBase | Map] = Undefined, strokeColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, symbolDash: Optional[ Parameter | SchemaBase | Sequence[float] | Map ] = Undefined, symbolDashOffset: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolFillColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, symbolLimit: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolOffset: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolOpacity: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolSize: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolStrokeColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, symbolStrokeWidth: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolType: Optional[str | Parameter | SchemaBase | Map] = Undefined, @@ -8636,14 +7426,14 @@ def legend( float | Parameter | SchemaBase | Map | TimeInterval_T ] = Undefined, tickMinStep: Optional[float | Parameter | SchemaBase | Map] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, titleAlign: Optional[Parameter | SchemaBase | Map | Align_T] = Undefined, titleAnchor: Optional[Parameter | SchemaBase | Map | TitleAnchor_T] = Undefined, titleBaseline: Optional[ Parameter | SchemaBase | Map | TextBaseline_T ] = Undefined, titleColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, titleFont: Optional[str | Parameter | SchemaBase | Map] = Undefined, titleFontSize: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -8663,19 +7453,17 @@ def legend( | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map ] = Undefined, zindex: Optional[float] = Undefined, - **kwds, ) -> Opacity: ... - @overload - def legend(self, _: None, **kwds) -> Opacity: ... - + def scale(self, _: Scale | None, /) -> Opacity: ... @overload def scale( self, + *, align: Optional[float | Parameter | SchemaBase | Map] = Undefined, base: Optional[float | Parameter | SchemaBase | Map] = Undefined, bins: Optional[SchemaBase | Sequence[float] | Map] = Undefined, @@ -8685,12 +7473,18 @@ def scale( Parameter | SchemaBase | Literal["unaggregated"] - | Sequence[str | bool | None | float | Parameter | SchemaBase | Map] + | Sequence[ + str | bool | float | Temporal | Parameter | SchemaBase | Map | None + ] | Map ] = Undefined, - domainMax: Optional[float | Parameter | SchemaBase | Map] = Undefined, + domainMax: Optional[ + float | Temporal | Parameter | SchemaBase | Map + ] = Undefined, domainMid: Optional[float | Parameter | SchemaBase | Map] = Undefined, - domainMin: Optional[float | Parameter | SchemaBase | Map] = Undefined, + domainMin: Optional[ + float | Temporal | Parameter | SchemaBase | Map + ] = Undefined, domainRaw: Optional[Parameter | SchemaBase | Map] = Undefined, exponent: Optional[float | Parameter | SchemaBase | Map] = Undefined, interpolate: Optional[ @@ -8715,156 +7509,78 @@ def scale( scheme: Optional[Parameter | SchemaBase | Map | ColorScheme_T] = Undefined, type: Optional[SchemaBase | ScaleType_T] = Undefined, zero: Optional[bool | Parameter | SchemaBase | Map] = Undefined, - **kwds, ) -> Opacity: ... - - @overload - def scale(self, _: None, **kwds) -> Opacity: ... - - @overload - def sort(self, _: list[float], **kwds) -> Opacity: ... - - @overload - def sort(self, _: list[str], **kwds) -> Opacity: ... - @overload - def sort(self, _: list[bool], **kwds) -> Opacity: ... - - @overload - def sort(self, _: list[core.DateTime], **kwds) -> Opacity: ... - - @overload - def sort(self, _: SortOrder_T, **kwds) -> Opacity: ... - - @overload - def sort(self, _: SortByChannel_T, **kwds) -> Opacity: ... - - @overload - def sort(self, _: SortByChannelDesc_T, **kwds) -> Opacity: ... - + def sort( + self, + _: Sequence[str] + | Sequence[bool] + | Sequence[float] + | Sequence[DateTime | Temporal] + | AllSortString_T + | None, + /, + ) -> Opacity: ... @overload def sort( self, + *, field: Optional[str | SchemaBase | Map] = Undefined, op: Optional[SchemaBase | NonArgAggregateOp_T] = Undefined, - order: Optional[None | SchemaBase | SortOrder_T] = Undefined, - **kwds, + order: Optional[SchemaBase | SortOrder_T | None] = Undefined, ) -> Opacity: ... - @overload def sort( self, + *, encoding: Optional[SchemaBase | SortByChannel_T] = Undefined, - order: Optional[None | SchemaBase | SortOrder_T] = Undefined, - **kwds, - ) -> Opacity: ... - - @overload - def sort(self, _: None, **kwds) -> Opacity: ... - - @overload - def timeUnit(self, _: LocalSingleTimeUnit_T, **kwds) -> Opacity: ... - - @overload - def timeUnit(self, _: UtcSingleTimeUnit_T, **kwds) -> Opacity: ... - - @overload - def timeUnit(self, _: LocalMultiTimeUnit_T, **kwds) -> Opacity: ... - - @overload - def timeUnit(self, _: UtcMultiTimeUnit_T, **kwds) -> Opacity: ... - - @overload - def timeUnit( - self, - _: Literal[ - "binnedyear", - "binnedyearquarter", - "binnedyearquartermonth", - "binnedyearmonth", - "binnedyearmonthdate", - "binnedyearmonthdatehours", - "binnedyearmonthdatehoursminutes", - "binnedyearmonthdatehoursminutesseconds", - "binnedyearweek", - "binnedyearweekday", - "binnedyearweekdayhours", - "binnedyearweekdayhoursminutes", - "binnedyearweekdayhoursminutesseconds", - "binnedyeardayofyear", - ], - **kwds, + order: Optional[SchemaBase | SortOrder_T | None] = Undefined, ) -> Opacity: ... - @overload def timeUnit( self, - _: Literal[ - "binnedutcyear", - "binnedutcyearquarter", - "binnedutcyearquartermonth", - "binnedutcyearmonth", - "binnedutcyearmonthdate", - "binnedutcyearmonthdatehours", - "binnedutcyearmonthdatehoursminutes", - "binnedutcyearmonthdatehoursminutesseconds", - "binnedutcyearweek", - "binnedutcyearweekday", - "binnedutcyearweekdayhours", - "binnedutcyearweekdayhoursminutes", - "binnedutcyearweekdayhoursminutesseconds", - "binnedutcyeardayofyear", - ], - **kwds, + _: TimeUnitParams | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T, + /, ) -> Opacity: ... - @overload def timeUnit( self, + *, binned: Optional[bool] = Undefined, maxbins: Optional[float] = Undefined, step: Optional[float] = Undefined, unit: Optional[SchemaBase | MultiTimeUnit_T | SingleTimeUnit_T] = Undefined, utc: Optional[bool] = Undefined, - **kwds, ) -> Opacity: ... - - @overload - def title(self, _: str, **kwds) -> Opacity: ... - - @overload - def title(self, _: list[str], **kwds) -> Opacity: ... - @overload - def title(self, _: None, **kwds) -> Opacity: ... - + def title(self, _: str | Sequence[str] | None, /) -> Opacity: ... @overload - def type(self, _: StandardType_T, **kwds) -> Opacity: ... + def type(self, _: StandardType_T, /) -> Opacity: ... def __init__( self, shorthand: Optional[str | SchemaBase | Sequence[str] | Map] = Undefined, aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Map] = Undefined, + bin: Optional[bool | SchemaBase | Map | None] = Undefined, condition: Optional[SchemaBase | Sequence[SchemaBase | Map] | Map] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, sort: Optional[ - None - | SchemaBase + SchemaBase | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map | AllSortString_T + | None ] = Undefined, timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, **kwds, ): @@ -8903,9 +7619,9 @@ class OpacityDatum(DatumChannelMixin, core.FieldOrDatumDefWithConditionDatumDefn **Note:** A field definition's ``condition`` property can only contain `conditional value definitions `__ since Vega-Lite only allows at most one encoded field per encoding channel. - datum : str, bool, dict, None, float, :class:`ExprRef`, :class:`DateTime`, :class:`RepeatRef`, :class:`PrimitiveValue` + datum : str, bool, dict, float, :class:`ExprRef`, :class:`DateTime`, :class:`RepeatRef`, :class:`PrimitiveValue`, None A constant value in data domain. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -8997,48 +7713,37 @@ class OpacityDatum(DatumChannelMixin, core.FieldOrDatumDefWithConditionDatumDefn _encoding_name = "opacity" @overload - def bandPosition(self, _: float, **kwds) -> OpacityDatum: ... - + def bandPosition(self, _: float, /) -> OpacityDatum: ... @overload def condition( self, + *, test: Optional[str | SchemaBase | Map] = Undefined, value: Optional[float | Parameter | SchemaBase | Map] = Undefined, - **kwds, ) -> OpacityDatum: ... - @overload def condition( self, + *, empty: Optional[bool] = Undefined, param: Optional[str | SchemaBase] = Undefined, value: Optional[float | Parameter | SchemaBase | Map] = Undefined, - **kwds, ) -> OpacityDatum: ... - @overload def condition( - self, _: list[core.ConditionalValueDefnumberExprRef], **kwds + self, _: list[core.ConditionalValueDefnumberExprRef], / ) -> OpacityDatum: ... - - @overload - def title(self, _: str, **kwds) -> OpacityDatum: ... - - @overload - def title(self, _: list[str], **kwds) -> OpacityDatum: ... - @overload - def title(self, _: None, **kwds) -> OpacityDatum: ... - + def title(self, _: str | Sequence[str] | None, /) -> OpacityDatum: ... @overload - def type(self, _: Type_T, **kwds) -> OpacityDatum: ... + def type(self, _: Type_T, /) -> OpacityDatum: ... def __init__( self, datum, bandPosition: Optional[float] = Undefined, condition: Optional[SchemaBase | Sequence[SchemaBase | Map] | Map] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | Type_T] = Undefined, **kwds, ): @@ -9075,111 +7780,105 @@ class OpacityValue( @overload def condition( self, + *, aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Map] = Undefined, + bin: Optional[bool | SchemaBase | Map | None] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, sort: Optional[ - None - | SchemaBase + SchemaBase | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map | AllSortString_T + | None ] = Undefined, test: Optional[str | SchemaBase | Map] = Undefined, timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, - **kwds, ) -> OpacityValue: ... - @overload def condition( self, + *, bandPosition: Optional[float] = Undefined, datum: Optional[ - str | bool | None | float | Parameter | SchemaBase | Map + Temporal | Parameter | SchemaBase | Map | PrimitiveValue_T ] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, test: Optional[str | SchemaBase | Map] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | Type_T] = Undefined, - **kwds, ) -> OpacityValue: ... - @overload def condition( self, + *, aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Map] = Undefined, + bin: Optional[bool | SchemaBase | Map | None] = Undefined, empty: Optional[bool] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, param: Optional[str | SchemaBase] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, sort: Optional[ - None - | SchemaBase + SchemaBase | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map | AllSortString_T + | None ] = Undefined, timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, - **kwds, ) -> OpacityValue: ... - @overload def condition( self, + *, bandPosition: Optional[float] = Undefined, datum: Optional[ - str | bool | None | float | Parameter | SchemaBase | Map + Temporal | Parameter | SchemaBase | Map | PrimitiveValue_T ] = Undefined, empty: Optional[bool] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, param: Optional[str | SchemaBase] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | Type_T] = Undefined, - **kwds, ) -> OpacityValue: ... - @overload def condition( self, + *, test: Optional[str | SchemaBase | Map] = Undefined, value: Optional[float | Parameter | SchemaBase | Map] = Undefined, - **kwds, ) -> OpacityValue: ... - @overload def condition( self, + *, empty: Optional[bool] = Undefined, param: Optional[str | SchemaBase] = Undefined, value: Optional[float | Parameter | SchemaBase | Map] = Undefined, - **kwds, ) -> OpacityValue: ... - @overload def condition( - self, _: list[core.ConditionalValueDefnumberExprRef], **kwds + self, _: list[core.ConditionalValueDefnumberExprRef], / ) -> OpacityValue: ... def __init__( @@ -9212,7 +7911,7 @@ class Order(FieldChannelMixin, core.OrderFieldDef): Relative position on a band of a stacked, binned, time unit, or band scale. For example, the marks will be positioned at the beginning of the band if set to ``0``, and at the middle of the band if set to ``0.5``. - bin : bool, dict, None, Literal['binned'], :class:`BinParams` + bin : bool, dict, Literal['binned'], :class:`BinParams`, None A flag for binning a ``quantitative`` field, `an object defining binning parameters `__, or indicating that the data for ``x`` or ``y`` channel are binned before they are imported into @@ -9259,7 +7958,7 @@ class Order(FieldChannelMixin, core.OrderFieldDef): **See also:** `timeUnit `__ documentation. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -9351,27 +8050,19 @@ class Order(FieldChannelMixin, core.OrderFieldDef): _encoding_name = "order" @overload - def aggregate(self, _: NonArgAggregateOp_T, **kwds) -> Order: ... - + def aggregate(self, _: NonArgAggregateOp_T, /) -> Order: ... @overload - def aggregate( - self, argmax: Optional[str | SchemaBase] = Undefined, **kwds - ) -> Order: ... - + def aggregate(self, *, argmax: Optional[str | SchemaBase] = Undefined) -> Order: ... @overload - def aggregate( - self, argmin: Optional[str | SchemaBase] = Undefined, **kwds - ) -> Order: ... - + def aggregate(self, *, argmin: Optional[str | SchemaBase] = Undefined) -> Order: ... @overload - def bandPosition(self, _: float, **kwds) -> Order: ... - + def bandPosition(self, _: float, /) -> Order: ... @overload - def bin(self, _: bool, **kwds) -> Order: ... - + def bin(self, _: bool | Bin | Literal["binned"] | None, /) -> Order: ... @overload def bin( self, + *, anchor: Optional[float] = Undefined, base: Optional[float] = Undefined, binned: Optional[bool] = Undefined, @@ -9382,119 +8073,50 @@ def bin( nice: Optional[bool] = Undefined, step: Optional[float] = Undefined, steps: Optional[Sequence[float]] = Undefined, - **kwds, ) -> Order: ... - - @overload - def bin(self, _: Literal["binned"], **kwds) -> Order: ... - - @overload - def bin(self, _: None, **kwds) -> Order: ... - @overload - def field(self, _: str, **kwds) -> Order: ... - + def field(self, _: str | RepeatRef, /) -> Order: ... @overload def field( self, + *, repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined, - **kwds, ) -> Order: ... - - @overload - def sort(self, _: SortOrder_T, **kwds) -> Order: ... - - @overload - def timeUnit(self, _: LocalSingleTimeUnit_T, **kwds) -> Order: ... - - @overload - def timeUnit(self, _: UtcSingleTimeUnit_T, **kwds) -> Order: ... - - @overload - def timeUnit(self, _: LocalMultiTimeUnit_T, **kwds) -> Order: ... - @overload - def timeUnit(self, _: UtcMultiTimeUnit_T, **kwds) -> Order: ... - - @overload - def timeUnit( - self, - _: Literal[ - "binnedyear", - "binnedyearquarter", - "binnedyearquartermonth", - "binnedyearmonth", - "binnedyearmonthdate", - "binnedyearmonthdatehours", - "binnedyearmonthdatehoursminutes", - "binnedyearmonthdatehoursminutesseconds", - "binnedyearweek", - "binnedyearweekday", - "binnedyearweekdayhours", - "binnedyearweekdayhoursminutes", - "binnedyearweekdayhoursminutesseconds", - "binnedyeardayofyear", - ], - **kwds, - ) -> Order: ... - + def sort(self, _: SortOrder_T, /) -> Order: ... @overload def timeUnit( self, - _: Literal[ - "binnedutcyear", - "binnedutcyearquarter", - "binnedutcyearquartermonth", - "binnedutcyearmonth", - "binnedutcyearmonthdate", - "binnedutcyearmonthdatehours", - "binnedutcyearmonthdatehoursminutes", - "binnedutcyearmonthdatehoursminutesseconds", - "binnedutcyearweek", - "binnedutcyearweekday", - "binnedutcyearweekdayhours", - "binnedutcyearweekdayhoursminutes", - "binnedutcyearweekdayhoursminutesseconds", - "binnedutcyeardayofyear", - ], - **kwds, + _: TimeUnitParams | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T, + /, ) -> Order: ... - @overload def timeUnit( self, + *, binned: Optional[bool] = Undefined, maxbins: Optional[float] = Undefined, step: Optional[float] = Undefined, unit: Optional[SchemaBase | MultiTimeUnit_T | SingleTimeUnit_T] = Undefined, utc: Optional[bool] = Undefined, - **kwds, ) -> Order: ... - - @overload - def title(self, _: str, **kwds) -> Order: ... - - @overload - def title(self, _: list[str], **kwds) -> Order: ... - @overload - def title(self, _: None, **kwds) -> Order: ... - + def title(self, _: str | Sequence[str] | None, /) -> Order: ... @overload - def type(self, _: StandardType_T, **kwds) -> Order: ... + def type(self, _: StandardType_T, /) -> Order: ... def __init__( self, shorthand: Optional[str | SchemaBase | Sequence[str] | Map] = Undefined, aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Literal["binned"] | Map] = Undefined, + bin: Optional[bool | SchemaBase | Literal["binned"] | Map | None] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, sort: Optional[SchemaBase | SortOrder_T] = Undefined, timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, **kwds, ): @@ -9538,24 +8160,20 @@ class OrderValue(ValueChannelMixin, core.OrderValueDef): @overload def condition( self, + *, test: Optional[str | SchemaBase | Map] = Undefined, value: Optional[float] = Undefined, - **kwds, ) -> OrderValue: ... - @overload def condition( self, + *, empty: Optional[bool] = Undefined, param: Optional[str | SchemaBase] = Undefined, value: Optional[float] = Undefined, - **kwds, ) -> OrderValue: ... - @overload - def condition( - self, _: list[core.ConditionalValueDefnumber], **kwds - ) -> OrderValue: ... + def condition(self, _: list[core.ConditionalValueDefnumber], /) -> OrderValue: ... def __init__( self, @@ -9587,7 +8205,7 @@ class Radius(FieldChannelMixin, core.PositionFieldDefBase): Relative position on a band of a stacked, binned, time unit, or band scale. For example, the marks will be positioned at the beginning of the band if set to ``0``, and at the middle of the band if set to ``0.5``. - bin : bool, dict, None, Literal['binned'], :class:`BinParams` + bin : bool, dict, Literal['binned'], :class:`BinParams`, None A flag for binning a ``quantitative`` field, `an object defining binning parameters `__, or indicating that the data for ``x`` or ``y`` channel are binned before they are imported into @@ -9623,7 +8241,7 @@ class Radius(FieldChannelMixin, core.PositionFieldDefBase): about escaping in the `field documentation `__. 2) ``field`` is not required if ``aggregate`` is ``count``. - scale : dict, None, :class:`Scale` + scale : dict, :class:`Scale`, None An object defining properties of the channel's scale, which is the function that transforms values in the data domain (numbers, dates, strings, etc) to visual values (pixels, colors, sizes) of the encoding channels. @@ -9636,7 +8254,7 @@ class Radius(FieldChannelMixin, core.PositionFieldDefBase): **See also:** `scale `__ documentation. - sort : dict, None, :class:`Sort`, Sequence[str], Sequence[bool], Sequence[float], :class:`SortArray`, :class:`SortOrder`, :class:`AllSortString`, :class:`SortByChannel`, :class:`SortByEncoding`, :class:`EncodingSortField`, :class:`SortByChannelDesc`, Sequence[dict, :class:`DateTime`], Literal['-x', '-y', '-color', '-fill', '-stroke', '-strokeWidth', '-size', '-shape', '-fillOpacity', '-strokeOpacity', '-opacity', '-text', 'ascending', 'descending', 'x', 'y', 'color', 'fill', 'stroke', 'strokeWidth', 'size', 'shape', 'fillOpacity', 'strokeOpacity', 'opacity', 'text'] + sort : dict, :class:`Sort`, Sequence[str], Sequence[bool], Sequence[float], :class:`SortArray`, :class:`SortOrder`, :class:`AllSortString`, :class:`SortByChannel`, :class:`SortByEncoding`, :class:`EncodingSortField`, :class:`SortByChannelDesc`, Sequence[dict, :class:`DateTime`], Literal['-x', '-y', '-color', '-fill', '-stroke', '-strokeWidth', '-size', '-shape', '-fillOpacity', '-strokeOpacity', '-opacity', '-text', 'ascending', 'descending', 'x', 'y', 'color', 'fill', 'stroke', 'strokeWidth', 'size', 'shape', 'fillOpacity', 'strokeOpacity', 'opacity', 'text'], None Sort order for the encoded field. For continuous fields (quantitative or temporal), ``sort`` can be either @@ -9674,7 +8292,7 @@ class Radius(FieldChannelMixin, core.PositionFieldDefBase): **See also:** `sort `__ documentation. - stack : bool, None, :class:`StackOffset`, Literal['zero', 'center', 'normalize'] + stack : bool, :class:`StackOffset`, Literal['zero', 'center', 'normalize'], None Type of stacking offset if the field should be stacked. ``stack`` is only applicable for ``x``, ``y``, ``theta``, and ``radius`` channels with continuous domains. For example, ``stack`` of ``y`` can be used to customize stacking for a vertical bar @@ -9713,7 +8331,7 @@ class Radius(FieldChannelMixin, core.PositionFieldDefBase): **See also:** `timeUnit `__ documentation. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -9805,27 +8423,23 @@ class Radius(FieldChannelMixin, core.PositionFieldDefBase): _encoding_name = "radius" @overload - def aggregate(self, _: NonArgAggregateOp_T, **kwds) -> Radius: ... - + def aggregate(self, _: NonArgAggregateOp_T, /) -> Radius: ... @overload def aggregate( - self, argmax: Optional[str | SchemaBase] = Undefined, **kwds + self, *, argmax: Optional[str | SchemaBase] = Undefined ) -> Radius: ... - @overload def aggregate( - self, argmin: Optional[str | SchemaBase] = Undefined, **kwds + self, *, argmin: Optional[str | SchemaBase] = Undefined ) -> Radius: ... - @overload - def bandPosition(self, _: float, **kwds) -> Radius: ... - + def bandPosition(self, _: float, /) -> Radius: ... @overload - def bin(self, _: bool, **kwds) -> Radius: ... - + def bin(self, _: bool | Bin | Literal["binned"] | None, /) -> Radius: ... @overload def bin( self, + *, anchor: Optional[float] = Undefined, base: Optional[float] = Undefined, binned: Optional[bool] = Undefined, @@ -9836,28 +8450,21 @@ def bin( nice: Optional[bool] = Undefined, step: Optional[float] = Undefined, steps: Optional[Sequence[float]] = Undefined, - **kwds, ) -> Radius: ... - - @overload - def bin(self, _: Literal["binned"], **kwds) -> Radius: ... - - @overload - def bin(self, _: None, **kwds) -> Radius: ... - @overload - def field(self, _: str, **kwds) -> Radius: ... - + def field(self, _: str | RepeatRef, /) -> Radius: ... @overload def field( self, + *, repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined, - **kwds, ) -> Radius: ... - + @overload + def scale(self, _: Scale | None, /) -> Radius: ... @overload def scale( self, + *, align: Optional[float | Parameter | SchemaBase | Map] = Undefined, base: Optional[float | Parameter | SchemaBase | Map] = Undefined, bins: Optional[SchemaBase | Sequence[float] | Map] = Undefined, @@ -9867,12 +8474,18 @@ def scale( Parameter | SchemaBase | Literal["unaggregated"] - | Sequence[str | bool | None | float | Parameter | SchemaBase | Map] + | Sequence[ + str | bool | float | Temporal | Parameter | SchemaBase | Map | None + ] | Map ] = Undefined, - domainMax: Optional[float | Parameter | SchemaBase | Map] = Undefined, + domainMax: Optional[ + float | Temporal | Parameter | SchemaBase | Map + ] = Undefined, domainMid: Optional[float | Parameter | SchemaBase | Map] = Undefined, - domainMin: Optional[float | Parameter | SchemaBase | Map] = Undefined, + domainMin: Optional[ + float | Temporal | Parameter | SchemaBase | Map + ] = Undefined, domainRaw: Optional[Parameter | SchemaBase | Map] = Undefined, exponent: Optional[float | Parameter | SchemaBase | Map] = Undefined, interpolate: Optional[ @@ -9897,164 +8510,79 @@ def scale( scheme: Optional[Parameter | SchemaBase | Map | ColorScheme_T] = Undefined, type: Optional[SchemaBase | ScaleType_T] = Undefined, zero: Optional[bool | Parameter | SchemaBase | Map] = Undefined, - **kwds, ) -> Radius: ... - - @overload - def scale(self, _: None, **kwds) -> Radius: ... - - @overload - def sort(self, _: list[float], **kwds) -> Radius: ... - - @overload - def sort(self, _: list[str], **kwds) -> Radius: ... - @overload - def sort(self, _: list[bool], **kwds) -> Radius: ... - - @overload - def sort(self, _: list[core.DateTime], **kwds) -> Radius: ... - - @overload - def sort(self, _: SortOrder_T, **kwds) -> Radius: ... - - @overload - def sort(self, _: SortByChannel_T, **kwds) -> Radius: ... - - @overload - def sort(self, _: SortByChannelDesc_T, **kwds) -> Radius: ... - + def sort( + self, + _: Sequence[str] + | Sequence[bool] + | Sequence[float] + | Sequence[DateTime | Temporal] + | AllSortString_T + | None, + /, + ) -> Radius: ... @overload def sort( self, + *, field: Optional[str | SchemaBase | Map] = Undefined, op: Optional[SchemaBase | NonArgAggregateOp_T] = Undefined, - order: Optional[None | SchemaBase | SortOrder_T] = Undefined, - **kwds, + order: Optional[SchemaBase | SortOrder_T | None] = Undefined, ) -> Radius: ... - @overload def sort( self, + *, encoding: Optional[SchemaBase | SortByChannel_T] = Undefined, - order: Optional[None | SchemaBase | SortOrder_T] = Undefined, - **kwds, + order: Optional[SchemaBase | SortOrder_T | None] = Undefined, ) -> Radius: ... - - @overload - def sort(self, _: None, **kwds) -> Radius: ... - - @overload - def stack(self, _: StackOffset_T, **kwds) -> Radius: ... - - @overload - def stack(self, _: None, **kwds) -> Radius: ... - - @overload - def stack(self, _: bool, **kwds) -> Radius: ... - - @overload - def timeUnit(self, _: LocalSingleTimeUnit_T, **kwds) -> Radius: ... - - @overload - def timeUnit(self, _: UtcSingleTimeUnit_T, **kwds) -> Radius: ... - - @overload - def timeUnit(self, _: LocalMultiTimeUnit_T, **kwds) -> Radius: ... - - @overload - def timeUnit(self, _: UtcMultiTimeUnit_T, **kwds) -> Radius: ... - @overload - def timeUnit( - self, - _: Literal[ - "binnedyear", - "binnedyearquarter", - "binnedyearquartermonth", - "binnedyearmonth", - "binnedyearmonthdate", - "binnedyearmonthdatehours", - "binnedyearmonthdatehoursminutes", - "binnedyearmonthdatehoursminutesseconds", - "binnedyearweek", - "binnedyearweekday", - "binnedyearweekdayhours", - "binnedyearweekdayhoursminutes", - "binnedyearweekdayhoursminutesseconds", - "binnedyeardayofyear", - ], - **kwds, - ) -> Radius: ... - + def stack(self, _: bool | StackOffset_T | None, /) -> Radius: ... @overload def timeUnit( self, - _: Literal[ - "binnedutcyear", - "binnedutcyearquarter", - "binnedutcyearquartermonth", - "binnedutcyearmonth", - "binnedutcyearmonthdate", - "binnedutcyearmonthdatehours", - "binnedutcyearmonthdatehoursminutes", - "binnedutcyearmonthdatehoursminutesseconds", - "binnedutcyearweek", - "binnedutcyearweekday", - "binnedutcyearweekdayhours", - "binnedutcyearweekdayhoursminutes", - "binnedutcyearweekdayhoursminutesseconds", - "binnedutcyeardayofyear", - ], - **kwds, + _: TimeUnitParams | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T, + /, ) -> Radius: ... - @overload def timeUnit( self, + *, binned: Optional[bool] = Undefined, maxbins: Optional[float] = Undefined, step: Optional[float] = Undefined, unit: Optional[SchemaBase | MultiTimeUnit_T | SingleTimeUnit_T] = Undefined, utc: Optional[bool] = Undefined, - **kwds, ) -> Radius: ... - - @overload - def title(self, _: str, **kwds) -> Radius: ... - - @overload - def title(self, _: list[str], **kwds) -> Radius: ... - @overload - def title(self, _: None, **kwds) -> Radius: ... - + def title(self, _: str | Sequence[str] | None, /) -> Radius: ... @overload - def type(self, _: StandardType_T, **kwds) -> Radius: ... + def type(self, _: StandardType_T, /) -> Radius: ... def __init__( self, shorthand: Optional[str | SchemaBase | Sequence[str] | Map] = Undefined, aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Literal["binned"] | Map] = Undefined, + bin: Optional[bool | SchemaBase | Literal["binned"] | Map | None] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, sort: Optional[ - None - | SchemaBase + SchemaBase | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map | AllSortString_T + | None ] = Undefined, - stack: Optional[bool | None | SchemaBase | StackOffset_T] = Undefined, + stack: Optional[bool | SchemaBase | StackOffset_T | None] = Undefined, timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, **kwds, ): @@ -10085,9 +8613,9 @@ class RadiusDatum(DatumChannelMixin, core.PositionDatumDefBase): Relative position on a band of a stacked, binned, time unit, or band scale. For example, the marks will be positioned at the beginning of the band if set to ``0``, and at the middle of the band if set to ``0.5``. - datum : str, bool, dict, None, float, :class:`ExprRef`, :class:`DateTime`, :class:`RepeatRef`, :class:`PrimitiveValue` + datum : str, bool, dict, float, :class:`ExprRef`, :class:`DateTime`, :class:`RepeatRef`, :class:`PrimitiveValue`, None A constant value in data domain. - scale : dict, None, :class:`Scale` + scale : dict, :class:`Scale`, None An object defining properties of the channel's scale, which is the function that transforms values in the data domain (numbers, dates, strings, etc) to visual values (pixels, colors, sizes) of the encoding channels. @@ -10100,7 +8628,7 @@ class RadiusDatum(DatumChannelMixin, core.PositionDatumDefBase): **See also:** `scale `__ documentation. - stack : bool, None, :class:`StackOffset`, Literal['zero', 'center', 'normalize'] + stack : bool, :class:`StackOffset`, Literal['zero', 'center', 'normalize'], None Type of stacking offset if the field should be stacked. ``stack`` is only applicable for ``x``, ``y``, ``theta``, and ``radius`` channels with continuous domains. For example, ``stack`` of ``y`` can be used to customize stacking for a vertical bar @@ -10130,7 +8658,7 @@ class RadiusDatum(DatumChannelMixin, core.PositionDatumDefBase): **See also:** `stack `__ documentation. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -10222,11 +8750,13 @@ class RadiusDatum(DatumChannelMixin, core.PositionDatumDefBase): _encoding_name = "radius" @overload - def bandPosition(self, _: float, **kwds) -> RadiusDatum: ... - + def bandPosition(self, _: float, /) -> RadiusDatum: ... + @overload + def scale(self, _: Scale | None, /) -> RadiusDatum: ... @overload def scale( self, + *, align: Optional[float | Parameter | SchemaBase | Map] = Undefined, base: Optional[float | Parameter | SchemaBase | Map] = Undefined, bins: Optional[SchemaBase | Sequence[float] | Map] = Undefined, @@ -10236,12 +8766,18 @@ def scale( Parameter | SchemaBase | Literal["unaggregated"] - | Sequence[str | bool | None | float | Parameter | SchemaBase | Map] + | Sequence[ + str | bool | float | Temporal | Parameter | SchemaBase | Map | None + ] | Map ] = Undefined, - domainMax: Optional[float | Parameter | SchemaBase | Map] = Undefined, + domainMax: Optional[ + float | Temporal | Parameter | SchemaBase | Map + ] = Undefined, domainMid: Optional[float | Parameter | SchemaBase | Map] = Undefined, - domainMin: Optional[float | Parameter | SchemaBase | Map] = Undefined, + domainMin: Optional[ + float | Temporal | Parameter | SchemaBase | Map + ] = Undefined, domainRaw: Optional[Parameter | SchemaBase | Map] = Undefined, exponent: Optional[float | Parameter | SchemaBase | Map] = Undefined, interpolate: Optional[ @@ -10266,40 +8802,21 @@ def scale( scheme: Optional[Parameter | SchemaBase | Map | ColorScheme_T] = Undefined, type: Optional[SchemaBase | ScaleType_T] = Undefined, zero: Optional[bool | Parameter | SchemaBase | Map] = Undefined, - **kwds, ) -> RadiusDatum: ... - - @overload - def scale(self, _: None, **kwds) -> RadiusDatum: ... - - @overload - def stack(self, _: StackOffset_T, **kwds) -> RadiusDatum: ... - - @overload - def stack(self, _: None, **kwds) -> RadiusDatum: ... - - @overload - def stack(self, _: bool, **kwds) -> RadiusDatum: ... - - @overload - def title(self, _: str, **kwds) -> RadiusDatum: ... - @overload - def title(self, _: list[str], **kwds) -> RadiusDatum: ... - + def stack(self, _: bool | StackOffset_T | None, /) -> RadiusDatum: ... @overload - def title(self, _: None, **kwds) -> RadiusDatum: ... - + def title(self, _: str | Sequence[str] | None, /) -> RadiusDatum: ... @overload - def type(self, _: Type_T, **kwds) -> RadiusDatum: ... + def type(self, _: Type_T, /) -> RadiusDatum: ... def __init__( self, datum, bandPosition: Optional[float] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, - stack: Optional[bool | None | SchemaBase | StackOffset_T] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, + stack: Optional[bool | SchemaBase | StackOffset_T | None] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | Type_T] = Undefined, **kwds, ): @@ -10406,7 +8923,7 @@ class Radius2(FieldChannelMixin, core.SecondaryFieldDef): **See also:** `timeUnit `__ documentation. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -10432,109 +8949,45 @@ class Radius2(FieldChannelMixin, core.SecondaryFieldDef): _encoding_name = "radius2" @overload - def aggregate(self, _: NonArgAggregateOp_T, **kwds) -> Radius2: ... - + def aggregate(self, _: NonArgAggregateOp_T, /) -> Radius2: ... @overload def aggregate( - self, argmax: Optional[str | SchemaBase] = Undefined, **kwds + self, *, argmax: Optional[str | SchemaBase] = Undefined ) -> Radius2: ... - @overload def aggregate( - self, argmin: Optional[str | SchemaBase] = Undefined, **kwds + self, *, argmin: Optional[str | SchemaBase] = Undefined ) -> Radius2: ... - @overload - def bandPosition(self, _: float, **kwds) -> Radius2: ... - + def bandPosition(self, _: float, /) -> Radius2: ... @overload - def bin(self, _: None, **kwds) -> Radius2: ... - + def bin(self, _: None, /) -> Radius2: ... @overload - def field(self, _: str, **kwds) -> Radius2: ... - + def field(self, _: str | RepeatRef, /) -> Radius2: ... @overload def field( self, + *, repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined, - **kwds, - ) -> Radius2: ... - - @overload - def timeUnit(self, _: LocalSingleTimeUnit_T, **kwds) -> Radius2: ... - - @overload - def timeUnit(self, _: UtcSingleTimeUnit_T, **kwds) -> Radius2: ... - - @overload - def timeUnit(self, _: LocalMultiTimeUnit_T, **kwds) -> Radius2: ... - - @overload - def timeUnit(self, _: UtcMultiTimeUnit_T, **kwds) -> Radius2: ... - - @overload - def timeUnit( - self, - _: Literal[ - "binnedyear", - "binnedyearquarter", - "binnedyearquartermonth", - "binnedyearmonth", - "binnedyearmonthdate", - "binnedyearmonthdatehours", - "binnedyearmonthdatehoursminutes", - "binnedyearmonthdatehoursminutesseconds", - "binnedyearweek", - "binnedyearweekday", - "binnedyearweekdayhours", - "binnedyearweekdayhoursminutes", - "binnedyearweekdayhoursminutesseconds", - "binnedyeardayofyear", - ], - **kwds, ) -> Radius2: ... - @overload def timeUnit( self, - _: Literal[ - "binnedutcyear", - "binnedutcyearquarter", - "binnedutcyearquartermonth", - "binnedutcyearmonth", - "binnedutcyearmonthdate", - "binnedutcyearmonthdatehours", - "binnedutcyearmonthdatehoursminutes", - "binnedutcyearmonthdatehoursminutesseconds", - "binnedutcyearweek", - "binnedutcyearweekday", - "binnedutcyearweekdayhours", - "binnedutcyearweekdayhoursminutes", - "binnedutcyearweekdayhoursminutesseconds", - "binnedutcyeardayofyear", - ], - **kwds, + _: TimeUnitParams | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T, + /, ) -> Radius2: ... - @overload def timeUnit( self, + *, binned: Optional[bool] = Undefined, maxbins: Optional[float] = Undefined, step: Optional[float] = Undefined, unit: Optional[SchemaBase | MultiTimeUnit_T | SingleTimeUnit_T] = Undefined, utc: Optional[bool] = Undefined, - **kwds, ) -> Radius2: ... - - @overload - def title(self, _: str, **kwds) -> Radius2: ... - - @overload - def title(self, _: list[str], **kwds) -> Radius2: ... - @overload - def title(self, _: None, **kwds) -> Radius2: ... + def title(self, _: str | Sequence[str] | None, /) -> Radius2: ... def __init__( self, @@ -10546,7 +8999,7 @@ def __init__( timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, **kwds, ): super().__init__( @@ -10572,9 +9025,9 @@ class Radius2Datum(DatumChannelMixin, core.DatumDef): Relative position on a band of a stacked, binned, time unit, or band scale. For example, the marks will be positioned at the beginning of the band if set to ``0``, and at the middle of the band if set to ``0.5``. - datum : str, bool, dict, None, float, :class:`ExprRef`, :class:`DateTime`, :class:`RepeatRef`, :class:`PrimitiveValue` + datum : str, bool, dict, float, :class:`ExprRef`, :class:`DateTime`, :class:`RepeatRef`, :class:`PrimitiveValue`, None A constant value in data domain. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -10666,25 +9119,17 @@ class Radius2Datum(DatumChannelMixin, core.DatumDef): _encoding_name = "radius2" @overload - def bandPosition(self, _: float, **kwds) -> Radius2Datum: ... - - @overload - def title(self, _: str, **kwds) -> Radius2Datum: ... - - @overload - def title(self, _: list[str], **kwds) -> Radius2Datum: ... - + def bandPosition(self, _: float, /) -> Radius2Datum: ... @overload - def title(self, _: None, **kwds) -> Radius2Datum: ... - + def title(self, _: str | Sequence[str] | None, /) -> Radius2Datum: ... @overload - def type(self, _: Type_T, **kwds) -> Radius2Datum: ... + def type(self, _: Type_T, /) -> Radius2Datum: ... def __init__( self, datum, bandPosition: Optional[float] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | Type_T] = Undefined, **kwds, ): @@ -10750,7 +9195,7 @@ class Row(FieldChannelMixin, core.RowColumnEncodingFieldDef): Relative position on a band of a stacked, binned, time unit, or band scale. For example, the marks will be positioned at the beginning of the band if set to ``0``, and at the middle of the band if set to ``0.5``. - bin : bool, dict, None, :class:`BinParams` + bin : bool, dict, :class:`BinParams`, None A flag for binning a ``quantitative`` field, `an object defining binning parameters `__, or indicating that the data for ``x`` or ``y`` channel are binned before they are imported into @@ -10791,9 +9236,9 @@ class Row(FieldChannelMixin, core.RowColumnEncodingFieldDef): about escaping in the `field documentation `__. 2) ``field`` is not required if ``aggregate`` is ``count``. - header : dict, None, :class:`Header` + header : dict, :class:`Header`, None An object defining properties of a facet's header. - sort : dict, None, Sequence[str], Sequence[bool], Sequence[float], :class:`SortArray`, :class:`SortOrder`, :class:`EncodingSortField`, Sequence[dict, :class:`DateTime`], Literal['ascending', 'descending'] + sort : dict, Sequence[str], Sequence[bool], Sequence[float], :class:`SortArray`, :class:`SortOrder`, :class:`EncodingSortField`, Sequence[dict, :class:`DateTime`], Literal['ascending', 'descending'], None Sort order for the encoded field. For continuous fields (quantitative or temporal), ``sort`` can be either @@ -10834,7 +9279,7 @@ class Row(FieldChannelMixin, core.RowColumnEncodingFieldDef): **See also:** `timeUnit `__ documentation. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -10926,30 +9371,21 @@ class Row(FieldChannelMixin, core.RowColumnEncodingFieldDef): _encoding_name = "row" @overload - def aggregate(self, _: NonArgAggregateOp_T, **kwds) -> Row: ... - + def aggregate(self, _: NonArgAggregateOp_T, /) -> Row: ... @overload - def aggregate( - self, argmax: Optional[str | SchemaBase] = Undefined, **kwds - ) -> Row: ... - + def aggregate(self, *, argmax: Optional[str | SchemaBase] = Undefined) -> Row: ... @overload - def aggregate( - self, argmin: Optional[str | SchemaBase] = Undefined, **kwds - ) -> Row: ... - + def aggregate(self, *, argmin: Optional[str | SchemaBase] = Undefined) -> Row: ... @overload - def align(self, _: LayoutAlign_T, **kwds) -> Row: ... - + def align(self, _: LayoutAlign_T, /) -> Row: ... @overload - def bandPosition(self, _: float, **kwds) -> Row: ... - + def bandPosition(self, _: float, /) -> Row: ... @overload - def bin(self, _: bool, **kwds) -> Row: ... - + def bin(self, _: bool | Bin | None, /) -> Row: ... @overload def bin( self, + *, anchor: Optional[float] = Undefined, base: Optional[float] = Undefined, binned: Optional[bool] = Undefined, @@ -10960,28 +9396,23 @@ def bin( nice: Optional[bool] = Undefined, step: Optional[float] = Undefined, steps: Optional[Sequence[float]] = Undefined, - **kwds, ) -> Row: ... - - @overload - def bin(self, _: None, **kwds) -> Row: ... - @overload - def center(self, _: bool, **kwds) -> Row: ... - + def center(self, _: bool, /) -> Row: ... @overload - def field(self, _: str, **kwds) -> Row: ... - + def field(self, _: str | RepeatRef, /) -> Row: ... @overload def field( self, + *, repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined, - **kwds, ) -> Row: ... - + @overload + def header(self, _: Header | None, /) -> Row: ... @overload def header( self, + *, format: Optional[str | SchemaBase | Map] = Undefined, formatType: Optional[str] = Undefined, labelAlign: Optional[Parameter | SchemaBase | Map | Align_T] = Undefined, @@ -11006,7 +9437,7 @@ def header( labelPadding: Optional[float | Parameter | SchemaBase | Map] = Undefined, labels: Optional[bool] = Undefined, orient: Optional[SchemaBase | Orient_T] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, titleAlign: Optional[Parameter | SchemaBase | Map | Align_T] = Undefined, titleAnchor: Optional[SchemaBase | TitleAnchor_T] = Undefined, titleAngle: Optional[float] = Undefined, @@ -11026,120 +9457,49 @@ def header( titleLineHeight: Optional[float | Parameter | SchemaBase | Map] = Undefined, titleOrient: Optional[SchemaBase | Orient_T] = Undefined, titlePadding: Optional[float | Parameter | SchemaBase | Map] = Undefined, - **kwds, ) -> Row: ... - - @overload - def header(self, _: None, **kwds) -> Row: ... - - @overload - def sort(self, _: list[float], **kwds) -> Row: ... - @overload - def sort(self, _: list[str], **kwds) -> Row: ... - - @overload - def sort(self, _: list[bool], **kwds) -> Row: ... - - @overload - def sort(self, _: list[core.DateTime], **kwds) -> Row: ... - - @overload - def sort(self, _: SortOrder_T, **kwds) -> Row: ... - + def sort( + self, + _: Sequence[str] + | Sequence[bool] + | Sequence[float] + | EncodingSortField + | Sequence[DateTime | Temporal] + | SortOrder_T + | None, + /, + ) -> Row: ... @overload def sort( self, + *, field: Optional[str | SchemaBase | Map] = Undefined, op: Optional[SchemaBase | NonArgAggregateOp_T] = Undefined, - order: Optional[None | SchemaBase | SortOrder_T] = Undefined, - **kwds, + order: Optional[SchemaBase | SortOrder_T | None] = Undefined, ) -> Row: ... - - @overload - def sort(self, _: None, **kwds) -> Row: ... - - @overload - def spacing(self, _: float, **kwds) -> Row: ... - @overload - def timeUnit(self, _: LocalSingleTimeUnit_T, **kwds) -> Row: ... - - @overload - def timeUnit(self, _: UtcSingleTimeUnit_T, **kwds) -> Row: ... - - @overload - def timeUnit(self, _: LocalMultiTimeUnit_T, **kwds) -> Row: ... - - @overload - def timeUnit(self, _: UtcMultiTimeUnit_T, **kwds) -> Row: ... - - @overload - def timeUnit( - self, - _: Literal[ - "binnedyear", - "binnedyearquarter", - "binnedyearquartermonth", - "binnedyearmonth", - "binnedyearmonthdate", - "binnedyearmonthdatehours", - "binnedyearmonthdatehoursminutes", - "binnedyearmonthdatehoursminutesseconds", - "binnedyearweek", - "binnedyearweekday", - "binnedyearweekdayhours", - "binnedyearweekdayhoursminutes", - "binnedyearweekdayhoursminutesseconds", - "binnedyeardayofyear", - ], - **kwds, - ) -> Row: ... - + def spacing(self, _: float, /) -> Row: ... @overload def timeUnit( self, - _: Literal[ - "binnedutcyear", - "binnedutcyearquarter", - "binnedutcyearquartermonth", - "binnedutcyearmonth", - "binnedutcyearmonthdate", - "binnedutcyearmonthdatehours", - "binnedutcyearmonthdatehoursminutes", - "binnedutcyearmonthdatehoursminutesseconds", - "binnedutcyearweek", - "binnedutcyearweekday", - "binnedutcyearweekdayhours", - "binnedutcyearweekdayhoursminutes", - "binnedutcyearweekdayhoursminutesseconds", - "binnedutcyeardayofyear", - ], - **kwds, + _: TimeUnitParams | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T, + /, ) -> Row: ... - @overload def timeUnit( self, + *, binned: Optional[bool] = Undefined, maxbins: Optional[float] = Undefined, step: Optional[float] = Undefined, unit: Optional[SchemaBase | MultiTimeUnit_T | SingleTimeUnit_T] = Undefined, utc: Optional[bool] = Undefined, - **kwds, ) -> Row: ... - - @overload - def title(self, _: str, **kwds) -> Row: ... - - @overload - def title(self, _: list[str], **kwds) -> Row: ... - @overload - def title(self, _: None, **kwds) -> Row: ... - + def title(self, _: str | Sequence[str] | None, /) -> Row: ... @overload - def type(self, _: StandardType_T, **kwds) -> Row: ... + def type(self, _: StandardType_T, /) -> Row: ... def __init__( self, @@ -11147,25 +9507,25 @@ def __init__( aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, align: Optional[SchemaBase | LayoutAlign_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Map] = Undefined, + bin: Optional[bool | SchemaBase | Map | None] = Undefined, center: Optional[bool] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, - header: Optional[None | SchemaBase | Map] = Undefined, + header: Optional[SchemaBase | Map | None] = Undefined, sort: Optional[ - None - | SchemaBase + SchemaBase | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map | SortOrder_T + | None ] = Undefined, spacing: Optional[float] = Undefined, timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, **kwds, ): @@ -11211,7 +9571,7 @@ class Shape( Relative position on a band of a stacked, binned, time unit, or band scale. For example, the marks will be positioned at the beginning of the band if set to ``0``, and at the middle of the band if set to ``0.5``. - bin : bool, dict, None, :class:`BinParams` + bin : bool, dict, :class:`BinParams`, None A flag for binning a ``quantitative`` field, `an object defining binning parameters `__, or indicating that the data for ``x`` or ``y`` channel are binned before they are imported into @@ -11254,7 +9614,7 @@ class Shape( about escaping in the `field documentation `__. 2) ``field`` is not required if ``aggregate`` is ``count``. - legend : dict, None, :class:`Legend` + legend : dict, :class:`Legend`, None An object defining properties of the legend. If ``null``, the legend for the encoding channel will be removed. @@ -11263,7 +9623,7 @@ class Shape( **See also:** `legend `__ documentation. - scale : dict, None, :class:`Scale` + scale : dict, :class:`Scale`, None An object defining properties of the channel's scale, which is the function that transforms values in the data domain (numbers, dates, strings, etc) to visual values (pixels, colors, sizes) of the encoding channels. @@ -11276,7 +9636,7 @@ class Shape( **See also:** `scale `__ documentation. - sort : dict, None, :class:`Sort`, Sequence[str], Sequence[bool], Sequence[float], :class:`SortArray`, :class:`SortOrder`, :class:`AllSortString`, :class:`SortByChannel`, :class:`SortByEncoding`, :class:`EncodingSortField`, :class:`SortByChannelDesc`, Sequence[dict, :class:`DateTime`], Literal['-x', '-y', '-color', '-fill', '-stroke', '-strokeWidth', '-size', '-shape', '-fillOpacity', '-strokeOpacity', '-opacity', '-text', 'ascending', 'descending', 'x', 'y', 'color', 'fill', 'stroke', 'strokeWidth', 'size', 'shape', 'fillOpacity', 'strokeOpacity', 'opacity', 'text'] + sort : dict, :class:`Sort`, Sequence[str], Sequence[bool], Sequence[float], :class:`SortArray`, :class:`SortOrder`, :class:`AllSortString`, :class:`SortByChannel`, :class:`SortByEncoding`, :class:`EncodingSortField`, :class:`SortByChannelDesc`, Sequence[dict, :class:`DateTime`], Literal['-x', '-y', '-color', '-fill', '-stroke', '-strokeWidth', '-size', '-shape', '-fillOpacity', '-strokeOpacity', '-opacity', '-text', 'ascending', 'descending', 'x', 'y', 'color', 'fill', 'stroke', 'strokeWidth', 'size', 'shape', 'fillOpacity', 'strokeOpacity', 'opacity', 'text'], None Sort order for the encoded field. For continuous fields (quantitative or temporal), ``sort`` can be either @@ -11323,7 +9683,7 @@ class Shape( **See also:** `timeUnit `__ documentation. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -11415,27 +9775,19 @@ class Shape( _encoding_name = "shape" @overload - def aggregate(self, _: NonArgAggregateOp_T, **kwds) -> Shape: ... - + def aggregate(self, _: NonArgAggregateOp_T, /) -> Shape: ... @overload - def aggregate( - self, argmax: Optional[str | SchemaBase] = Undefined, **kwds - ) -> Shape: ... - + def aggregate(self, *, argmax: Optional[str | SchemaBase] = Undefined) -> Shape: ... @overload - def aggregate( - self, argmin: Optional[str | SchemaBase] = Undefined, **kwds - ) -> Shape: ... - + def aggregate(self, *, argmin: Optional[str | SchemaBase] = Undefined) -> Shape: ... @overload - def bandPosition(self, _: float, **kwds) -> Shape: ... - + def bandPosition(self, _: float, /) -> Shape: ... @overload - def bin(self, _: bool, **kwds) -> Shape: ... - + def bin(self, _: bool | Bin | None, /) -> Shape: ... @overload def bin( self, + *, anchor: Optional[float] = Undefined, base: Optional[float] = Undefined, binned: Optional[bool] = Undefined, @@ -11446,47 +9798,40 @@ def bin( nice: Optional[bool] = Undefined, step: Optional[float] = Undefined, steps: Optional[Sequence[float]] = Undefined, - **kwds, ) -> Shape: ... - - @overload - def bin(self, _: None, **kwds) -> Shape: ... - @overload def condition( self, + *, test: Optional[str | SchemaBase | Map] = Undefined, - value: Optional[str | None | Parameter | SchemaBase | Map] = Undefined, - **kwds, + value: Optional[str | Parameter | SchemaBase | Map | None] = Undefined, ) -> Shape: ... - @overload def condition( self, + *, empty: Optional[bool] = Undefined, param: Optional[str | SchemaBase] = Undefined, - value: Optional[str | None | Parameter | SchemaBase | Map] = Undefined, - **kwds, + value: Optional[str | Parameter | SchemaBase | Map | None] = Undefined, ) -> Shape: ... - @overload def condition( - self, _: list[core.ConditionalValueDefstringnullExprRef], **kwds + self, _: list[core.ConditionalValueDefstringnullExprRef], / ) -> Shape: ... - @overload - def field(self, _: str, **kwds) -> Shape: ... - + def field(self, _: str | RepeatRef, /) -> Shape: ... @overload def field( self, + *, repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined, - **kwds, ) -> Shape: ... - + @overload + def legend(self, _: Legend | None, /) -> Shape: ... @overload def legend( self, + *, aria: Optional[bool | Parameter | SchemaBase | Map] = Undefined, clipHeight: Optional[float | Parameter | SchemaBase | Map] = Undefined, columnPadding: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -11495,14 +9840,14 @@ def legend( description: Optional[str | Parameter | SchemaBase | Map] = Undefined, direction: Optional[SchemaBase | Orientation_T] = Undefined, fillColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, format: Optional[str | SchemaBase | Map] = Undefined, formatType: Optional[str] = Undefined, gradientLength: Optional[float | Parameter | SchemaBase | Map] = Undefined, gradientOpacity: Optional[float | Parameter | SchemaBase | Map] = Undefined, gradientStrokeColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, gradientStrokeWidth: Optional[float | Parameter | SchemaBase | Map] = Undefined, gradientThickness: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -11512,7 +9857,7 @@ def legend( Parameter | SchemaBase | Map | TextBaseline_T ] = Undefined, labelColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, labelExpr: Optional[str] = Undefined, labelFont: Optional[str | Parameter | SchemaBase | Map] = Undefined, @@ -11536,21 +9881,21 @@ def legend( padding: Optional[float | Parameter | SchemaBase | Map] = Undefined, rowPadding: Optional[float | Parameter | SchemaBase | Map] = Undefined, strokeColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, symbolDash: Optional[ Parameter | SchemaBase | Sequence[float] | Map ] = Undefined, symbolDashOffset: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolFillColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, symbolLimit: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolOffset: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolOpacity: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolSize: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolStrokeColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, symbolStrokeWidth: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolType: Optional[str | Parameter | SchemaBase | Map] = Undefined, @@ -11558,14 +9903,14 @@ def legend( float | Parameter | SchemaBase | Map | TimeInterval_T ] = Undefined, tickMinStep: Optional[float | Parameter | SchemaBase | Map] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, titleAlign: Optional[Parameter | SchemaBase | Map | Align_T] = Undefined, titleAnchor: Optional[Parameter | SchemaBase | Map | TitleAnchor_T] = Undefined, titleBaseline: Optional[ Parameter | SchemaBase | Map | TextBaseline_T ] = Undefined, titleColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, titleFont: Optional[str | Parameter | SchemaBase | Map] = Undefined, titleFontSize: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -11585,19 +9930,17 @@ def legend( | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map ] = Undefined, zindex: Optional[float] = Undefined, - **kwds, ) -> Shape: ... - @overload - def legend(self, _: None, **kwds) -> Shape: ... - + def scale(self, _: Scale | None, /) -> Shape: ... @overload def scale( self, + *, align: Optional[float | Parameter | SchemaBase | Map] = Undefined, base: Optional[float | Parameter | SchemaBase | Map] = Undefined, bins: Optional[SchemaBase | Sequence[float] | Map] = Undefined, @@ -11607,12 +9950,18 @@ def scale( Parameter | SchemaBase | Literal["unaggregated"] - | Sequence[str | bool | None | float | Parameter | SchemaBase | Map] + | Sequence[ + str | bool | float | Temporal | Parameter | SchemaBase | Map | None + ] | Map ] = Undefined, - domainMax: Optional[float | Parameter | SchemaBase | Map] = Undefined, + domainMax: Optional[ + float | Temporal | Parameter | SchemaBase | Map + ] = Undefined, domainMid: Optional[float | Parameter | SchemaBase | Map] = Undefined, - domainMin: Optional[float | Parameter | SchemaBase | Map] = Undefined, + domainMin: Optional[ + float | Temporal | Parameter | SchemaBase | Map + ] = Undefined, domainRaw: Optional[Parameter | SchemaBase | Map] = Undefined, exponent: Optional[float | Parameter | SchemaBase | Map] = Undefined, interpolate: Optional[ @@ -11637,156 +9986,78 @@ def scale( scheme: Optional[Parameter | SchemaBase | Map | ColorScheme_T] = Undefined, type: Optional[SchemaBase | ScaleType_T] = Undefined, zero: Optional[bool | Parameter | SchemaBase | Map] = Undefined, - **kwds, ) -> Shape: ... - - @overload - def scale(self, _: None, **kwds) -> Shape: ... - - @overload - def sort(self, _: list[float], **kwds) -> Shape: ... - - @overload - def sort(self, _: list[str], **kwds) -> Shape: ... - - @overload - def sort(self, _: list[bool], **kwds) -> Shape: ... - - @overload - def sort(self, _: list[core.DateTime], **kwds) -> Shape: ... - @overload - def sort(self, _: SortOrder_T, **kwds) -> Shape: ... - - @overload - def sort(self, _: SortByChannel_T, **kwds) -> Shape: ... - - @overload - def sort(self, _: SortByChannelDesc_T, **kwds) -> Shape: ... - + def sort( + self, + _: Sequence[str] + | Sequence[bool] + | Sequence[float] + | Sequence[DateTime | Temporal] + | AllSortString_T + | None, + /, + ) -> Shape: ... @overload def sort( self, + *, field: Optional[str | SchemaBase | Map] = Undefined, op: Optional[SchemaBase | NonArgAggregateOp_T] = Undefined, - order: Optional[None | SchemaBase | SortOrder_T] = Undefined, - **kwds, + order: Optional[SchemaBase | SortOrder_T | None] = Undefined, ) -> Shape: ... - @overload def sort( self, + *, encoding: Optional[SchemaBase | SortByChannel_T] = Undefined, - order: Optional[None | SchemaBase | SortOrder_T] = Undefined, - **kwds, - ) -> Shape: ... - - @overload - def sort(self, _: None, **kwds) -> Shape: ... - - @overload - def timeUnit(self, _: LocalSingleTimeUnit_T, **kwds) -> Shape: ... - - @overload - def timeUnit(self, _: UtcSingleTimeUnit_T, **kwds) -> Shape: ... - - @overload - def timeUnit(self, _: LocalMultiTimeUnit_T, **kwds) -> Shape: ... - - @overload - def timeUnit(self, _: UtcMultiTimeUnit_T, **kwds) -> Shape: ... - - @overload - def timeUnit( - self, - _: Literal[ - "binnedyear", - "binnedyearquarter", - "binnedyearquartermonth", - "binnedyearmonth", - "binnedyearmonthdate", - "binnedyearmonthdatehours", - "binnedyearmonthdatehoursminutes", - "binnedyearmonthdatehoursminutesseconds", - "binnedyearweek", - "binnedyearweekday", - "binnedyearweekdayhours", - "binnedyearweekdayhoursminutes", - "binnedyearweekdayhoursminutesseconds", - "binnedyeardayofyear", - ], - **kwds, + order: Optional[SchemaBase | SortOrder_T | None] = Undefined, ) -> Shape: ... - @overload def timeUnit( self, - _: Literal[ - "binnedutcyear", - "binnedutcyearquarter", - "binnedutcyearquartermonth", - "binnedutcyearmonth", - "binnedutcyearmonthdate", - "binnedutcyearmonthdatehours", - "binnedutcyearmonthdatehoursminutes", - "binnedutcyearmonthdatehoursminutesseconds", - "binnedutcyearweek", - "binnedutcyearweekday", - "binnedutcyearweekdayhours", - "binnedutcyearweekdayhoursminutes", - "binnedutcyearweekdayhoursminutesseconds", - "binnedutcyeardayofyear", - ], - **kwds, + _: TimeUnitParams | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T, + /, ) -> Shape: ... - @overload def timeUnit( self, + *, binned: Optional[bool] = Undefined, maxbins: Optional[float] = Undefined, step: Optional[float] = Undefined, unit: Optional[SchemaBase | MultiTimeUnit_T | SingleTimeUnit_T] = Undefined, utc: Optional[bool] = Undefined, - **kwds, ) -> Shape: ... - @overload - def title(self, _: str, **kwds) -> Shape: ... - - @overload - def title(self, _: list[str], **kwds) -> Shape: ... - - @overload - def title(self, _: None, **kwds) -> Shape: ... - + def title(self, _: str | Sequence[str] | None, /) -> Shape: ... @overload - def type(self, _: TypeForShape_T, **kwds) -> Shape: ... + def type(self, _: TypeForShape_T, /) -> Shape: ... def __init__( self, shorthand: Optional[str | SchemaBase | Sequence[str] | Map] = Undefined, aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Map] = Undefined, + bin: Optional[bool | SchemaBase | Map | None] = Undefined, condition: Optional[SchemaBase | Sequence[SchemaBase | Map] | Map] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, sort: Optional[ - None - | SchemaBase + SchemaBase | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map | AllSortString_T + | None ] = Undefined, timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | TypeForShape_T] = Undefined, **kwds, ): @@ -11827,9 +10098,9 @@ class ShapeDatum( **Note:** A field definition's ``condition`` property can only contain `conditional value definitions `__ since Vega-Lite only allows at most one encoded field per encoding channel. - datum : str, bool, dict, None, float, :class:`ExprRef`, :class:`DateTime`, :class:`RepeatRef`, :class:`PrimitiveValue` + datum : str, bool, dict, float, :class:`ExprRef`, :class:`DateTime`, :class:`RepeatRef`, :class:`PrimitiveValue`, None A constant value in data domain. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -11921,48 +10192,37 @@ class ShapeDatum( _encoding_name = "shape" @overload - def bandPosition(self, _: float, **kwds) -> ShapeDatum: ... - + def bandPosition(self, _: float, /) -> ShapeDatum: ... @overload def condition( self, + *, test: Optional[str | SchemaBase | Map] = Undefined, - value: Optional[str | None | Parameter | SchemaBase | Map] = Undefined, - **kwds, + value: Optional[str | Parameter | SchemaBase | Map | None] = Undefined, ) -> ShapeDatum: ... - @overload def condition( self, + *, empty: Optional[bool] = Undefined, param: Optional[str | SchemaBase] = Undefined, - value: Optional[str | None | Parameter | SchemaBase | Map] = Undefined, - **kwds, + value: Optional[str | Parameter | SchemaBase | Map | None] = Undefined, ) -> ShapeDatum: ... - @overload def condition( - self, _: list[core.ConditionalValueDefstringnullExprRef], **kwds + self, _: list[core.ConditionalValueDefstringnullExprRef], / ) -> ShapeDatum: ... - - @overload - def title(self, _: str, **kwds) -> ShapeDatum: ... - - @overload - def title(self, _: list[str], **kwds) -> ShapeDatum: ... - @overload - def title(self, _: None, **kwds) -> ShapeDatum: ... - + def title(self, _: str | Sequence[str] | None, /) -> ShapeDatum: ... @overload - def type(self, _: Type_T, **kwds) -> ShapeDatum: ... + def type(self, _: Type_T, /) -> ShapeDatum: ... def __init__( self, datum, bandPosition: Optional[float] = Undefined, condition: Optional[SchemaBase | Sequence[SchemaBase | Map] | Map] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | Type_T] = Undefined, **kwds, ): @@ -11988,7 +10248,7 @@ class ShapeValue( ---------- condition : dict, :class:`ConditionalValueDefstringnullExprRef`, :class:`ConditionalParameterValueDefstringnullExprRef`, :class:`ConditionalPredicateValueDefstringnullExprRef`, :class:`ConditionalMarkPropFieldOrDatumDefTypeForShape`, :class:`ConditionalParameterMarkPropFieldOrDatumDefTypeForShape`, :class:`ConditionalPredicateMarkPropFieldOrDatumDefTypeForShape`, Sequence[dict, :class:`ConditionalValueDefstringnullExprRef`, :class:`ConditionalParameterValueDefstringnullExprRef`, :class:`ConditionalPredicateValueDefstringnullExprRef`] A field definition or one or more value definition(s) with a parameter predicate. - value : str, dict, None, :class:`ExprRef` + value : str, dict, :class:`ExprRef`, None A constant value in visual domain (e.g., ``"red"`` / ``"#0099ff"`` / `gradient definition `__ for color, values between ``0`` to ``1`` for opacity). @@ -12000,111 +10260,105 @@ class ShapeValue( @overload def condition( self, + *, aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Map] = Undefined, + bin: Optional[bool | SchemaBase | Map | None] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, sort: Optional[ - None - | SchemaBase + SchemaBase | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map | AllSortString_T + | None ] = Undefined, test: Optional[str | SchemaBase | Map] = Undefined, timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | TypeForShape_T] = Undefined, - **kwds, ) -> ShapeValue: ... - @overload def condition( self, + *, bandPosition: Optional[float] = Undefined, datum: Optional[ - str | bool | None | float | Parameter | SchemaBase | Map + Temporal | Parameter | SchemaBase | Map | PrimitiveValue_T ] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, test: Optional[str | SchemaBase | Map] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | Type_T] = Undefined, - **kwds, ) -> ShapeValue: ... - @overload def condition( self, + *, aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Map] = Undefined, + bin: Optional[bool | SchemaBase | Map | None] = Undefined, empty: Optional[bool] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, param: Optional[str | SchemaBase] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, sort: Optional[ - None - | SchemaBase + SchemaBase | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map | AllSortString_T + | None ] = Undefined, timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | TypeForShape_T] = Undefined, - **kwds, ) -> ShapeValue: ... - @overload def condition( self, + *, bandPosition: Optional[float] = Undefined, datum: Optional[ - str | bool | None | float | Parameter | SchemaBase | Map + Temporal | Parameter | SchemaBase | Map | PrimitiveValue_T ] = Undefined, empty: Optional[bool] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, param: Optional[str | SchemaBase] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | Type_T] = Undefined, - **kwds, ) -> ShapeValue: ... - @overload def condition( self, + *, test: Optional[str | SchemaBase | Map] = Undefined, - value: Optional[str | None | Parameter | SchemaBase | Map] = Undefined, - **kwds, + value: Optional[str | Parameter | SchemaBase | Map | None] = Undefined, ) -> ShapeValue: ... - @overload def condition( self, + *, empty: Optional[bool] = Undefined, param: Optional[str | SchemaBase] = Undefined, - value: Optional[str | None | Parameter | SchemaBase | Map] = Undefined, - **kwds, + value: Optional[str | Parameter | SchemaBase | Map | None] = Undefined, ) -> ShapeValue: ... - @overload def condition( - self, _: list[core.ConditionalValueDefstringnullExprRef], **kwds + self, _: list[core.ConditionalValueDefstringnullExprRef], / ) -> ShapeValue: ... def __init__( @@ -12137,7 +10391,7 @@ class Size(FieldChannelMixin, core.FieldOrDatumDefWithConditionMarkPropFieldDefn Relative position on a band of a stacked, binned, time unit, or band scale. For example, the marks will be positioned at the beginning of the band if set to ``0``, and at the middle of the band if set to ``0.5``. - bin : bool, dict, None, :class:`BinParams` + bin : bool, dict, :class:`BinParams`, None A flag for binning a ``quantitative`` field, `an object defining binning parameters `__, or indicating that the data for ``x`` or ``y`` channel are binned before they are imported into @@ -12180,7 +10434,7 @@ class Size(FieldChannelMixin, core.FieldOrDatumDefWithConditionMarkPropFieldDefn about escaping in the `field documentation `__. 2) ``field`` is not required if ``aggregate`` is ``count``. - legend : dict, None, :class:`Legend` + legend : dict, :class:`Legend`, None An object defining properties of the legend. If ``null``, the legend for the encoding channel will be removed. @@ -12189,7 +10443,7 @@ class Size(FieldChannelMixin, core.FieldOrDatumDefWithConditionMarkPropFieldDefn **See also:** `legend `__ documentation. - scale : dict, None, :class:`Scale` + scale : dict, :class:`Scale`, None An object defining properties of the channel's scale, which is the function that transforms values in the data domain (numbers, dates, strings, etc) to visual values (pixels, colors, sizes) of the encoding channels. @@ -12202,7 +10456,7 @@ class Size(FieldChannelMixin, core.FieldOrDatumDefWithConditionMarkPropFieldDefn **See also:** `scale `__ documentation. - sort : dict, None, :class:`Sort`, Sequence[str], Sequence[bool], Sequence[float], :class:`SortArray`, :class:`SortOrder`, :class:`AllSortString`, :class:`SortByChannel`, :class:`SortByEncoding`, :class:`EncodingSortField`, :class:`SortByChannelDesc`, Sequence[dict, :class:`DateTime`], Literal['-x', '-y', '-color', '-fill', '-stroke', '-strokeWidth', '-size', '-shape', '-fillOpacity', '-strokeOpacity', '-opacity', '-text', 'ascending', 'descending', 'x', 'y', 'color', 'fill', 'stroke', 'strokeWidth', 'size', 'shape', 'fillOpacity', 'strokeOpacity', 'opacity', 'text'] + sort : dict, :class:`Sort`, Sequence[str], Sequence[bool], Sequence[float], :class:`SortArray`, :class:`SortOrder`, :class:`AllSortString`, :class:`SortByChannel`, :class:`SortByEncoding`, :class:`EncodingSortField`, :class:`SortByChannelDesc`, Sequence[dict, :class:`DateTime`], Literal['-x', '-y', '-color', '-fill', '-stroke', '-strokeWidth', '-size', '-shape', '-fillOpacity', '-strokeOpacity', '-opacity', '-text', 'ascending', 'descending', 'x', 'y', 'color', 'fill', 'stroke', 'strokeWidth', 'size', 'shape', 'fillOpacity', 'strokeOpacity', 'opacity', 'text'], None Sort order for the encoded field. For continuous fields (quantitative or temporal), ``sort`` can be either @@ -12249,7 +10503,7 @@ class Size(FieldChannelMixin, core.FieldOrDatumDefWithConditionMarkPropFieldDefn **See also:** `timeUnit `__ documentation. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -12341,27 +10595,19 @@ class Size(FieldChannelMixin, core.FieldOrDatumDefWithConditionMarkPropFieldDefn _encoding_name = "size" @overload - def aggregate(self, _: NonArgAggregateOp_T, **kwds) -> Size: ... - + def aggregate(self, _: NonArgAggregateOp_T, /) -> Size: ... @overload - def aggregate( - self, argmax: Optional[str | SchemaBase] = Undefined, **kwds - ) -> Size: ... - + def aggregate(self, *, argmax: Optional[str | SchemaBase] = Undefined) -> Size: ... @overload - def aggregate( - self, argmin: Optional[str | SchemaBase] = Undefined, **kwds - ) -> Size: ... - + def aggregate(self, *, argmin: Optional[str | SchemaBase] = Undefined) -> Size: ... @overload - def bandPosition(self, _: float, **kwds) -> Size: ... - + def bandPosition(self, _: float, /) -> Size: ... @overload - def bin(self, _: bool, **kwds) -> Size: ... - + def bin(self, _: bool | Bin | None, /) -> Size: ... @overload def bin( self, + *, anchor: Optional[float] = Undefined, base: Optional[float] = Undefined, binned: Optional[bool] = Undefined, @@ -12372,47 +10618,38 @@ def bin( nice: Optional[bool] = Undefined, step: Optional[float] = Undefined, steps: Optional[Sequence[float]] = Undefined, - **kwds, ) -> Size: ... - - @overload - def bin(self, _: None, **kwds) -> Size: ... - @overload def condition( self, + *, test: Optional[str | SchemaBase | Map] = Undefined, value: Optional[float | Parameter | SchemaBase | Map] = Undefined, - **kwds, ) -> Size: ... - @overload def condition( self, + *, empty: Optional[bool] = Undefined, param: Optional[str | SchemaBase] = Undefined, value: Optional[float | Parameter | SchemaBase | Map] = Undefined, - **kwds, ) -> Size: ... - @overload - def condition( - self, _: list[core.ConditionalValueDefnumberExprRef], **kwds - ) -> Size: ... - + def condition(self, _: list[core.ConditionalValueDefnumberExprRef], /) -> Size: ... @overload - def field(self, _: str, **kwds) -> Size: ... - + def field(self, _: str | RepeatRef, /) -> Size: ... @overload def field( self, + *, repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined, - **kwds, ) -> Size: ... - + @overload + def legend(self, _: Legend | None, /) -> Size: ... @overload def legend( self, + *, aria: Optional[bool | Parameter | SchemaBase | Map] = Undefined, clipHeight: Optional[float | Parameter | SchemaBase | Map] = Undefined, columnPadding: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -12421,14 +10658,14 @@ def legend( description: Optional[str | Parameter | SchemaBase | Map] = Undefined, direction: Optional[SchemaBase | Orientation_T] = Undefined, fillColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, format: Optional[str | SchemaBase | Map] = Undefined, formatType: Optional[str] = Undefined, gradientLength: Optional[float | Parameter | SchemaBase | Map] = Undefined, gradientOpacity: Optional[float | Parameter | SchemaBase | Map] = Undefined, gradientStrokeColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, gradientStrokeWidth: Optional[float | Parameter | SchemaBase | Map] = Undefined, gradientThickness: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -12438,7 +10675,7 @@ def legend( Parameter | SchemaBase | Map | TextBaseline_T ] = Undefined, labelColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, labelExpr: Optional[str] = Undefined, labelFont: Optional[str | Parameter | SchemaBase | Map] = Undefined, @@ -12462,21 +10699,21 @@ def legend( padding: Optional[float | Parameter | SchemaBase | Map] = Undefined, rowPadding: Optional[float | Parameter | SchemaBase | Map] = Undefined, strokeColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, symbolDash: Optional[ Parameter | SchemaBase | Sequence[float] | Map ] = Undefined, symbolDashOffset: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolFillColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, symbolLimit: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolOffset: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolOpacity: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolSize: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolStrokeColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, symbolStrokeWidth: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolType: Optional[str | Parameter | SchemaBase | Map] = Undefined, @@ -12484,14 +10721,14 @@ def legend( float | Parameter | SchemaBase | Map | TimeInterval_T ] = Undefined, tickMinStep: Optional[float | Parameter | SchemaBase | Map] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, titleAlign: Optional[Parameter | SchemaBase | Map | Align_T] = Undefined, titleAnchor: Optional[Parameter | SchemaBase | Map | TitleAnchor_T] = Undefined, titleBaseline: Optional[ Parameter | SchemaBase | Map | TextBaseline_T ] = Undefined, titleColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, titleFont: Optional[str | Parameter | SchemaBase | Map] = Undefined, titleFontSize: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -12511,19 +10748,17 @@ def legend( | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map ] = Undefined, zindex: Optional[float] = Undefined, - **kwds, ) -> Size: ... - @overload - def legend(self, _: None, **kwds) -> Size: ... - + def scale(self, _: Scale | None, /) -> Size: ... @overload def scale( self, + *, align: Optional[float | Parameter | SchemaBase | Map] = Undefined, base: Optional[float | Parameter | SchemaBase | Map] = Undefined, bins: Optional[SchemaBase | Sequence[float] | Map] = Undefined, @@ -12533,12 +10768,18 @@ def scale( Parameter | SchemaBase | Literal["unaggregated"] - | Sequence[str | bool | None | float | Parameter | SchemaBase | Map] + | Sequence[ + str | bool | float | Temporal | Parameter | SchemaBase | Map | None + ] | Map ] = Undefined, - domainMax: Optional[float | Parameter | SchemaBase | Map] = Undefined, + domainMax: Optional[ + float | Temporal | Parameter | SchemaBase | Map + ] = Undefined, domainMid: Optional[float | Parameter | SchemaBase | Map] = Undefined, - domainMin: Optional[float | Parameter | SchemaBase | Map] = Undefined, + domainMin: Optional[ + float | Temporal | Parameter | SchemaBase | Map + ] = Undefined, domainRaw: Optional[Parameter | SchemaBase | Map] = Undefined, exponent: Optional[float | Parameter | SchemaBase | Map] = Undefined, interpolate: Optional[ @@ -12563,156 +10804,78 @@ def scale( scheme: Optional[Parameter | SchemaBase | Map | ColorScheme_T] = Undefined, type: Optional[SchemaBase | ScaleType_T] = Undefined, zero: Optional[bool | Parameter | SchemaBase | Map] = Undefined, - **kwds, ) -> Size: ... - - @overload - def scale(self, _: None, **kwds) -> Size: ... - - @overload - def sort(self, _: list[float], **kwds) -> Size: ... - - @overload - def sort(self, _: list[str], **kwds) -> Size: ... - - @overload - def sort(self, _: list[bool], **kwds) -> Size: ... - - @overload - def sort(self, _: list[core.DateTime], **kwds) -> Size: ... - - @overload - def sort(self, _: SortOrder_T, **kwds) -> Size: ... - - @overload - def sort(self, _: SortByChannel_T, **kwds) -> Size: ... - @overload - def sort(self, _: SortByChannelDesc_T, **kwds) -> Size: ... - + def sort( + self, + _: Sequence[str] + | Sequence[bool] + | Sequence[float] + | Sequence[DateTime | Temporal] + | AllSortString_T + | None, + /, + ) -> Size: ... @overload def sort( self, + *, field: Optional[str | SchemaBase | Map] = Undefined, op: Optional[SchemaBase | NonArgAggregateOp_T] = Undefined, - order: Optional[None | SchemaBase | SortOrder_T] = Undefined, - **kwds, + order: Optional[SchemaBase | SortOrder_T | None] = Undefined, ) -> Size: ... - @overload def sort( self, + *, encoding: Optional[SchemaBase | SortByChannel_T] = Undefined, - order: Optional[None | SchemaBase | SortOrder_T] = Undefined, - **kwds, - ) -> Size: ... - - @overload - def sort(self, _: None, **kwds) -> Size: ... - - @overload - def timeUnit(self, _: LocalSingleTimeUnit_T, **kwds) -> Size: ... - - @overload - def timeUnit(self, _: UtcSingleTimeUnit_T, **kwds) -> Size: ... - - @overload - def timeUnit(self, _: LocalMultiTimeUnit_T, **kwds) -> Size: ... - - @overload - def timeUnit(self, _: UtcMultiTimeUnit_T, **kwds) -> Size: ... - - @overload - def timeUnit( - self, - _: Literal[ - "binnedyear", - "binnedyearquarter", - "binnedyearquartermonth", - "binnedyearmonth", - "binnedyearmonthdate", - "binnedyearmonthdatehours", - "binnedyearmonthdatehoursminutes", - "binnedyearmonthdatehoursminutesseconds", - "binnedyearweek", - "binnedyearweekday", - "binnedyearweekdayhours", - "binnedyearweekdayhoursminutes", - "binnedyearweekdayhoursminutesseconds", - "binnedyeardayofyear", - ], - **kwds, + order: Optional[SchemaBase | SortOrder_T | None] = Undefined, ) -> Size: ... - @overload def timeUnit( self, - _: Literal[ - "binnedutcyear", - "binnedutcyearquarter", - "binnedutcyearquartermonth", - "binnedutcyearmonth", - "binnedutcyearmonthdate", - "binnedutcyearmonthdatehours", - "binnedutcyearmonthdatehoursminutes", - "binnedutcyearmonthdatehoursminutesseconds", - "binnedutcyearweek", - "binnedutcyearweekday", - "binnedutcyearweekdayhours", - "binnedutcyearweekdayhoursminutes", - "binnedutcyearweekdayhoursminutesseconds", - "binnedutcyeardayofyear", - ], - **kwds, + _: TimeUnitParams | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T, + /, ) -> Size: ... - @overload def timeUnit( self, + *, binned: Optional[bool] = Undefined, maxbins: Optional[float] = Undefined, step: Optional[float] = Undefined, unit: Optional[SchemaBase | MultiTimeUnit_T | SingleTimeUnit_T] = Undefined, utc: Optional[bool] = Undefined, - **kwds, ) -> Size: ... - - @overload - def title(self, _: str, **kwds) -> Size: ... - - @overload - def title(self, _: list[str], **kwds) -> Size: ... - @overload - def title(self, _: None, **kwds) -> Size: ... - + def title(self, _: str | Sequence[str] | None, /) -> Size: ... @overload - def type(self, _: StandardType_T, **kwds) -> Size: ... + def type(self, _: StandardType_T, /) -> Size: ... def __init__( self, shorthand: Optional[str | SchemaBase | Sequence[str] | Map] = Undefined, aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Map] = Undefined, + bin: Optional[bool | SchemaBase | Map | None] = Undefined, condition: Optional[SchemaBase | Sequence[SchemaBase | Map] | Map] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, sort: Optional[ - None - | SchemaBase + SchemaBase | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map | AllSortString_T + | None ] = Undefined, timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, **kwds, ): @@ -12751,9 +10914,9 @@ class SizeDatum(DatumChannelMixin, core.FieldOrDatumDefWithConditionDatumDefnumb **Note:** A field definition's ``condition`` property can only contain `conditional value definitions `__ since Vega-Lite only allows at most one encoded field per encoding channel. - datum : str, bool, dict, None, float, :class:`ExprRef`, :class:`DateTime`, :class:`RepeatRef`, :class:`PrimitiveValue` + datum : str, bool, dict, float, :class:`ExprRef`, :class:`DateTime`, :class:`RepeatRef`, :class:`PrimitiveValue`, None A constant value in data domain. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -12845,48 +11008,37 @@ class SizeDatum(DatumChannelMixin, core.FieldOrDatumDefWithConditionDatumDefnumb _encoding_name = "size" @overload - def bandPosition(self, _: float, **kwds) -> SizeDatum: ... - + def bandPosition(self, _: float, /) -> SizeDatum: ... @overload def condition( self, + *, test: Optional[str | SchemaBase | Map] = Undefined, value: Optional[float | Parameter | SchemaBase | Map] = Undefined, - **kwds, ) -> SizeDatum: ... - @overload def condition( self, + *, empty: Optional[bool] = Undefined, param: Optional[str | SchemaBase] = Undefined, value: Optional[float | Parameter | SchemaBase | Map] = Undefined, - **kwds, ) -> SizeDatum: ... - @overload def condition( - self, _: list[core.ConditionalValueDefnumberExprRef], **kwds + self, _: list[core.ConditionalValueDefnumberExprRef], / ) -> SizeDatum: ... - - @overload - def title(self, _: str, **kwds) -> SizeDatum: ... - - @overload - def title(self, _: list[str], **kwds) -> SizeDatum: ... - @overload - def title(self, _: None, **kwds) -> SizeDatum: ... - + def title(self, _: str | Sequence[str] | None, /) -> SizeDatum: ... @overload - def type(self, _: Type_T, **kwds) -> SizeDatum: ... + def type(self, _: Type_T, /) -> SizeDatum: ... def __init__( self, datum, bandPosition: Optional[float] = Undefined, condition: Optional[SchemaBase | Sequence[SchemaBase | Map] | Map] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | Type_T] = Undefined, **kwds, ): @@ -12923,111 +11075,105 @@ class SizeValue( @overload def condition( self, + *, aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Map] = Undefined, + bin: Optional[bool | SchemaBase | Map | None] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, sort: Optional[ - None - | SchemaBase + SchemaBase | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map | AllSortString_T + | None ] = Undefined, test: Optional[str | SchemaBase | Map] = Undefined, timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, - **kwds, ) -> SizeValue: ... - @overload def condition( self, + *, bandPosition: Optional[float] = Undefined, datum: Optional[ - str | bool | None | float | Parameter | SchemaBase | Map + Temporal | Parameter | SchemaBase | Map | PrimitiveValue_T ] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, test: Optional[str | SchemaBase | Map] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | Type_T] = Undefined, - **kwds, ) -> SizeValue: ... - @overload def condition( self, + *, aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Map] = Undefined, + bin: Optional[bool | SchemaBase | Map | None] = Undefined, empty: Optional[bool] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, param: Optional[str | SchemaBase] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, sort: Optional[ - None - | SchemaBase + SchemaBase | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map | AllSortString_T + | None ] = Undefined, timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, - **kwds, ) -> SizeValue: ... - @overload def condition( self, + *, bandPosition: Optional[float] = Undefined, datum: Optional[ - str | bool | None | float | Parameter | SchemaBase | Map + Temporal | Parameter | SchemaBase | Map | PrimitiveValue_T ] = Undefined, empty: Optional[bool] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, param: Optional[str | SchemaBase] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | Type_T] = Undefined, - **kwds, ) -> SizeValue: ... - @overload def condition( self, + *, test: Optional[str | SchemaBase | Map] = Undefined, value: Optional[float | Parameter | SchemaBase | Map] = Undefined, - **kwds, ) -> SizeValue: ... - @overload def condition( self, + *, empty: Optional[bool] = Undefined, param: Optional[str | SchemaBase] = Undefined, value: Optional[float | Parameter | SchemaBase | Map] = Undefined, - **kwds, ) -> SizeValue: ... - @overload def condition( - self, _: list[core.ConditionalValueDefnumberExprRef], **kwds + self, _: list[core.ConditionalValueDefnumberExprRef], / ) -> SizeValue: ... def __init__( @@ -13063,7 +11209,7 @@ class Stroke( Relative position on a band of a stacked, binned, time unit, or band scale. For example, the marks will be positioned at the beginning of the band if set to ``0``, and at the middle of the band if set to ``0.5``. - bin : bool, dict, None, :class:`BinParams` + bin : bool, dict, :class:`BinParams`, None A flag for binning a ``quantitative`` field, `an object defining binning parameters `__, or indicating that the data for ``x`` or ``y`` channel are binned before they are imported into @@ -13106,7 +11252,7 @@ class Stroke( about escaping in the `field documentation `__. 2) ``field`` is not required if ``aggregate`` is ``count``. - legend : dict, None, :class:`Legend` + legend : dict, :class:`Legend`, None An object defining properties of the legend. If ``null``, the legend for the encoding channel will be removed. @@ -13115,7 +11261,7 @@ class Stroke( **See also:** `legend `__ documentation. - scale : dict, None, :class:`Scale` + scale : dict, :class:`Scale`, None An object defining properties of the channel's scale, which is the function that transforms values in the data domain (numbers, dates, strings, etc) to visual values (pixels, colors, sizes) of the encoding channels. @@ -13128,7 +11274,7 @@ class Stroke( **See also:** `scale `__ documentation. - sort : dict, None, :class:`Sort`, Sequence[str], Sequence[bool], Sequence[float], :class:`SortArray`, :class:`SortOrder`, :class:`AllSortString`, :class:`SortByChannel`, :class:`SortByEncoding`, :class:`EncodingSortField`, :class:`SortByChannelDesc`, Sequence[dict, :class:`DateTime`], Literal['-x', '-y', '-color', '-fill', '-stroke', '-strokeWidth', '-size', '-shape', '-fillOpacity', '-strokeOpacity', '-opacity', '-text', 'ascending', 'descending', 'x', 'y', 'color', 'fill', 'stroke', 'strokeWidth', 'size', 'shape', 'fillOpacity', 'strokeOpacity', 'opacity', 'text'] + sort : dict, :class:`Sort`, Sequence[str], Sequence[bool], Sequence[float], :class:`SortArray`, :class:`SortOrder`, :class:`AllSortString`, :class:`SortByChannel`, :class:`SortByEncoding`, :class:`EncodingSortField`, :class:`SortByChannelDesc`, Sequence[dict, :class:`DateTime`], Literal['-x', '-y', '-color', '-fill', '-stroke', '-strokeWidth', '-size', '-shape', '-fillOpacity', '-strokeOpacity', '-opacity', '-text', 'ascending', 'descending', 'x', 'y', 'color', 'fill', 'stroke', 'strokeWidth', 'size', 'shape', 'fillOpacity', 'strokeOpacity', 'opacity', 'text'], None Sort order for the encoded field. For continuous fields (quantitative or temporal), ``sort`` can be either @@ -13175,7 +11321,7 @@ class Stroke( **See also:** `timeUnit `__ documentation. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -13267,27 +11413,23 @@ class Stroke( _encoding_name = "stroke" @overload - def aggregate(self, _: NonArgAggregateOp_T, **kwds) -> Stroke: ... - + def aggregate(self, _: NonArgAggregateOp_T, /) -> Stroke: ... @overload def aggregate( - self, argmax: Optional[str | SchemaBase] = Undefined, **kwds + self, *, argmax: Optional[str | SchemaBase] = Undefined ) -> Stroke: ... - @overload def aggregate( - self, argmin: Optional[str | SchemaBase] = Undefined, **kwds + self, *, argmin: Optional[str | SchemaBase] = Undefined ) -> Stroke: ... - @overload - def bandPosition(self, _: float, **kwds) -> Stroke: ... - + def bandPosition(self, _: float, /) -> Stroke: ... @overload - def bin(self, _: bool, **kwds) -> Stroke: ... - + def bin(self, _: bool | Bin | None, /) -> Stroke: ... @overload def bin( self, + *, anchor: Optional[float] = Undefined, base: Optional[float] = Undefined, binned: Optional[bool] = Undefined, @@ -13298,47 +11440,40 @@ def bin( nice: Optional[bool] = Undefined, step: Optional[float] = Undefined, steps: Optional[Sequence[float]] = Undefined, - **kwds, ) -> Stroke: ... - - @overload - def bin(self, _: None, **kwds) -> Stroke: ... - @overload def condition( self, + *, test: Optional[str | SchemaBase | Map] = Undefined, - value: Optional[str | None | Parameter | SchemaBase | Map] = Undefined, - **kwds, + value: Optional[str | Parameter | SchemaBase | Map | None] = Undefined, ) -> Stroke: ... - @overload def condition( self, + *, empty: Optional[bool] = Undefined, param: Optional[str | SchemaBase] = Undefined, - value: Optional[str | None | Parameter | SchemaBase | Map] = Undefined, - **kwds, + value: Optional[str | Parameter | SchemaBase | Map | None] = Undefined, ) -> Stroke: ... - @overload def condition( - self, _: list[core.ConditionalValueDefGradientstringnullExprRef], **kwds + self, _: list[core.ConditionalValueDefGradientstringnullExprRef], / ) -> Stroke: ... - @overload - def field(self, _: str, **kwds) -> Stroke: ... - + def field(self, _: str | RepeatRef, /) -> Stroke: ... @overload def field( self, + *, repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined, - **kwds, ) -> Stroke: ... - + @overload + def legend(self, _: Legend | None, /) -> Stroke: ... @overload def legend( self, + *, aria: Optional[bool | Parameter | SchemaBase | Map] = Undefined, clipHeight: Optional[float | Parameter | SchemaBase | Map] = Undefined, columnPadding: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -13347,14 +11482,14 @@ def legend( description: Optional[str | Parameter | SchemaBase | Map] = Undefined, direction: Optional[SchemaBase | Orientation_T] = Undefined, fillColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, format: Optional[str | SchemaBase | Map] = Undefined, formatType: Optional[str] = Undefined, gradientLength: Optional[float | Parameter | SchemaBase | Map] = Undefined, gradientOpacity: Optional[float | Parameter | SchemaBase | Map] = Undefined, gradientStrokeColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, gradientStrokeWidth: Optional[float | Parameter | SchemaBase | Map] = Undefined, gradientThickness: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -13364,7 +11499,7 @@ def legend( Parameter | SchemaBase | Map | TextBaseline_T ] = Undefined, labelColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, labelExpr: Optional[str] = Undefined, labelFont: Optional[str | Parameter | SchemaBase | Map] = Undefined, @@ -13388,21 +11523,21 @@ def legend( padding: Optional[float | Parameter | SchemaBase | Map] = Undefined, rowPadding: Optional[float | Parameter | SchemaBase | Map] = Undefined, strokeColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, symbolDash: Optional[ Parameter | SchemaBase | Sequence[float] | Map ] = Undefined, symbolDashOffset: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolFillColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, symbolLimit: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolOffset: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolOpacity: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolSize: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolStrokeColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, symbolStrokeWidth: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolType: Optional[str | Parameter | SchemaBase | Map] = Undefined, @@ -13410,14 +11545,14 @@ def legend( float | Parameter | SchemaBase | Map | TimeInterval_T ] = Undefined, tickMinStep: Optional[float | Parameter | SchemaBase | Map] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, titleAlign: Optional[Parameter | SchemaBase | Map | Align_T] = Undefined, titleAnchor: Optional[Parameter | SchemaBase | Map | TitleAnchor_T] = Undefined, titleBaseline: Optional[ Parameter | SchemaBase | Map | TextBaseline_T ] = Undefined, titleColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, titleFont: Optional[str | Parameter | SchemaBase | Map] = Undefined, titleFontSize: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -13437,19 +11572,17 @@ def legend( | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map ] = Undefined, zindex: Optional[float] = Undefined, - **kwds, ) -> Stroke: ... - @overload - def legend(self, _: None, **kwds) -> Stroke: ... - + def scale(self, _: Scale | None, /) -> Stroke: ... @overload def scale( self, + *, align: Optional[float | Parameter | SchemaBase | Map] = Undefined, base: Optional[float | Parameter | SchemaBase | Map] = Undefined, bins: Optional[SchemaBase | Sequence[float] | Map] = Undefined, @@ -13459,12 +11592,18 @@ def scale( Parameter | SchemaBase | Literal["unaggregated"] - | Sequence[str | bool | None | float | Parameter | SchemaBase | Map] + | Sequence[ + str | bool | float | Temporal | Parameter | SchemaBase | Map | None + ] | Map ] = Undefined, - domainMax: Optional[float | Parameter | SchemaBase | Map] = Undefined, + domainMax: Optional[ + float | Temporal | Parameter | SchemaBase | Map + ] = Undefined, domainMid: Optional[float | Parameter | SchemaBase | Map] = Undefined, - domainMin: Optional[float | Parameter | SchemaBase | Map] = Undefined, + domainMin: Optional[ + float | Temporal | Parameter | SchemaBase | Map + ] = Undefined, domainRaw: Optional[Parameter | SchemaBase | Map] = Undefined, exponent: Optional[float | Parameter | SchemaBase | Map] = Undefined, interpolate: Optional[ @@ -13489,156 +11628,78 @@ def scale( scheme: Optional[Parameter | SchemaBase | Map | ColorScheme_T] = Undefined, type: Optional[SchemaBase | ScaleType_T] = Undefined, zero: Optional[bool | Parameter | SchemaBase | Map] = Undefined, - **kwds, ) -> Stroke: ... - - @overload - def scale(self, _: None, **kwds) -> Stroke: ... - - @overload - def sort(self, _: list[float], **kwds) -> Stroke: ... - - @overload - def sort(self, _: list[str], **kwds) -> Stroke: ... - - @overload - def sort(self, _: list[bool], **kwds) -> Stroke: ... - @overload - def sort(self, _: list[core.DateTime], **kwds) -> Stroke: ... - - @overload - def sort(self, _: SortOrder_T, **kwds) -> Stroke: ... - - @overload - def sort(self, _: SortByChannel_T, **kwds) -> Stroke: ... - - @overload - def sort(self, _: SortByChannelDesc_T, **kwds) -> Stroke: ... - + def sort( + self, + _: Sequence[str] + | Sequence[bool] + | Sequence[float] + | Sequence[DateTime | Temporal] + | AllSortString_T + | None, + /, + ) -> Stroke: ... @overload def sort( self, + *, field: Optional[str | SchemaBase | Map] = Undefined, op: Optional[SchemaBase | NonArgAggregateOp_T] = Undefined, - order: Optional[None | SchemaBase | SortOrder_T] = Undefined, - **kwds, + order: Optional[SchemaBase | SortOrder_T | None] = Undefined, ) -> Stroke: ... - @overload def sort( self, + *, encoding: Optional[SchemaBase | SortByChannel_T] = Undefined, - order: Optional[None | SchemaBase | SortOrder_T] = Undefined, - **kwds, - ) -> Stroke: ... - - @overload - def sort(self, _: None, **kwds) -> Stroke: ... - - @overload - def timeUnit(self, _: LocalSingleTimeUnit_T, **kwds) -> Stroke: ... - - @overload - def timeUnit(self, _: UtcSingleTimeUnit_T, **kwds) -> Stroke: ... - - @overload - def timeUnit(self, _: LocalMultiTimeUnit_T, **kwds) -> Stroke: ... - - @overload - def timeUnit(self, _: UtcMultiTimeUnit_T, **kwds) -> Stroke: ... - - @overload - def timeUnit( - self, - _: Literal[ - "binnedyear", - "binnedyearquarter", - "binnedyearquartermonth", - "binnedyearmonth", - "binnedyearmonthdate", - "binnedyearmonthdatehours", - "binnedyearmonthdatehoursminutes", - "binnedyearmonthdatehoursminutesseconds", - "binnedyearweek", - "binnedyearweekday", - "binnedyearweekdayhours", - "binnedyearweekdayhoursminutes", - "binnedyearweekdayhoursminutesseconds", - "binnedyeardayofyear", - ], - **kwds, + order: Optional[SchemaBase | SortOrder_T | None] = Undefined, ) -> Stroke: ... - @overload def timeUnit( self, - _: Literal[ - "binnedutcyear", - "binnedutcyearquarter", - "binnedutcyearquartermonth", - "binnedutcyearmonth", - "binnedutcyearmonthdate", - "binnedutcyearmonthdatehours", - "binnedutcyearmonthdatehoursminutes", - "binnedutcyearmonthdatehoursminutesseconds", - "binnedutcyearweek", - "binnedutcyearweekday", - "binnedutcyearweekdayhours", - "binnedutcyearweekdayhoursminutes", - "binnedutcyearweekdayhoursminutesseconds", - "binnedutcyeardayofyear", - ], - **kwds, + _: TimeUnitParams | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T, + /, ) -> Stroke: ... - @overload def timeUnit( self, + *, binned: Optional[bool] = Undefined, maxbins: Optional[float] = Undefined, step: Optional[float] = Undefined, unit: Optional[SchemaBase | MultiTimeUnit_T | SingleTimeUnit_T] = Undefined, utc: Optional[bool] = Undefined, - **kwds, ) -> Stroke: ... - - @overload - def title(self, _: str, **kwds) -> Stroke: ... - @overload - def title(self, _: list[str], **kwds) -> Stroke: ... - - @overload - def title(self, _: None, **kwds) -> Stroke: ... - + def title(self, _: str | Sequence[str] | None, /) -> Stroke: ... @overload - def type(self, _: StandardType_T, **kwds) -> Stroke: ... + def type(self, _: StandardType_T, /) -> Stroke: ... def __init__( self, shorthand: Optional[str | SchemaBase | Sequence[str] | Map] = Undefined, aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Map] = Undefined, + bin: Optional[bool | SchemaBase | Map | None] = Undefined, condition: Optional[SchemaBase | Sequence[SchemaBase | Map] | Map] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, sort: Optional[ - None - | SchemaBase + SchemaBase | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map | AllSortString_T + | None ] = Undefined, timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, **kwds, ): @@ -13679,9 +11740,9 @@ class StrokeDatum( **Note:** A field definition's ``condition`` property can only contain `conditional value definitions `__ since Vega-Lite only allows at most one encoded field per encoding channel. - datum : str, bool, dict, None, float, :class:`ExprRef`, :class:`DateTime`, :class:`RepeatRef`, :class:`PrimitiveValue` + datum : str, bool, dict, float, :class:`ExprRef`, :class:`DateTime`, :class:`RepeatRef`, :class:`PrimitiveValue`, None A constant value in data domain. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -13773,48 +11834,37 @@ class StrokeDatum( _encoding_name = "stroke" @overload - def bandPosition(self, _: float, **kwds) -> StrokeDatum: ... - + def bandPosition(self, _: float, /) -> StrokeDatum: ... @overload def condition( self, + *, test: Optional[str | SchemaBase | Map] = Undefined, - value: Optional[str | None | Parameter | SchemaBase | Map] = Undefined, - **kwds, + value: Optional[str | Parameter | SchemaBase | Map | None] = Undefined, ) -> StrokeDatum: ... - @overload def condition( self, + *, empty: Optional[bool] = Undefined, param: Optional[str | SchemaBase] = Undefined, - value: Optional[str | None | Parameter | SchemaBase | Map] = Undefined, - **kwds, + value: Optional[str | Parameter | SchemaBase | Map | None] = Undefined, ) -> StrokeDatum: ... - @overload def condition( - self, _: list[core.ConditionalValueDefGradientstringnullExprRef], **kwds + self, _: list[core.ConditionalValueDefGradientstringnullExprRef], / ) -> StrokeDatum: ... - - @overload - def title(self, _: str, **kwds) -> StrokeDatum: ... - - @overload - def title(self, _: list[str], **kwds) -> StrokeDatum: ... - @overload - def title(self, _: None, **kwds) -> StrokeDatum: ... - + def title(self, _: str | Sequence[str] | None, /) -> StrokeDatum: ... @overload - def type(self, _: Type_T, **kwds) -> StrokeDatum: ... + def type(self, _: Type_T, /) -> StrokeDatum: ... def __init__( self, datum, bandPosition: Optional[float] = Undefined, condition: Optional[SchemaBase | Sequence[SchemaBase | Map] | Map] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | Type_T] = Undefined, **kwds, ): @@ -13840,7 +11890,7 @@ class StrokeValue( ---------- condition : dict, :class:`ConditionalMarkPropFieldOrDatumDef`, :class:`ConditionalParameterMarkPropFieldOrDatumDef`, :class:`ConditionalPredicateMarkPropFieldOrDatumDef`, :class:`ConditionalValueDefGradientstringnullExprRef`, :class:`ConditionalParameterValueDefGradientstringnullExprRef`, :class:`ConditionalPredicateValueDefGradientstringnullExprRef`, Sequence[dict, :class:`ConditionalValueDefGradientstringnullExprRef`, :class:`ConditionalParameterValueDefGradientstringnullExprRef`, :class:`ConditionalPredicateValueDefGradientstringnullExprRef`] A field definition or one or more value definition(s) with a parameter predicate. - value : str, dict, None, :class:`ExprRef`, :class:`Gradient`, :class:`LinearGradient`, :class:`RadialGradient` + value : str, dict, :class:`ExprRef`, :class:`Gradient`, :class:`LinearGradient`, :class:`RadialGradient`, None A constant value in visual domain (e.g., ``"red"`` / ``"#0099ff"`` / `gradient definition `__ for color, values between ``0`` to ``1`` for opacity). @@ -13852,111 +11902,105 @@ class StrokeValue( @overload def condition( self, + *, aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Map] = Undefined, + bin: Optional[bool | SchemaBase | Map | None] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, sort: Optional[ - None - | SchemaBase + SchemaBase | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map | AllSortString_T + | None ] = Undefined, test: Optional[str | SchemaBase | Map] = Undefined, timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, - **kwds, ) -> StrokeValue: ... - @overload def condition( self, + *, bandPosition: Optional[float] = Undefined, datum: Optional[ - str | bool | None | float | Parameter | SchemaBase | Map + Temporal | Parameter | SchemaBase | Map | PrimitiveValue_T ] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, test: Optional[str | SchemaBase | Map] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | Type_T] = Undefined, - **kwds, ) -> StrokeValue: ... - @overload def condition( self, + *, aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Map] = Undefined, + bin: Optional[bool | SchemaBase | Map | None] = Undefined, empty: Optional[bool] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, param: Optional[str | SchemaBase] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, sort: Optional[ - None - | SchemaBase + SchemaBase | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map | AllSortString_T + | None ] = Undefined, timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, - **kwds, ) -> StrokeValue: ... - @overload def condition( self, + *, bandPosition: Optional[float] = Undefined, datum: Optional[ - str | bool | None | float | Parameter | SchemaBase | Map + Temporal | Parameter | SchemaBase | Map | PrimitiveValue_T ] = Undefined, empty: Optional[bool] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, param: Optional[str | SchemaBase] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | Type_T] = Undefined, - **kwds, ) -> StrokeValue: ... - @overload def condition( self, + *, test: Optional[str | SchemaBase | Map] = Undefined, - value: Optional[str | None | Parameter | SchemaBase | Map] = Undefined, - **kwds, + value: Optional[str | Parameter | SchemaBase | Map | None] = Undefined, ) -> StrokeValue: ... - @overload def condition( self, + *, empty: Optional[bool] = Undefined, param: Optional[str | SchemaBase] = Undefined, - value: Optional[str | None | Parameter | SchemaBase | Map] = Undefined, - **kwds, + value: Optional[str | Parameter | SchemaBase | Map | None] = Undefined, ) -> StrokeValue: ... - @overload def condition( - self, _: list[core.ConditionalValueDefGradientstringnullExprRef], **kwds + self, _: list[core.ConditionalValueDefGradientstringnullExprRef], / ) -> StrokeValue: ... def __init__( @@ -13991,7 +12035,7 @@ class StrokeDash( Relative position on a band of a stacked, binned, time unit, or band scale. For example, the marks will be positioned at the beginning of the band if set to ``0``, and at the middle of the band if set to ``0.5``. - bin : bool, dict, None, :class:`BinParams` + bin : bool, dict, :class:`BinParams`, None A flag for binning a ``quantitative`` field, `an object defining binning parameters `__, or indicating that the data for ``x`` or ``y`` channel are binned before they are imported into @@ -14034,7 +12078,7 @@ class StrokeDash( about escaping in the `field documentation `__. 2) ``field`` is not required if ``aggregate`` is ``count``. - legend : dict, None, :class:`Legend` + legend : dict, :class:`Legend`, None An object defining properties of the legend. If ``null``, the legend for the encoding channel will be removed. @@ -14043,7 +12087,7 @@ class StrokeDash( **See also:** `legend `__ documentation. - scale : dict, None, :class:`Scale` + scale : dict, :class:`Scale`, None An object defining properties of the channel's scale, which is the function that transforms values in the data domain (numbers, dates, strings, etc) to visual values (pixels, colors, sizes) of the encoding channels. @@ -14056,7 +12100,7 @@ class StrokeDash( **See also:** `scale `__ documentation. - sort : dict, None, :class:`Sort`, Sequence[str], Sequence[bool], Sequence[float], :class:`SortArray`, :class:`SortOrder`, :class:`AllSortString`, :class:`SortByChannel`, :class:`SortByEncoding`, :class:`EncodingSortField`, :class:`SortByChannelDesc`, Sequence[dict, :class:`DateTime`], Literal['-x', '-y', '-color', '-fill', '-stroke', '-strokeWidth', '-size', '-shape', '-fillOpacity', '-strokeOpacity', '-opacity', '-text', 'ascending', 'descending', 'x', 'y', 'color', 'fill', 'stroke', 'strokeWidth', 'size', 'shape', 'fillOpacity', 'strokeOpacity', 'opacity', 'text'] + sort : dict, :class:`Sort`, Sequence[str], Sequence[bool], Sequence[float], :class:`SortArray`, :class:`SortOrder`, :class:`AllSortString`, :class:`SortByChannel`, :class:`SortByEncoding`, :class:`EncodingSortField`, :class:`SortByChannelDesc`, Sequence[dict, :class:`DateTime`], Literal['-x', '-y', '-color', '-fill', '-stroke', '-strokeWidth', '-size', '-shape', '-fillOpacity', '-strokeOpacity', '-opacity', '-text', 'ascending', 'descending', 'x', 'y', 'color', 'fill', 'stroke', 'strokeWidth', 'size', 'shape', 'fillOpacity', 'strokeOpacity', 'opacity', 'text'], None Sort order for the encoded field. For continuous fields (quantitative or temporal), ``sort`` can be either @@ -14103,7 +12147,7 @@ class StrokeDash( **See also:** `timeUnit `__ documentation. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -14195,27 +12239,23 @@ class StrokeDash( _encoding_name = "strokeDash" @overload - def aggregate(self, _: NonArgAggregateOp_T, **kwds) -> StrokeDash: ... - + def aggregate(self, _: NonArgAggregateOp_T, /) -> StrokeDash: ... @overload def aggregate( - self, argmax: Optional[str | SchemaBase] = Undefined, **kwds + self, *, argmax: Optional[str | SchemaBase] = Undefined ) -> StrokeDash: ... - @overload def aggregate( - self, argmin: Optional[str | SchemaBase] = Undefined, **kwds + self, *, argmin: Optional[str | SchemaBase] = Undefined ) -> StrokeDash: ... - @overload - def bandPosition(self, _: float, **kwds) -> StrokeDash: ... - + def bandPosition(self, _: float, /) -> StrokeDash: ... @overload - def bin(self, _: bool, **kwds) -> StrokeDash: ... - + def bin(self, _: bool | Bin | None, /) -> StrokeDash: ... @overload def bin( self, + *, anchor: Optional[float] = Undefined, base: Optional[float] = Undefined, binned: Optional[bool] = Undefined, @@ -14226,47 +12266,40 @@ def bin( nice: Optional[bool] = Undefined, step: Optional[float] = Undefined, steps: Optional[Sequence[float]] = Undefined, - **kwds, ) -> StrokeDash: ... - - @overload - def bin(self, _: None, **kwds) -> StrokeDash: ... - @overload def condition( self, + *, test: Optional[str | SchemaBase | Map] = Undefined, value: Optional[Parameter | SchemaBase | Sequence[float] | Map] = Undefined, - **kwds, ) -> StrokeDash: ... - @overload def condition( self, + *, empty: Optional[bool] = Undefined, param: Optional[str | SchemaBase] = Undefined, value: Optional[Parameter | SchemaBase | Sequence[float] | Map] = Undefined, - **kwds, ) -> StrokeDash: ... - @overload def condition( - self, _: list[core.ConditionalValueDefnumberArrayExprRef], **kwds + self, _: list[core.ConditionalValueDefnumberArrayExprRef], / ) -> StrokeDash: ... - @overload - def field(self, _: str, **kwds) -> StrokeDash: ... - + def field(self, _: str | RepeatRef, /) -> StrokeDash: ... @overload def field( self, + *, repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined, - **kwds, ) -> StrokeDash: ... - + @overload + def legend(self, _: Legend | None, /) -> StrokeDash: ... @overload def legend( self, + *, aria: Optional[bool | Parameter | SchemaBase | Map] = Undefined, clipHeight: Optional[float | Parameter | SchemaBase | Map] = Undefined, columnPadding: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -14275,14 +12308,14 @@ def legend( description: Optional[str | Parameter | SchemaBase | Map] = Undefined, direction: Optional[SchemaBase | Orientation_T] = Undefined, fillColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, format: Optional[str | SchemaBase | Map] = Undefined, formatType: Optional[str] = Undefined, gradientLength: Optional[float | Parameter | SchemaBase | Map] = Undefined, gradientOpacity: Optional[float | Parameter | SchemaBase | Map] = Undefined, gradientStrokeColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, gradientStrokeWidth: Optional[float | Parameter | SchemaBase | Map] = Undefined, gradientThickness: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -14292,7 +12325,7 @@ def legend( Parameter | SchemaBase | Map | TextBaseline_T ] = Undefined, labelColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, labelExpr: Optional[str] = Undefined, labelFont: Optional[str | Parameter | SchemaBase | Map] = Undefined, @@ -14316,21 +12349,21 @@ def legend( padding: Optional[float | Parameter | SchemaBase | Map] = Undefined, rowPadding: Optional[float | Parameter | SchemaBase | Map] = Undefined, strokeColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, symbolDash: Optional[ Parameter | SchemaBase | Sequence[float] | Map ] = Undefined, symbolDashOffset: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolFillColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, symbolLimit: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolOffset: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolOpacity: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolSize: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolStrokeColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, symbolStrokeWidth: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolType: Optional[str | Parameter | SchemaBase | Map] = Undefined, @@ -14338,14 +12371,14 @@ def legend( float | Parameter | SchemaBase | Map | TimeInterval_T ] = Undefined, tickMinStep: Optional[float | Parameter | SchemaBase | Map] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, titleAlign: Optional[Parameter | SchemaBase | Map | Align_T] = Undefined, titleAnchor: Optional[Parameter | SchemaBase | Map | TitleAnchor_T] = Undefined, titleBaseline: Optional[ Parameter | SchemaBase | Map | TextBaseline_T ] = Undefined, titleColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, titleFont: Optional[str | Parameter | SchemaBase | Map] = Undefined, titleFontSize: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -14365,19 +12398,17 @@ def legend( | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map ] = Undefined, zindex: Optional[float] = Undefined, - **kwds, ) -> StrokeDash: ... - @overload - def legend(self, _: None, **kwds) -> StrokeDash: ... - + def scale(self, _: Scale | None, /) -> StrokeDash: ... @overload def scale( self, + *, align: Optional[float | Parameter | SchemaBase | Map] = Undefined, base: Optional[float | Parameter | SchemaBase | Map] = Undefined, bins: Optional[SchemaBase | Sequence[float] | Map] = Undefined, @@ -14387,12 +12418,18 @@ def scale( Parameter | SchemaBase | Literal["unaggregated"] - | Sequence[str | bool | None | float | Parameter | SchemaBase | Map] + | Sequence[ + str | bool | float | Temporal | Parameter | SchemaBase | Map | None + ] | Map ] = Undefined, - domainMax: Optional[float | Parameter | SchemaBase | Map] = Undefined, + domainMax: Optional[ + float | Temporal | Parameter | SchemaBase | Map + ] = Undefined, domainMid: Optional[float | Parameter | SchemaBase | Map] = Undefined, - domainMin: Optional[float | Parameter | SchemaBase | Map] = Undefined, + domainMin: Optional[ + float | Temporal | Parameter | SchemaBase | Map + ] = Undefined, domainRaw: Optional[Parameter | SchemaBase | Map] = Undefined, exponent: Optional[float | Parameter | SchemaBase | Map] = Undefined, interpolate: Optional[ @@ -14417,156 +12454,78 @@ def scale( scheme: Optional[Parameter | SchemaBase | Map | ColorScheme_T] = Undefined, type: Optional[SchemaBase | ScaleType_T] = Undefined, zero: Optional[bool | Parameter | SchemaBase | Map] = Undefined, - **kwds, ) -> StrokeDash: ... - - @overload - def scale(self, _: None, **kwds) -> StrokeDash: ... - @overload - def sort(self, _: list[float], **kwds) -> StrokeDash: ... - - @overload - def sort(self, _: list[str], **kwds) -> StrokeDash: ... - - @overload - def sort(self, _: list[bool], **kwds) -> StrokeDash: ... - - @overload - def sort(self, _: list[core.DateTime], **kwds) -> StrokeDash: ... - - @overload - def sort(self, _: SortOrder_T, **kwds) -> StrokeDash: ... - - @overload - def sort(self, _: SortByChannel_T, **kwds) -> StrokeDash: ... - - @overload - def sort(self, _: SortByChannelDesc_T, **kwds) -> StrokeDash: ... - + def sort( + self, + _: Sequence[str] + | Sequence[bool] + | Sequence[float] + | Sequence[DateTime | Temporal] + | AllSortString_T + | None, + /, + ) -> StrokeDash: ... @overload def sort( self, + *, field: Optional[str | SchemaBase | Map] = Undefined, op: Optional[SchemaBase | NonArgAggregateOp_T] = Undefined, - order: Optional[None | SchemaBase | SortOrder_T] = Undefined, - **kwds, + order: Optional[SchemaBase | SortOrder_T | None] = Undefined, ) -> StrokeDash: ... - @overload def sort( self, + *, encoding: Optional[SchemaBase | SortByChannel_T] = Undefined, - order: Optional[None | SchemaBase | SortOrder_T] = Undefined, - **kwds, - ) -> StrokeDash: ... - - @overload - def sort(self, _: None, **kwds) -> StrokeDash: ... - - @overload - def timeUnit(self, _: LocalSingleTimeUnit_T, **kwds) -> StrokeDash: ... - - @overload - def timeUnit(self, _: UtcSingleTimeUnit_T, **kwds) -> StrokeDash: ... - - @overload - def timeUnit(self, _: LocalMultiTimeUnit_T, **kwds) -> StrokeDash: ... - - @overload - def timeUnit(self, _: UtcMultiTimeUnit_T, **kwds) -> StrokeDash: ... - - @overload - def timeUnit( - self, - _: Literal[ - "binnedyear", - "binnedyearquarter", - "binnedyearquartermonth", - "binnedyearmonth", - "binnedyearmonthdate", - "binnedyearmonthdatehours", - "binnedyearmonthdatehoursminutes", - "binnedyearmonthdatehoursminutesseconds", - "binnedyearweek", - "binnedyearweekday", - "binnedyearweekdayhours", - "binnedyearweekdayhoursminutes", - "binnedyearweekdayhoursminutesseconds", - "binnedyeardayofyear", - ], - **kwds, + order: Optional[SchemaBase | SortOrder_T | None] = Undefined, ) -> StrokeDash: ... - @overload def timeUnit( self, - _: Literal[ - "binnedutcyear", - "binnedutcyearquarter", - "binnedutcyearquartermonth", - "binnedutcyearmonth", - "binnedutcyearmonthdate", - "binnedutcyearmonthdatehours", - "binnedutcyearmonthdatehoursminutes", - "binnedutcyearmonthdatehoursminutesseconds", - "binnedutcyearweek", - "binnedutcyearweekday", - "binnedutcyearweekdayhours", - "binnedutcyearweekdayhoursminutes", - "binnedutcyearweekdayhoursminutesseconds", - "binnedutcyeardayofyear", - ], - **kwds, + _: TimeUnitParams | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T, + /, ) -> StrokeDash: ... - @overload def timeUnit( self, + *, binned: Optional[bool] = Undefined, maxbins: Optional[float] = Undefined, step: Optional[float] = Undefined, unit: Optional[SchemaBase | MultiTimeUnit_T | SingleTimeUnit_T] = Undefined, utc: Optional[bool] = Undefined, - **kwds, ) -> StrokeDash: ... - @overload - def title(self, _: str, **kwds) -> StrokeDash: ... - - @overload - def title(self, _: list[str], **kwds) -> StrokeDash: ... - - @overload - def title(self, _: None, **kwds) -> StrokeDash: ... - + def title(self, _: str | Sequence[str] | None, /) -> StrokeDash: ... @overload - def type(self, _: StandardType_T, **kwds) -> StrokeDash: ... + def type(self, _: StandardType_T, /) -> StrokeDash: ... def __init__( self, shorthand: Optional[str | SchemaBase | Sequence[str] | Map] = Undefined, aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Map] = Undefined, + bin: Optional[bool | SchemaBase | Map | None] = Undefined, condition: Optional[SchemaBase | Sequence[SchemaBase | Map] | Map] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, sort: Optional[ - None - | SchemaBase + SchemaBase | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map | AllSortString_T + | None ] = Undefined, timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, **kwds, ): @@ -14607,9 +12566,9 @@ class StrokeDashDatum( **Note:** A field definition's ``condition`` property can only contain `conditional value definitions `__ since Vega-Lite only allows at most one encoded field per encoding channel. - datum : str, bool, dict, None, float, :class:`ExprRef`, :class:`DateTime`, :class:`RepeatRef`, :class:`PrimitiveValue` + datum : str, bool, dict, float, :class:`ExprRef`, :class:`DateTime`, :class:`RepeatRef`, :class:`PrimitiveValue`, None A constant value in data domain. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -14701,48 +12660,37 @@ class StrokeDashDatum( _encoding_name = "strokeDash" @overload - def bandPosition(self, _: float, **kwds) -> StrokeDashDatum: ... - + def bandPosition(self, _: float, /) -> StrokeDashDatum: ... @overload def condition( self, + *, test: Optional[str | SchemaBase | Map] = Undefined, value: Optional[Parameter | SchemaBase | Sequence[float] | Map] = Undefined, - **kwds, ) -> StrokeDashDatum: ... - @overload def condition( self, + *, empty: Optional[bool] = Undefined, param: Optional[str | SchemaBase] = Undefined, value: Optional[Parameter | SchemaBase | Sequence[float] | Map] = Undefined, - **kwds, ) -> StrokeDashDatum: ... - @overload def condition( - self, _: list[core.ConditionalValueDefnumberArrayExprRef], **kwds + self, _: list[core.ConditionalValueDefnumberArrayExprRef], / ) -> StrokeDashDatum: ... - - @overload - def title(self, _: str, **kwds) -> StrokeDashDatum: ... - - @overload - def title(self, _: list[str], **kwds) -> StrokeDashDatum: ... - @overload - def title(self, _: None, **kwds) -> StrokeDashDatum: ... - + def title(self, _: str | Sequence[str] | None, /) -> StrokeDashDatum: ... @overload - def type(self, _: Type_T, **kwds) -> StrokeDashDatum: ... + def type(self, _: Type_T, /) -> StrokeDashDatum: ... def __init__( self, datum, bandPosition: Optional[float] = Undefined, condition: Optional[SchemaBase | Sequence[SchemaBase | Map] | Map] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | Type_T] = Undefined, **kwds, ): @@ -14779,111 +12727,105 @@ class StrokeDashValue( @overload def condition( self, + *, aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Map] = Undefined, + bin: Optional[bool | SchemaBase | Map | None] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, sort: Optional[ - None - | SchemaBase + SchemaBase | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map | AllSortString_T + | None ] = Undefined, test: Optional[str | SchemaBase | Map] = Undefined, timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, - **kwds, ) -> StrokeDashValue: ... - @overload def condition( self, + *, bandPosition: Optional[float] = Undefined, datum: Optional[ - str | bool | None | float | Parameter | SchemaBase | Map + Temporal | Parameter | SchemaBase | Map | PrimitiveValue_T ] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, test: Optional[str | SchemaBase | Map] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | Type_T] = Undefined, - **kwds, ) -> StrokeDashValue: ... - @overload def condition( self, + *, aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Map] = Undefined, + bin: Optional[bool | SchemaBase | Map | None] = Undefined, empty: Optional[bool] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, param: Optional[str | SchemaBase] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, sort: Optional[ - None - | SchemaBase + SchemaBase | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map | AllSortString_T + | None ] = Undefined, timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, - **kwds, ) -> StrokeDashValue: ... - @overload def condition( self, + *, bandPosition: Optional[float] = Undefined, datum: Optional[ - str | bool | None | float | Parameter | SchemaBase | Map + Temporal | Parameter | SchemaBase | Map | PrimitiveValue_T ] = Undefined, empty: Optional[bool] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, param: Optional[str | SchemaBase] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | Type_T] = Undefined, - **kwds, ) -> StrokeDashValue: ... - @overload def condition( self, + *, test: Optional[str | SchemaBase | Map] = Undefined, value: Optional[Parameter | SchemaBase | Sequence[float] | Map] = Undefined, - **kwds, ) -> StrokeDashValue: ... - @overload def condition( self, + *, empty: Optional[bool] = Undefined, param: Optional[str | SchemaBase] = Undefined, value: Optional[Parameter | SchemaBase | Sequence[float] | Map] = Undefined, - **kwds, ) -> StrokeDashValue: ... - @overload def condition( - self, _: list[core.ConditionalValueDefnumberArrayExprRef], **kwds + self, _: list[core.ConditionalValueDefnumberArrayExprRef], / ) -> StrokeDashValue: ... def __init__( @@ -14918,7 +12860,7 @@ class StrokeOpacity( Relative position on a band of a stacked, binned, time unit, or band scale. For example, the marks will be positioned at the beginning of the band if set to ``0``, and at the middle of the band if set to ``0.5``. - bin : bool, dict, None, :class:`BinParams` + bin : bool, dict, :class:`BinParams`, None A flag for binning a ``quantitative`` field, `an object defining binning parameters `__, or indicating that the data for ``x`` or ``y`` channel are binned before they are imported into @@ -14961,7 +12903,7 @@ class StrokeOpacity( about escaping in the `field documentation `__. 2) ``field`` is not required if ``aggregate`` is ``count``. - legend : dict, None, :class:`Legend` + legend : dict, :class:`Legend`, None An object defining properties of the legend. If ``null``, the legend for the encoding channel will be removed. @@ -14970,7 +12912,7 @@ class StrokeOpacity( **See also:** `legend `__ documentation. - scale : dict, None, :class:`Scale` + scale : dict, :class:`Scale`, None An object defining properties of the channel's scale, which is the function that transforms values in the data domain (numbers, dates, strings, etc) to visual values (pixels, colors, sizes) of the encoding channels. @@ -14983,7 +12925,7 @@ class StrokeOpacity( **See also:** `scale `__ documentation. - sort : dict, None, :class:`Sort`, Sequence[str], Sequence[bool], Sequence[float], :class:`SortArray`, :class:`SortOrder`, :class:`AllSortString`, :class:`SortByChannel`, :class:`SortByEncoding`, :class:`EncodingSortField`, :class:`SortByChannelDesc`, Sequence[dict, :class:`DateTime`], Literal['-x', '-y', '-color', '-fill', '-stroke', '-strokeWidth', '-size', '-shape', '-fillOpacity', '-strokeOpacity', '-opacity', '-text', 'ascending', 'descending', 'x', 'y', 'color', 'fill', 'stroke', 'strokeWidth', 'size', 'shape', 'fillOpacity', 'strokeOpacity', 'opacity', 'text'] + sort : dict, :class:`Sort`, Sequence[str], Sequence[bool], Sequence[float], :class:`SortArray`, :class:`SortOrder`, :class:`AllSortString`, :class:`SortByChannel`, :class:`SortByEncoding`, :class:`EncodingSortField`, :class:`SortByChannelDesc`, Sequence[dict, :class:`DateTime`], Literal['-x', '-y', '-color', '-fill', '-stroke', '-strokeWidth', '-size', '-shape', '-fillOpacity', '-strokeOpacity', '-opacity', '-text', 'ascending', 'descending', 'x', 'y', 'color', 'fill', 'stroke', 'strokeWidth', 'size', 'shape', 'fillOpacity', 'strokeOpacity', 'opacity', 'text'], None Sort order for the encoded field. For continuous fields (quantitative or temporal), ``sort`` can be either @@ -15030,7 +12972,7 @@ class StrokeOpacity( **See also:** `timeUnit `__ documentation. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -15122,27 +13064,23 @@ class StrokeOpacity( _encoding_name = "strokeOpacity" @overload - def aggregate(self, _: NonArgAggregateOp_T, **kwds) -> StrokeOpacity: ... - + def aggregate(self, _: NonArgAggregateOp_T, /) -> StrokeOpacity: ... @overload def aggregate( - self, argmax: Optional[str | SchemaBase] = Undefined, **kwds + self, *, argmax: Optional[str | SchemaBase] = Undefined ) -> StrokeOpacity: ... - @overload def aggregate( - self, argmin: Optional[str | SchemaBase] = Undefined, **kwds + self, *, argmin: Optional[str | SchemaBase] = Undefined ) -> StrokeOpacity: ... - @overload - def bandPosition(self, _: float, **kwds) -> StrokeOpacity: ... - + def bandPosition(self, _: float, /) -> StrokeOpacity: ... @overload - def bin(self, _: bool, **kwds) -> StrokeOpacity: ... - + def bin(self, _: bool | Bin | None, /) -> StrokeOpacity: ... @overload def bin( self, + *, anchor: Optional[float] = Undefined, base: Optional[float] = Undefined, binned: Optional[bool] = Undefined, @@ -15153,47 +13091,40 @@ def bin( nice: Optional[bool] = Undefined, step: Optional[float] = Undefined, steps: Optional[Sequence[float]] = Undefined, - **kwds, ) -> StrokeOpacity: ... - - @overload - def bin(self, _: None, **kwds) -> StrokeOpacity: ... - @overload def condition( self, + *, test: Optional[str | SchemaBase | Map] = Undefined, value: Optional[float | Parameter | SchemaBase | Map] = Undefined, - **kwds, ) -> StrokeOpacity: ... - @overload def condition( self, + *, empty: Optional[bool] = Undefined, param: Optional[str | SchemaBase] = Undefined, value: Optional[float | Parameter | SchemaBase | Map] = Undefined, - **kwds, ) -> StrokeOpacity: ... - @overload def condition( - self, _: list[core.ConditionalValueDefnumberExprRef], **kwds + self, _: list[core.ConditionalValueDefnumberExprRef], / ) -> StrokeOpacity: ... - @overload - def field(self, _: str, **kwds) -> StrokeOpacity: ... - + def field(self, _: str | RepeatRef, /) -> StrokeOpacity: ... @overload def field( self, + *, repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined, - **kwds, ) -> StrokeOpacity: ... - + @overload + def legend(self, _: Legend | None, /) -> StrokeOpacity: ... @overload def legend( self, + *, aria: Optional[bool | Parameter | SchemaBase | Map] = Undefined, clipHeight: Optional[float | Parameter | SchemaBase | Map] = Undefined, columnPadding: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -15202,14 +13133,14 @@ def legend( description: Optional[str | Parameter | SchemaBase | Map] = Undefined, direction: Optional[SchemaBase | Orientation_T] = Undefined, fillColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, format: Optional[str | SchemaBase | Map] = Undefined, formatType: Optional[str] = Undefined, gradientLength: Optional[float | Parameter | SchemaBase | Map] = Undefined, gradientOpacity: Optional[float | Parameter | SchemaBase | Map] = Undefined, gradientStrokeColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, gradientStrokeWidth: Optional[float | Parameter | SchemaBase | Map] = Undefined, gradientThickness: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -15219,7 +13150,7 @@ def legend( Parameter | SchemaBase | Map | TextBaseline_T ] = Undefined, labelColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, labelExpr: Optional[str] = Undefined, labelFont: Optional[str | Parameter | SchemaBase | Map] = Undefined, @@ -15243,21 +13174,21 @@ def legend( padding: Optional[float | Parameter | SchemaBase | Map] = Undefined, rowPadding: Optional[float | Parameter | SchemaBase | Map] = Undefined, strokeColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, symbolDash: Optional[ Parameter | SchemaBase | Sequence[float] | Map ] = Undefined, symbolDashOffset: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolFillColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, symbolLimit: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolOffset: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolOpacity: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolSize: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolStrokeColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, symbolStrokeWidth: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolType: Optional[str | Parameter | SchemaBase | Map] = Undefined, @@ -15265,14 +13196,14 @@ def legend( float | Parameter | SchemaBase | Map | TimeInterval_T ] = Undefined, tickMinStep: Optional[float | Parameter | SchemaBase | Map] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, titleAlign: Optional[Parameter | SchemaBase | Map | Align_T] = Undefined, titleAnchor: Optional[Parameter | SchemaBase | Map | TitleAnchor_T] = Undefined, titleBaseline: Optional[ Parameter | SchemaBase | Map | TextBaseline_T ] = Undefined, titleColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, titleFont: Optional[str | Parameter | SchemaBase | Map] = Undefined, titleFontSize: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -15292,19 +13223,17 @@ def legend( | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map ] = Undefined, zindex: Optional[float] = Undefined, - **kwds, ) -> StrokeOpacity: ... - @overload - def legend(self, _: None, **kwds) -> StrokeOpacity: ... - + def scale(self, _: Scale | None, /) -> StrokeOpacity: ... @overload def scale( self, + *, align: Optional[float | Parameter | SchemaBase | Map] = Undefined, base: Optional[float | Parameter | SchemaBase | Map] = Undefined, bins: Optional[SchemaBase | Sequence[float] | Map] = Undefined, @@ -15314,12 +13243,18 @@ def scale( Parameter | SchemaBase | Literal["unaggregated"] - | Sequence[str | bool | None | float | Parameter | SchemaBase | Map] + | Sequence[ + str | bool | float | Temporal | Parameter | SchemaBase | Map | None + ] | Map ] = Undefined, - domainMax: Optional[float | Parameter | SchemaBase | Map] = Undefined, + domainMax: Optional[ + float | Temporal | Parameter | SchemaBase | Map + ] = Undefined, domainMid: Optional[float | Parameter | SchemaBase | Map] = Undefined, - domainMin: Optional[float | Parameter | SchemaBase | Map] = Undefined, + domainMin: Optional[ + float | Temporal | Parameter | SchemaBase | Map + ] = Undefined, domainRaw: Optional[Parameter | SchemaBase | Map] = Undefined, exponent: Optional[float | Parameter | SchemaBase | Map] = Undefined, interpolate: Optional[ @@ -15344,156 +13279,78 @@ def scale( scheme: Optional[Parameter | SchemaBase | Map | ColorScheme_T] = Undefined, type: Optional[SchemaBase | ScaleType_T] = Undefined, zero: Optional[bool | Parameter | SchemaBase | Map] = Undefined, - **kwds, ) -> StrokeOpacity: ... - - @overload - def scale(self, _: None, **kwds) -> StrokeOpacity: ... - - @overload - def sort(self, _: list[float], **kwds) -> StrokeOpacity: ... - - @overload - def sort(self, _: list[str], **kwds) -> StrokeOpacity: ... - - @overload - def sort(self, _: list[bool], **kwds) -> StrokeOpacity: ... - - @overload - def sort(self, _: list[core.DateTime], **kwds) -> StrokeOpacity: ... - - @overload - def sort(self, _: SortOrder_T, **kwds) -> StrokeOpacity: ... - @overload - def sort(self, _: SortByChannel_T, **kwds) -> StrokeOpacity: ... - - @overload - def sort(self, _: SortByChannelDesc_T, **kwds) -> StrokeOpacity: ... - + def sort( + self, + _: Sequence[str] + | Sequence[bool] + | Sequence[float] + | Sequence[DateTime | Temporal] + | AllSortString_T + | None, + /, + ) -> StrokeOpacity: ... @overload def sort( self, + *, field: Optional[str | SchemaBase | Map] = Undefined, op: Optional[SchemaBase | NonArgAggregateOp_T] = Undefined, - order: Optional[None | SchemaBase | SortOrder_T] = Undefined, - **kwds, + order: Optional[SchemaBase | SortOrder_T | None] = Undefined, ) -> StrokeOpacity: ... - @overload def sort( self, + *, encoding: Optional[SchemaBase | SortByChannel_T] = Undefined, - order: Optional[None | SchemaBase | SortOrder_T] = Undefined, - **kwds, - ) -> StrokeOpacity: ... - - @overload - def sort(self, _: None, **kwds) -> StrokeOpacity: ... - - @overload - def timeUnit(self, _: LocalSingleTimeUnit_T, **kwds) -> StrokeOpacity: ... - - @overload - def timeUnit(self, _: UtcSingleTimeUnit_T, **kwds) -> StrokeOpacity: ... - - @overload - def timeUnit(self, _: LocalMultiTimeUnit_T, **kwds) -> StrokeOpacity: ... - - @overload - def timeUnit(self, _: UtcMultiTimeUnit_T, **kwds) -> StrokeOpacity: ... - - @overload - def timeUnit( - self, - _: Literal[ - "binnedyear", - "binnedyearquarter", - "binnedyearquartermonth", - "binnedyearmonth", - "binnedyearmonthdate", - "binnedyearmonthdatehours", - "binnedyearmonthdatehoursminutes", - "binnedyearmonthdatehoursminutesseconds", - "binnedyearweek", - "binnedyearweekday", - "binnedyearweekdayhours", - "binnedyearweekdayhoursminutes", - "binnedyearweekdayhoursminutesseconds", - "binnedyeardayofyear", - ], - **kwds, + order: Optional[SchemaBase | SortOrder_T | None] = Undefined, ) -> StrokeOpacity: ... - @overload def timeUnit( self, - _: Literal[ - "binnedutcyear", - "binnedutcyearquarter", - "binnedutcyearquartermonth", - "binnedutcyearmonth", - "binnedutcyearmonthdate", - "binnedutcyearmonthdatehours", - "binnedutcyearmonthdatehoursminutes", - "binnedutcyearmonthdatehoursminutesseconds", - "binnedutcyearweek", - "binnedutcyearweekday", - "binnedutcyearweekdayhours", - "binnedutcyearweekdayhoursminutes", - "binnedutcyearweekdayhoursminutesseconds", - "binnedutcyeardayofyear", - ], - **kwds, + _: TimeUnitParams | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T, + /, ) -> StrokeOpacity: ... - @overload def timeUnit( self, + *, binned: Optional[bool] = Undefined, maxbins: Optional[float] = Undefined, step: Optional[float] = Undefined, unit: Optional[SchemaBase | MultiTimeUnit_T | SingleTimeUnit_T] = Undefined, utc: Optional[bool] = Undefined, - **kwds, ) -> StrokeOpacity: ... - - @overload - def title(self, _: str, **kwds) -> StrokeOpacity: ... - @overload - def title(self, _: list[str], **kwds) -> StrokeOpacity: ... - - @overload - def title(self, _: None, **kwds) -> StrokeOpacity: ... - + def title(self, _: str | Sequence[str] | None, /) -> StrokeOpacity: ... @overload - def type(self, _: StandardType_T, **kwds) -> StrokeOpacity: ... + def type(self, _: StandardType_T, /) -> StrokeOpacity: ... def __init__( self, shorthand: Optional[str | SchemaBase | Sequence[str] | Map] = Undefined, aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Map] = Undefined, + bin: Optional[bool | SchemaBase | Map | None] = Undefined, condition: Optional[SchemaBase | Sequence[SchemaBase | Map] | Map] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, sort: Optional[ - None - | SchemaBase + SchemaBase | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map | AllSortString_T + | None ] = Undefined, timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, **kwds, ): @@ -15534,9 +13391,9 @@ class StrokeOpacityDatum( **Note:** A field definition's ``condition`` property can only contain `conditional value definitions `__ since Vega-Lite only allows at most one encoded field per encoding channel. - datum : str, bool, dict, None, float, :class:`ExprRef`, :class:`DateTime`, :class:`RepeatRef`, :class:`PrimitiveValue` + datum : str, bool, dict, float, :class:`ExprRef`, :class:`DateTime`, :class:`RepeatRef`, :class:`PrimitiveValue`, None A constant value in data domain. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -15628,48 +13485,37 @@ class StrokeOpacityDatum( _encoding_name = "strokeOpacity" @overload - def bandPosition(self, _: float, **kwds) -> StrokeOpacityDatum: ... - + def bandPosition(self, _: float, /) -> StrokeOpacityDatum: ... @overload def condition( self, + *, test: Optional[str | SchemaBase | Map] = Undefined, value: Optional[float | Parameter | SchemaBase | Map] = Undefined, - **kwds, ) -> StrokeOpacityDatum: ... - @overload def condition( self, + *, empty: Optional[bool] = Undefined, param: Optional[str | SchemaBase] = Undefined, value: Optional[float | Parameter | SchemaBase | Map] = Undefined, - **kwds, ) -> StrokeOpacityDatum: ... - @overload def condition( - self, _: list[core.ConditionalValueDefnumberExprRef], **kwds + self, _: list[core.ConditionalValueDefnumberExprRef], / ) -> StrokeOpacityDatum: ... - - @overload - def title(self, _: str, **kwds) -> StrokeOpacityDatum: ... - - @overload - def title(self, _: list[str], **kwds) -> StrokeOpacityDatum: ... - @overload - def title(self, _: None, **kwds) -> StrokeOpacityDatum: ... - + def title(self, _: str | Sequence[str] | None, /) -> StrokeOpacityDatum: ... @overload - def type(self, _: Type_T, **kwds) -> StrokeOpacityDatum: ... + def type(self, _: Type_T, /) -> StrokeOpacityDatum: ... def __init__( self, datum, bandPosition: Optional[float] = Undefined, condition: Optional[SchemaBase | Sequence[SchemaBase | Map] | Map] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | Type_T] = Undefined, **kwds, ): @@ -15706,111 +13552,105 @@ class StrokeOpacityValue( @overload def condition( self, + *, aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Map] = Undefined, + bin: Optional[bool | SchemaBase | Map | None] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, sort: Optional[ - None - | SchemaBase + SchemaBase | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map | AllSortString_T + | None ] = Undefined, test: Optional[str | SchemaBase | Map] = Undefined, timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, - **kwds, ) -> StrokeOpacityValue: ... - @overload def condition( self, + *, bandPosition: Optional[float] = Undefined, datum: Optional[ - str | bool | None | float | Parameter | SchemaBase | Map + Temporal | Parameter | SchemaBase | Map | PrimitiveValue_T ] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, test: Optional[str | SchemaBase | Map] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | Type_T] = Undefined, - **kwds, ) -> StrokeOpacityValue: ... - @overload def condition( self, + *, aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Map] = Undefined, + bin: Optional[bool | SchemaBase | Map | None] = Undefined, empty: Optional[bool] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, param: Optional[str | SchemaBase] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, sort: Optional[ - None - | SchemaBase + SchemaBase | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map | AllSortString_T + | None ] = Undefined, timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, - **kwds, ) -> StrokeOpacityValue: ... - @overload def condition( self, + *, bandPosition: Optional[float] = Undefined, datum: Optional[ - str | bool | None | float | Parameter | SchemaBase | Map + Temporal | Parameter | SchemaBase | Map | PrimitiveValue_T ] = Undefined, empty: Optional[bool] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, param: Optional[str | SchemaBase] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | Type_T] = Undefined, - **kwds, ) -> StrokeOpacityValue: ... - @overload def condition( self, + *, test: Optional[str | SchemaBase | Map] = Undefined, value: Optional[float | Parameter | SchemaBase | Map] = Undefined, - **kwds, ) -> StrokeOpacityValue: ... - @overload def condition( self, + *, empty: Optional[bool] = Undefined, param: Optional[str | SchemaBase] = Undefined, value: Optional[float | Parameter | SchemaBase | Map] = Undefined, - **kwds, ) -> StrokeOpacityValue: ... - @overload def condition( - self, _: list[core.ConditionalValueDefnumberExprRef], **kwds + self, _: list[core.ConditionalValueDefnumberExprRef], / ) -> StrokeOpacityValue: ... def __init__( @@ -15845,7 +13685,7 @@ class StrokeWidth( Relative position on a band of a stacked, binned, time unit, or band scale. For example, the marks will be positioned at the beginning of the band if set to ``0``, and at the middle of the band if set to ``0.5``. - bin : bool, dict, None, :class:`BinParams` + bin : bool, dict, :class:`BinParams`, None A flag for binning a ``quantitative`` field, `an object defining binning parameters `__, or indicating that the data for ``x`` or ``y`` channel are binned before they are imported into @@ -15888,7 +13728,7 @@ class StrokeWidth( about escaping in the `field documentation `__. 2) ``field`` is not required if ``aggregate`` is ``count``. - legend : dict, None, :class:`Legend` + legend : dict, :class:`Legend`, None An object defining properties of the legend. If ``null``, the legend for the encoding channel will be removed. @@ -15897,7 +13737,7 @@ class StrokeWidth( **See also:** `legend `__ documentation. - scale : dict, None, :class:`Scale` + scale : dict, :class:`Scale`, None An object defining properties of the channel's scale, which is the function that transforms values in the data domain (numbers, dates, strings, etc) to visual values (pixels, colors, sizes) of the encoding channels. @@ -15910,7 +13750,7 @@ class StrokeWidth( **See also:** `scale `__ documentation. - sort : dict, None, :class:`Sort`, Sequence[str], Sequence[bool], Sequence[float], :class:`SortArray`, :class:`SortOrder`, :class:`AllSortString`, :class:`SortByChannel`, :class:`SortByEncoding`, :class:`EncodingSortField`, :class:`SortByChannelDesc`, Sequence[dict, :class:`DateTime`], Literal['-x', '-y', '-color', '-fill', '-stroke', '-strokeWidth', '-size', '-shape', '-fillOpacity', '-strokeOpacity', '-opacity', '-text', 'ascending', 'descending', 'x', 'y', 'color', 'fill', 'stroke', 'strokeWidth', 'size', 'shape', 'fillOpacity', 'strokeOpacity', 'opacity', 'text'] + sort : dict, :class:`Sort`, Sequence[str], Sequence[bool], Sequence[float], :class:`SortArray`, :class:`SortOrder`, :class:`AllSortString`, :class:`SortByChannel`, :class:`SortByEncoding`, :class:`EncodingSortField`, :class:`SortByChannelDesc`, Sequence[dict, :class:`DateTime`], Literal['-x', '-y', '-color', '-fill', '-stroke', '-strokeWidth', '-size', '-shape', '-fillOpacity', '-strokeOpacity', '-opacity', '-text', 'ascending', 'descending', 'x', 'y', 'color', 'fill', 'stroke', 'strokeWidth', 'size', 'shape', 'fillOpacity', 'strokeOpacity', 'opacity', 'text'], None Sort order for the encoded field. For continuous fields (quantitative or temporal), ``sort`` can be either @@ -15957,7 +13797,7 @@ class StrokeWidth( **See also:** `timeUnit `__ documentation. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -16049,27 +13889,23 @@ class StrokeWidth( _encoding_name = "strokeWidth" @overload - def aggregate(self, _: NonArgAggregateOp_T, **kwds) -> StrokeWidth: ... - + def aggregate(self, _: NonArgAggregateOp_T, /) -> StrokeWidth: ... @overload def aggregate( - self, argmax: Optional[str | SchemaBase] = Undefined, **kwds + self, *, argmax: Optional[str | SchemaBase] = Undefined ) -> StrokeWidth: ... - @overload def aggregate( - self, argmin: Optional[str | SchemaBase] = Undefined, **kwds + self, *, argmin: Optional[str | SchemaBase] = Undefined ) -> StrokeWidth: ... - @overload - def bandPosition(self, _: float, **kwds) -> StrokeWidth: ... - + def bandPosition(self, _: float, /) -> StrokeWidth: ... @overload - def bin(self, _: bool, **kwds) -> StrokeWidth: ... - + def bin(self, _: bool | Bin | None, /) -> StrokeWidth: ... @overload def bin( self, + *, anchor: Optional[float] = Undefined, base: Optional[float] = Undefined, binned: Optional[bool] = Undefined, @@ -16080,47 +13916,40 @@ def bin( nice: Optional[bool] = Undefined, step: Optional[float] = Undefined, steps: Optional[Sequence[float]] = Undefined, - **kwds, ) -> StrokeWidth: ... - - @overload - def bin(self, _: None, **kwds) -> StrokeWidth: ... - @overload def condition( self, + *, test: Optional[str | SchemaBase | Map] = Undefined, value: Optional[float | Parameter | SchemaBase | Map] = Undefined, - **kwds, ) -> StrokeWidth: ... - @overload def condition( self, + *, empty: Optional[bool] = Undefined, param: Optional[str | SchemaBase] = Undefined, value: Optional[float | Parameter | SchemaBase | Map] = Undefined, - **kwds, ) -> StrokeWidth: ... - @overload def condition( - self, _: list[core.ConditionalValueDefnumberExprRef], **kwds + self, _: list[core.ConditionalValueDefnumberExprRef], / ) -> StrokeWidth: ... - @overload - def field(self, _: str, **kwds) -> StrokeWidth: ... - + def field(self, _: str | RepeatRef, /) -> StrokeWidth: ... @overload def field( self, + *, repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined, - **kwds, ) -> StrokeWidth: ... - + @overload + def legend(self, _: Legend | None, /) -> StrokeWidth: ... @overload def legend( self, + *, aria: Optional[bool | Parameter | SchemaBase | Map] = Undefined, clipHeight: Optional[float | Parameter | SchemaBase | Map] = Undefined, columnPadding: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -16129,14 +13958,14 @@ def legend( description: Optional[str | Parameter | SchemaBase | Map] = Undefined, direction: Optional[SchemaBase | Orientation_T] = Undefined, fillColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, format: Optional[str | SchemaBase | Map] = Undefined, formatType: Optional[str] = Undefined, gradientLength: Optional[float | Parameter | SchemaBase | Map] = Undefined, gradientOpacity: Optional[float | Parameter | SchemaBase | Map] = Undefined, gradientStrokeColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, gradientStrokeWidth: Optional[float | Parameter | SchemaBase | Map] = Undefined, gradientThickness: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -16146,7 +13975,7 @@ def legend( Parameter | SchemaBase | Map | TextBaseline_T ] = Undefined, labelColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, labelExpr: Optional[str] = Undefined, labelFont: Optional[str | Parameter | SchemaBase | Map] = Undefined, @@ -16170,21 +13999,21 @@ def legend( padding: Optional[float | Parameter | SchemaBase | Map] = Undefined, rowPadding: Optional[float | Parameter | SchemaBase | Map] = Undefined, strokeColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, symbolDash: Optional[ Parameter | SchemaBase | Sequence[float] | Map ] = Undefined, symbolDashOffset: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolFillColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, symbolLimit: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolOffset: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolOpacity: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolSize: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolStrokeColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, symbolStrokeWidth: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolType: Optional[str | Parameter | SchemaBase | Map] = Undefined, @@ -16192,14 +14021,14 @@ def legend( float | Parameter | SchemaBase | Map | TimeInterval_T ] = Undefined, tickMinStep: Optional[float | Parameter | SchemaBase | Map] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, titleAlign: Optional[Parameter | SchemaBase | Map | Align_T] = Undefined, titleAnchor: Optional[Parameter | SchemaBase | Map | TitleAnchor_T] = Undefined, titleBaseline: Optional[ Parameter | SchemaBase | Map | TextBaseline_T ] = Undefined, titleColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, titleFont: Optional[str | Parameter | SchemaBase | Map] = Undefined, titleFontSize: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -16219,19 +14048,17 @@ def legend( | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map ] = Undefined, zindex: Optional[float] = Undefined, - **kwds, ) -> StrokeWidth: ... - @overload - def legend(self, _: None, **kwds) -> StrokeWidth: ... - + def scale(self, _: Scale | None, /) -> StrokeWidth: ... @overload def scale( self, + *, align: Optional[float | Parameter | SchemaBase | Map] = Undefined, base: Optional[float | Parameter | SchemaBase | Map] = Undefined, bins: Optional[SchemaBase | Sequence[float] | Map] = Undefined, @@ -16241,12 +14068,18 @@ def scale( Parameter | SchemaBase | Literal["unaggregated"] - | Sequence[str | bool | None | float | Parameter | SchemaBase | Map] + | Sequence[ + str | bool | float | Temporal | Parameter | SchemaBase | Map | None + ] | Map ] = Undefined, - domainMax: Optional[float | Parameter | SchemaBase | Map] = Undefined, + domainMax: Optional[ + float | Temporal | Parameter | SchemaBase | Map + ] = Undefined, domainMid: Optional[float | Parameter | SchemaBase | Map] = Undefined, - domainMin: Optional[float | Parameter | SchemaBase | Map] = Undefined, + domainMin: Optional[ + float | Temporal | Parameter | SchemaBase | Map + ] = Undefined, domainRaw: Optional[Parameter | SchemaBase | Map] = Undefined, exponent: Optional[float | Parameter | SchemaBase | Map] = Undefined, interpolate: Optional[ @@ -16271,156 +14104,78 @@ def scale( scheme: Optional[Parameter | SchemaBase | Map | ColorScheme_T] = Undefined, type: Optional[SchemaBase | ScaleType_T] = Undefined, zero: Optional[bool | Parameter | SchemaBase | Map] = Undefined, - **kwds, ) -> StrokeWidth: ... - - @overload - def scale(self, _: None, **kwds) -> StrokeWidth: ... - - @overload - def sort(self, _: list[float], **kwds) -> StrokeWidth: ... - - @overload - def sort(self, _: list[str], **kwds) -> StrokeWidth: ... - @overload - def sort(self, _: list[bool], **kwds) -> StrokeWidth: ... - - @overload - def sort(self, _: list[core.DateTime], **kwds) -> StrokeWidth: ... - - @overload - def sort(self, _: SortOrder_T, **kwds) -> StrokeWidth: ... - - @overload - def sort(self, _: SortByChannel_T, **kwds) -> StrokeWidth: ... - - @overload - def sort(self, _: SortByChannelDesc_T, **kwds) -> StrokeWidth: ... - + def sort( + self, + _: Sequence[str] + | Sequence[bool] + | Sequence[float] + | Sequence[DateTime | Temporal] + | AllSortString_T + | None, + /, + ) -> StrokeWidth: ... @overload def sort( self, + *, field: Optional[str | SchemaBase | Map] = Undefined, op: Optional[SchemaBase | NonArgAggregateOp_T] = Undefined, - order: Optional[None | SchemaBase | SortOrder_T] = Undefined, - **kwds, + order: Optional[SchemaBase | SortOrder_T | None] = Undefined, ) -> StrokeWidth: ... - @overload def sort( self, + *, encoding: Optional[SchemaBase | SortByChannel_T] = Undefined, - order: Optional[None | SchemaBase | SortOrder_T] = Undefined, - **kwds, - ) -> StrokeWidth: ... - - @overload - def sort(self, _: None, **kwds) -> StrokeWidth: ... - - @overload - def timeUnit(self, _: LocalSingleTimeUnit_T, **kwds) -> StrokeWidth: ... - - @overload - def timeUnit(self, _: UtcSingleTimeUnit_T, **kwds) -> StrokeWidth: ... - - @overload - def timeUnit(self, _: LocalMultiTimeUnit_T, **kwds) -> StrokeWidth: ... - - @overload - def timeUnit(self, _: UtcMultiTimeUnit_T, **kwds) -> StrokeWidth: ... - - @overload - def timeUnit( - self, - _: Literal[ - "binnedyear", - "binnedyearquarter", - "binnedyearquartermonth", - "binnedyearmonth", - "binnedyearmonthdate", - "binnedyearmonthdatehours", - "binnedyearmonthdatehoursminutes", - "binnedyearmonthdatehoursminutesseconds", - "binnedyearweek", - "binnedyearweekday", - "binnedyearweekdayhours", - "binnedyearweekdayhoursminutes", - "binnedyearweekdayhoursminutesseconds", - "binnedyeardayofyear", - ], - **kwds, + order: Optional[SchemaBase | SortOrder_T | None] = Undefined, ) -> StrokeWidth: ... - @overload def timeUnit( self, - _: Literal[ - "binnedutcyear", - "binnedutcyearquarter", - "binnedutcyearquartermonth", - "binnedutcyearmonth", - "binnedutcyearmonthdate", - "binnedutcyearmonthdatehours", - "binnedutcyearmonthdatehoursminutes", - "binnedutcyearmonthdatehoursminutesseconds", - "binnedutcyearweek", - "binnedutcyearweekday", - "binnedutcyearweekdayhours", - "binnedutcyearweekdayhoursminutes", - "binnedutcyearweekdayhoursminutesseconds", - "binnedutcyeardayofyear", - ], - **kwds, + _: TimeUnitParams | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T, + /, ) -> StrokeWidth: ... - @overload def timeUnit( self, + *, binned: Optional[bool] = Undefined, maxbins: Optional[float] = Undefined, step: Optional[float] = Undefined, unit: Optional[SchemaBase | MultiTimeUnit_T | SingleTimeUnit_T] = Undefined, utc: Optional[bool] = Undefined, - **kwds, ) -> StrokeWidth: ... - - @overload - def title(self, _: str, **kwds) -> StrokeWidth: ... - - @overload - def title(self, _: list[str], **kwds) -> StrokeWidth: ... - @overload - def title(self, _: None, **kwds) -> StrokeWidth: ... - + def title(self, _: str | Sequence[str] | None, /) -> StrokeWidth: ... @overload - def type(self, _: StandardType_T, **kwds) -> StrokeWidth: ... + def type(self, _: StandardType_T, /) -> StrokeWidth: ... def __init__( self, shorthand: Optional[str | SchemaBase | Sequence[str] | Map] = Undefined, aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Map] = Undefined, + bin: Optional[bool | SchemaBase | Map | None] = Undefined, condition: Optional[SchemaBase | Sequence[SchemaBase | Map] | Map] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, sort: Optional[ - None - | SchemaBase + SchemaBase | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map | AllSortString_T + | None ] = Undefined, timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, **kwds, ): @@ -16461,9 +14216,9 @@ class StrokeWidthDatum( **Note:** A field definition's ``condition`` property can only contain `conditional value definitions `__ since Vega-Lite only allows at most one encoded field per encoding channel. - datum : str, bool, dict, None, float, :class:`ExprRef`, :class:`DateTime`, :class:`RepeatRef`, :class:`PrimitiveValue` + datum : str, bool, dict, float, :class:`ExprRef`, :class:`DateTime`, :class:`RepeatRef`, :class:`PrimitiveValue`, None A constant value in data domain. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -16555,48 +14310,37 @@ class StrokeWidthDatum( _encoding_name = "strokeWidth" @overload - def bandPosition(self, _: float, **kwds) -> StrokeWidthDatum: ... - + def bandPosition(self, _: float, /) -> StrokeWidthDatum: ... @overload def condition( self, + *, test: Optional[str | SchemaBase | Map] = Undefined, value: Optional[float | Parameter | SchemaBase | Map] = Undefined, - **kwds, ) -> StrokeWidthDatum: ... - @overload def condition( self, + *, empty: Optional[bool] = Undefined, param: Optional[str | SchemaBase] = Undefined, value: Optional[float | Parameter | SchemaBase | Map] = Undefined, - **kwds, ) -> StrokeWidthDatum: ... - @overload def condition( - self, _: list[core.ConditionalValueDefnumberExprRef], **kwds + self, _: list[core.ConditionalValueDefnumberExprRef], / ) -> StrokeWidthDatum: ... - - @overload - def title(self, _: str, **kwds) -> StrokeWidthDatum: ... - - @overload - def title(self, _: list[str], **kwds) -> StrokeWidthDatum: ... - @overload - def title(self, _: None, **kwds) -> StrokeWidthDatum: ... - + def title(self, _: str | Sequence[str] | None, /) -> StrokeWidthDatum: ... @overload - def type(self, _: Type_T, **kwds) -> StrokeWidthDatum: ... + def type(self, _: Type_T, /) -> StrokeWidthDatum: ... def __init__( self, datum, bandPosition: Optional[float] = Undefined, condition: Optional[SchemaBase | Sequence[SchemaBase | Map] | Map] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | Type_T] = Undefined, **kwds, ): @@ -16633,111 +14377,105 @@ class StrokeWidthValue( @overload def condition( self, + *, aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Map] = Undefined, + bin: Optional[bool | SchemaBase | Map | None] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, sort: Optional[ - None - | SchemaBase + SchemaBase | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map | AllSortString_T + | None ] = Undefined, test: Optional[str | SchemaBase | Map] = Undefined, timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, - **kwds, ) -> StrokeWidthValue: ... - @overload def condition( self, + *, bandPosition: Optional[float] = Undefined, datum: Optional[ - str | bool | None | float | Parameter | SchemaBase | Map + Temporal | Parameter | SchemaBase | Map | PrimitiveValue_T ] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, test: Optional[str | SchemaBase | Map] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | Type_T] = Undefined, - **kwds, ) -> StrokeWidthValue: ... - @overload def condition( self, + *, aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Map] = Undefined, + bin: Optional[bool | SchemaBase | Map | None] = Undefined, empty: Optional[bool] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, param: Optional[str | SchemaBase] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, sort: Optional[ - None - | SchemaBase + SchemaBase | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map | AllSortString_T + | None ] = Undefined, timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, - **kwds, ) -> StrokeWidthValue: ... - @overload def condition( self, + *, bandPosition: Optional[float] = Undefined, datum: Optional[ - str | bool | None | float | Parameter | SchemaBase | Map + Temporal | Parameter | SchemaBase | Map | PrimitiveValue_T ] = Undefined, empty: Optional[bool] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, param: Optional[str | SchemaBase] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | Type_T] = Undefined, - **kwds, ) -> StrokeWidthValue: ... - @overload def condition( self, + *, test: Optional[str | SchemaBase | Map] = Undefined, value: Optional[float | Parameter | SchemaBase | Map] = Undefined, - **kwds, ) -> StrokeWidthValue: ... - @overload def condition( self, + *, empty: Optional[bool] = Undefined, param: Optional[str | SchemaBase] = Undefined, value: Optional[float | Parameter | SchemaBase | Map] = Undefined, - **kwds, ) -> StrokeWidthValue: ... - @overload def condition( - self, _: list[core.ConditionalValueDefnumberExprRef], **kwds + self, _: list[core.ConditionalValueDefnumberExprRef], / ) -> StrokeWidthValue: ... def __init__( @@ -16770,7 +14508,7 @@ class Text(FieldChannelMixin, core.FieldOrDatumDefWithConditionStringFieldDefTex Relative position on a band of a stacked, binned, time unit, or band scale. For example, the marks will be positioned at the beginning of the band if set to ``0``, and at the middle of the band if set to ``0.5``. - bin : bool, dict, None, Literal['binned'], :class:`BinParams` + bin : bool, dict, Literal['binned'], :class:`BinParams`, None A flag for binning a ``quantitative`` field, `an object defining binning parameters `__, or indicating that the data for ``x`` or ``y`` channel are binned before they are imported into @@ -16854,7 +14592,7 @@ class Text(FieldChannelMixin, core.FieldOrDatumDefWithConditionStringFieldDefTex **See also:** `timeUnit `__ documentation. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -16946,27 +14684,19 @@ class Text(FieldChannelMixin, core.FieldOrDatumDefWithConditionStringFieldDefTex _encoding_name = "text" @overload - def aggregate(self, _: NonArgAggregateOp_T, **kwds) -> Text: ... - + def aggregate(self, _: NonArgAggregateOp_T, /) -> Text: ... @overload - def aggregate( - self, argmax: Optional[str | SchemaBase] = Undefined, **kwds - ) -> Text: ... - + def aggregate(self, *, argmax: Optional[str | SchemaBase] = Undefined) -> Text: ... @overload - def aggregate( - self, argmin: Optional[str | SchemaBase] = Undefined, **kwds - ) -> Text: ... - + def aggregate(self, *, argmin: Optional[str | SchemaBase] = Undefined) -> Text: ... @overload - def bandPosition(self, _: float, **kwds) -> Text: ... - + def bandPosition(self, _: float, /) -> Text: ... @overload - def bin(self, _: bool, **kwds) -> Text: ... - + def bin(self, _: bool | Bin | Literal["binned"] | None, /) -> Text: ... @overload def bin( self, + *, anchor: Optional[float] = Undefined, base: Optional[float] = Undefined, binned: Optional[bool] = Undefined, @@ -16977,141 +14707,65 @@ def bin( nice: Optional[bool] = Undefined, step: Optional[float] = Undefined, steps: Optional[Sequence[float]] = Undefined, - **kwds, ) -> Text: ... - - @overload - def bin(self, _: Literal["binned"], **kwds) -> Text: ... - - @overload - def bin(self, _: None, **kwds) -> Text: ... - @overload def condition( self, + *, test: Optional[str | SchemaBase | Map] = Undefined, value: Optional[str | Parameter | SchemaBase | Sequence[str] | Map] = Undefined, - **kwds, ) -> Text: ... - @overload def condition( self, + *, empty: Optional[bool] = Undefined, param: Optional[str | SchemaBase] = Undefined, value: Optional[str | Parameter | SchemaBase | Sequence[str] | Map] = Undefined, - **kwds, ) -> Text: ... - @overload - def condition( - self, _: list[core.ConditionalValueDefTextExprRef], **kwds - ) -> Text: ... - + def condition(self, _: list[core.ConditionalValueDefTextExprRef], /) -> Text: ... @overload - def field(self, _: str, **kwds) -> Text: ... - + def field(self, _: str | RepeatRef, /) -> Text: ... @overload def field( self, + *, repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined, - **kwds, ) -> Text: ... - - @overload - def format(self, _: str, **kwds) -> Text: ... - - @overload - def format(self, _: Map, **kwds) -> Text: ... - - @overload - def formatType(self, _: str, **kwds) -> Text: ... - - @overload - def timeUnit(self, _: LocalSingleTimeUnit_T, **kwds) -> Text: ... - - @overload - def timeUnit(self, _: UtcSingleTimeUnit_T, **kwds) -> Text: ... - @overload - def timeUnit(self, _: LocalMultiTimeUnit_T, **kwds) -> Text: ... - + def format(self, _: str, /) -> Text: ... @overload - def timeUnit(self, _: UtcMultiTimeUnit_T, **kwds) -> Text: ... - + def format(self, _: Map, /) -> Text: ... @overload - def timeUnit( - self, - _: Literal[ - "binnedyear", - "binnedyearquarter", - "binnedyearquartermonth", - "binnedyearmonth", - "binnedyearmonthdate", - "binnedyearmonthdatehours", - "binnedyearmonthdatehoursminutes", - "binnedyearmonthdatehoursminutesseconds", - "binnedyearweek", - "binnedyearweekday", - "binnedyearweekdayhours", - "binnedyearweekdayhoursminutes", - "binnedyearweekdayhoursminutesseconds", - "binnedyeardayofyear", - ], - **kwds, - ) -> Text: ... - + def formatType(self, _: str, /) -> Text: ... @overload def timeUnit( self, - _: Literal[ - "binnedutcyear", - "binnedutcyearquarter", - "binnedutcyearquartermonth", - "binnedutcyearmonth", - "binnedutcyearmonthdate", - "binnedutcyearmonthdatehours", - "binnedutcyearmonthdatehoursminutes", - "binnedutcyearmonthdatehoursminutesseconds", - "binnedutcyearweek", - "binnedutcyearweekday", - "binnedutcyearweekdayhours", - "binnedutcyearweekdayhoursminutes", - "binnedutcyearweekdayhoursminutesseconds", - "binnedutcyeardayofyear", - ], - **kwds, + _: TimeUnitParams | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T, + /, ) -> Text: ... - @overload def timeUnit( self, + *, binned: Optional[bool] = Undefined, maxbins: Optional[float] = Undefined, step: Optional[float] = Undefined, unit: Optional[SchemaBase | MultiTimeUnit_T | SingleTimeUnit_T] = Undefined, utc: Optional[bool] = Undefined, - **kwds, ) -> Text: ... - - @overload - def title(self, _: str, **kwds) -> Text: ... - - @overload - def title(self, _: list[str], **kwds) -> Text: ... - @overload - def title(self, _: None, **kwds) -> Text: ... - + def title(self, _: str | Sequence[str] | None, /) -> Text: ... @overload - def type(self, _: StandardType_T, **kwds) -> Text: ... + def type(self, _: StandardType_T, /) -> Text: ... def __init__( self, shorthand: Optional[str | SchemaBase | Sequence[str] | Map] = Undefined, aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Literal["binned"] | Map] = Undefined, + bin: Optional[bool | SchemaBase | Literal["binned"] | Map | None] = Undefined, condition: Optional[SchemaBase | Sequence[SchemaBase | Map] | Map] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, format: Optional[str | SchemaBase | Map] = Undefined, @@ -17119,7 +14773,7 @@ def __init__( timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, **kwds, ): @@ -17157,7 +14811,7 @@ class TextDatum(DatumChannelMixin, core.FieldOrDatumDefWithConditionStringDatumD **Note:** A field definition's ``condition`` property can only contain `conditional value definitions `__ since Vega-Lite only allows at most one encoded field per encoding channel. - datum : str, bool, dict, None, float, :class:`ExprRef`, :class:`DateTime`, :class:`RepeatRef`, :class:`PrimitiveValue` + datum : str, bool, dict, float, :class:`ExprRef`, :class:`DateTime`, :class:`RepeatRef`, :class:`PrimitiveValue`, None A constant value in data domain. format : str, dict, :class:`Dict` When used with the default ``"number"`` and ``"time"`` format type, the text @@ -17191,7 +14845,7 @@ class TextDatum(DatumChannelMixin, core.FieldOrDatumDefWithConditionStringDatumD * ``"time"`` for temporal fields and ordinal and nominal fields with ``timeUnit``. * ``"number"`` for quantitative fields as well as ordinal and nominal fields without ``timeUnit``. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -17283,50 +14937,36 @@ class TextDatum(DatumChannelMixin, core.FieldOrDatumDefWithConditionStringDatumD _encoding_name = "text" @overload - def bandPosition(self, _: float, **kwds) -> TextDatum: ... - + def bandPosition(self, _: float, /) -> TextDatum: ... @overload def condition( self, + *, test: Optional[str | SchemaBase | Map] = Undefined, value: Optional[str | Parameter | SchemaBase | Sequence[str] | Map] = Undefined, - **kwds, ) -> TextDatum: ... - @overload def condition( self, + *, empty: Optional[bool] = Undefined, param: Optional[str | SchemaBase] = Undefined, value: Optional[str | Parameter | SchemaBase | Sequence[str] | Map] = Undefined, - **kwds, ) -> TextDatum: ... - @overload def condition( - self, _: list[core.ConditionalValueDefTextExprRef], **kwds + self, _: list[core.ConditionalValueDefTextExprRef], / ) -> TextDatum: ... - - @overload - def format(self, _: str, **kwds) -> TextDatum: ... - - @overload - def format(self, _: Map, **kwds) -> TextDatum: ... - @overload - def formatType(self, _: str, **kwds) -> TextDatum: ... - + def format(self, _: str, /) -> TextDatum: ... @overload - def title(self, _: str, **kwds) -> TextDatum: ... - + def format(self, _: Map, /) -> TextDatum: ... @overload - def title(self, _: list[str], **kwds) -> TextDatum: ... - + def formatType(self, _: str, /) -> TextDatum: ... @overload - def title(self, _: None, **kwds) -> TextDatum: ... - + def title(self, _: str | Sequence[str] | None, /) -> TextDatum: ... @overload - def type(self, _: Type_T, **kwds) -> TextDatum: ... + def type(self, _: Type_T, /) -> TextDatum: ... def __init__( self, @@ -17335,7 +14975,7 @@ def __init__( condition: Optional[SchemaBase | Sequence[SchemaBase | Map] | Map] = Undefined, format: Optional[str | SchemaBase | Map] = Undefined, formatType: Optional[str] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | Type_T] = Undefined, **kwds, ): @@ -17372,9 +15012,10 @@ class TextValue(ValueChannelMixin, core.ValueDefWithConditionStringFieldDefText) @overload def condition( self, + *, aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Literal["binned"] | Map] = Undefined, + bin: Optional[bool | SchemaBase | Literal["binned"] | Map | None] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, format: Optional[str | SchemaBase | Map] = Undefined, formatType: Optional[str] = Undefined, @@ -17382,17 +15023,16 @@ def condition( timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, - **kwds, ) -> TextValue: ... - @overload def condition( self, + *, aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Literal["binned"] | Map] = Undefined, + bin: Optional[bool | SchemaBase | Literal["binned"] | Map | None] = Undefined, empty: Optional[bool] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, format: Optional[str | SchemaBase | Map] = Undefined, @@ -17401,31 +15041,27 @@ def condition( timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, - **kwds, ) -> TextValue: ... - @overload def condition( self, + *, test: Optional[str | SchemaBase | Map] = Undefined, value: Optional[str | Parameter | SchemaBase | Sequence[str] | Map] = Undefined, - **kwds, ) -> TextValue: ... - @overload def condition( self, + *, empty: Optional[bool] = Undefined, param: Optional[str | SchemaBase] = Undefined, value: Optional[str | Parameter | SchemaBase | Sequence[str] | Map] = Undefined, - **kwds, ) -> TextValue: ... - @overload def condition( - self, _: list[core.ConditionalValueDefTextExprRef], **kwds + self, _: list[core.ConditionalValueDefTextExprRef], / ) -> TextValue: ... def __init__( @@ -17458,7 +15094,7 @@ class Theta(FieldChannelMixin, core.PositionFieldDefBase): Relative position on a band of a stacked, binned, time unit, or band scale. For example, the marks will be positioned at the beginning of the band if set to ``0``, and at the middle of the band if set to ``0.5``. - bin : bool, dict, None, Literal['binned'], :class:`BinParams` + bin : bool, dict, Literal['binned'], :class:`BinParams`, None A flag for binning a ``quantitative`` field, `an object defining binning parameters `__, or indicating that the data for ``x`` or ``y`` channel are binned before they are imported into @@ -17494,7 +15130,7 @@ class Theta(FieldChannelMixin, core.PositionFieldDefBase): about escaping in the `field documentation `__. 2) ``field`` is not required if ``aggregate`` is ``count``. - scale : dict, None, :class:`Scale` + scale : dict, :class:`Scale`, None An object defining properties of the channel's scale, which is the function that transforms values in the data domain (numbers, dates, strings, etc) to visual values (pixels, colors, sizes) of the encoding channels. @@ -17507,7 +15143,7 @@ class Theta(FieldChannelMixin, core.PositionFieldDefBase): **See also:** `scale `__ documentation. - sort : dict, None, :class:`Sort`, Sequence[str], Sequence[bool], Sequence[float], :class:`SortArray`, :class:`SortOrder`, :class:`AllSortString`, :class:`SortByChannel`, :class:`SortByEncoding`, :class:`EncodingSortField`, :class:`SortByChannelDesc`, Sequence[dict, :class:`DateTime`], Literal['-x', '-y', '-color', '-fill', '-stroke', '-strokeWidth', '-size', '-shape', '-fillOpacity', '-strokeOpacity', '-opacity', '-text', 'ascending', 'descending', 'x', 'y', 'color', 'fill', 'stroke', 'strokeWidth', 'size', 'shape', 'fillOpacity', 'strokeOpacity', 'opacity', 'text'] + sort : dict, :class:`Sort`, Sequence[str], Sequence[bool], Sequence[float], :class:`SortArray`, :class:`SortOrder`, :class:`AllSortString`, :class:`SortByChannel`, :class:`SortByEncoding`, :class:`EncodingSortField`, :class:`SortByChannelDesc`, Sequence[dict, :class:`DateTime`], Literal['-x', '-y', '-color', '-fill', '-stroke', '-strokeWidth', '-size', '-shape', '-fillOpacity', '-strokeOpacity', '-opacity', '-text', 'ascending', 'descending', 'x', 'y', 'color', 'fill', 'stroke', 'strokeWidth', 'size', 'shape', 'fillOpacity', 'strokeOpacity', 'opacity', 'text'], None Sort order for the encoded field. For continuous fields (quantitative or temporal), ``sort`` can be either @@ -17545,7 +15181,7 @@ class Theta(FieldChannelMixin, core.PositionFieldDefBase): **See also:** `sort `__ documentation. - stack : bool, None, :class:`StackOffset`, Literal['zero', 'center', 'normalize'] + stack : bool, :class:`StackOffset`, Literal['zero', 'center', 'normalize'], None Type of stacking offset if the field should be stacked. ``stack`` is only applicable for ``x``, ``y``, ``theta``, and ``radius`` channels with continuous domains. For example, ``stack`` of ``y`` can be used to customize stacking for a vertical bar @@ -17584,7 +15220,7 @@ class Theta(FieldChannelMixin, core.PositionFieldDefBase): **See also:** `timeUnit `__ documentation. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -17676,27 +15312,19 @@ class Theta(FieldChannelMixin, core.PositionFieldDefBase): _encoding_name = "theta" @overload - def aggregate(self, _: NonArgAggregateOp_T, **kwds) -> Theta: ... - + def aggregate(self, _: NonArgAggregateOp_T, /) -> Theta: ... @overload - def aggregate( - self, argmax: Optional[str | SchemaBase] = Undefined, **kwds - ) -> Theta: ... - + def aggregate(self, *, argmax: Optional[str | SchemaBase] = Undefined) -> Theta: ... @overload - def aggregate( - self, argmin: Optional[str | SchemaBase] = Undefined, **kwds - ) -> Theta: ... - + def aggregate(self, *, argmin: Optional[str | SchemaBase] = Undefined) -> Theta: ... @overload - def bandPosition(self, _: float, **kwds) -> Theta: ... - + def bandPosition(self, _: float, /) -> Theta: ... @overload - def bin(self, _: bool, **kwds) -> Theta: ... - + def bin(self, _: bool | Bin | Literal["binned"] | None, /) -> Theta: ... @overload def bin( self, + *, anchor: Optional[float] = Undefined, base: Optional[float] = Undefined, binned: Optional[bool] = Undefined, @@ -17707,28 +15335,21 @@ def bin( nice: Optional[bool] = Undefined, step: Optional[float] = Undefined, steps: Optional[Sequence[float]] = Undefined, - **kwds, ) -> Theta: ... - - @overload - def bin(self, _: Literal["binned"], **kwds) -> Theta: ... - @overload - def bin(self, _: None, **kwds) -> Theta: ... - - @overload - def field(self, _: str, **kwds) -> Theta: ... - + def field(self, _: str | RepeatRef, /) -> Theta: ... @overload def field( self, + *, repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined, - **kwds, ) -> Theta: ... - + @overload + def scale(self, _: Scale | None, /) -> Theta: ... @overload def scale( self, + *, align: Optional[float | Parameter | SchemaBase | Map] = Undefined, base: Optional[float | Parameter | SchemaBase | Map] = Undefined, bins: Optional[SchemaBase | Sequence[float] | Map] = Undefined, @@ -17738,12 +15359,18 @@ def scale( Parameter | SchemaBase | Literal["unaggregated"] - | Sequence[str | bool | None | float | Parameter | SchemaBase | Map] + | Sequence[ + str | bool | float | Temporal | Parameter | SchemaBase | Map | None + ] | Map ] = Undefined, - domainMax: Optional[float | Parameter | SchemaBase | Map] = Undefined, + domainMax: Optional[ + float | Temporal | Parameter | SchemaBase | Map + ] = Undefined, domainMid: Optional[float | Parameter | SchemaBase | Map] = Undefined, - domainMin: Optional[float | Parameter | SchemaBase | Map] = Undefined, + domainMin: Optional[ + float | Temporal | Parameter | SchemaBase | Map + ] = Undefined, domainRaw: Optional[Parameter | SchemaBase | Map] = Undefined, exponent: Optional[float | Parameter | SchemaBase | Map] = Undefined, interpolate: Optional[ @@ -17768,164 +15395,79 @@ def scale( scheme: Optional[Parameter | SchemaBase | Map | ColorScheme_T] = Undefined, type: Optional[SchemaBase | ScaleType_T] = Undefined, zero: Optional[bool | Parameter | SchemaBase | Map] = Undefined, - **kwds, ) -> Theta: ... - - @overload - def scale(self, _: None, **kwds) -> Theta: ... - - @overload - def sort(self, _: list[float], **kwds) -> Theta: ... - - @overload - def sort(self, _: list[str], **kwds) -> Theta: ... - - @overload - def sort(self, _: list[bool], **kwds) -> Theta: ... - - @overload - def sort(self, _: list[core.DateTime], **kwds) -> Theta: ... - - @overload - def sort(self, _: SortOrder_T, **kwds) -> Theta: ... - - @overload - def sort(self, _: SortByChannel_T, **kwds) -> Theta: ... - @overload - def sort(self, _: SortByChannelDesc_T, **kwds) -> Theta: ... - + def sort( + self, + _: Sequence[str] + | Sequence[bool] + | Sequence[float] + | Sequence[DateTime | Temporal] + | AllSortString_T + | None, + /, + ) -> Theta: ... @overload def sort( self, + *, field: Optional[str | SchemaBase | Map] = Undefined, op: Optional[SchemaBase | NonArgAggregateOp_T] = Undefined, - order: Optional[None | SchemaBase | SortOrder_T] = Undefined, - **kwds, + order: Optional[SchemaBase | SortOrder_T | None] = Undefined, ) -> Theta: ... - @overload def sort( self, + *, encoding: Optional[SchemaBase | SortByChannel_T] = Undefined, - order: Optional[None | SchemaBase | SortOrder_T] = Undefined, - **kwds, + order: Optional[SchemaBase | SortOrder_T | None] = Undefined, ) -> Theta: ... - - @overload - def sort(self, _: None, **kwds) -> Theta: ... - - @overload - def stack(self, _: StackOffset_T, **kwds) -> Theta: ... - - @overload - def stack(self, _: None, **kwds) -> Theta: ... - - @overload - def stack(self, _: bool, **kwds) -> Theta: ... - - @overload - def timeUnit(self, _: LocalSingleTimeUnit_T, **kwds) -> Theta: ... - - @overload - def timeUnit(self, _: UtcSingleTimeUnit_T, **kwds) -> Theta: ... - - @overload - def timeUnit(self, _: LocalMultiTimeUnit_T, **kwds) -> Theta: ... - - @overload - def timeUnit(self, _: UtcMultiTimeUnit_T, **kwds) -> Theta: ... - @overload - def timeUnit( - self, - _: Literal[ - "binnedyear", - "binnedyearquarter", - "binnedyearquartermonth", - "binnedyearmonth", - "binnedyearmonthdate", - "binnedyearmonthdatehours", - "binnedyearmonthdatehoursminutes", - "binnedyearmonthdatehoursminutesseconds", - "binnedyearweek", - "binnedyearweekday", - "binnedyearweekdayhours", - "binnedyearweekdayhoursminutes", - "binnedyearweekdayhoursminutesseconds", - "binnedyeardayofyear", - ], - **kwds, - ) -> Theta: ... - + def stack(self, _: bool | StackOffset_T | None, /) -> Theta: ... @overload def timeUnit( self, - _: Literal[ - "binnedutcyear", - "binnedutcyearquarter", - "binnedutcyearquartermonth", - "binnedutcyearmonth", - "binnedutcyearmonthdate", - "binnedutcyearmonthdatehours", - "binnedutcyearmonthdatehoursminutes", - "binnedutcyearmonthdatehoursminutesseconds", - "binnedutcyearweek", - "binnedutcyearweekday", - "binnedutcyearweekdayhours", - "binnedutcyearweekdayhoursminutes", - "binnedutcyearweekdayhoursminutesseconds", - "binnedutcyeardayofyear", - ], - **kwds, + _: TimeUnitParams | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T, + /, ) -> Theta: ... - @overload def timeUnit( self, + *, binned: Optional[bool] = Undefined, maxbins: Optional[float] = Undefined, step: Optional[float] = Undefined, unit: Optional[SchemaBase | MultiTimeUnit_T | SingleTimeUnit_T] = Undefined, utc: Optional[bool] = Undefined, - **kwds, ) -> Theta: ... - - @overload - def title(self, _: str, **kwds) -> Theta: ... - @overload - def title(self, _: list[str], **kwds) -> Theta: ... - - @overload - def title(self, _: None, **kwds) -> Theta: ... - + def title(self, _: str | Sequence[str] | None, /) -> Theta: ... @overload - def type(self, _: StandardType_T, **kwds) -> Theta: ... + def type(self, _: StandardType_T, /) -> Theta: ... def __init__( self, shorthand: Optional[str | SchemaBase | Sequence[str] | Map] = Undefined, aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Literal["binned"] | Map] = Undefined, + bin: Optional[bool | SchemaBase | Literal["binned"] | Map | None] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, sort: Optional[ - None - | SchemaBase + SchemaBase | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map | AllSortString_T + | None ] = Undefined, - stack: Optional[bool | None | SchemaBase | StackOffset_T] = Undefined, + stack: Optional[bool | SchemaBase | StackOffset_T | None] = Undefined, timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, **kwds, ): @@ -17956,9 +15498,9 @@ class ThetaDatum(DatumChannelMixin, core.PositionDatumDefBase): Relative position on a band of a stacked, binned, time unit, or band scale. For example, the marks will be positioned at the beginning of the band if set to ``0``, and at the middle of the band if set to ``0.5``. - datum : str, bool, dict, None, float, :class:`ExprRef`, :class:`DateTime`, :class:`RepeatRef`, :class:`PrimitiveValue` + datum : str, bool, dict, float, :class:`ExprRef`, :class:`DateTime`, :class:`RepeatRef`, :class:`PrimitiveValue`, None A constant value in data domain. - scale : dict, None, :class:`Scale` + scale : dict, :class:`Scale`, None An object defining properties of the channel's scale, which is the function that transforms values in the data domain (numbers, dates, strings, etc) to visual values (pixels, colors, sizes) of the encoding channels. @@ -17971,7 +15513,7 @@ class ThetaDatum(DatumChannelMixin, core.PositionDatumDefBase): **See also:** `scale `__ documentation. - stack : bool, None, :class:`StackOffset`, Literal['zero', 'center', 'normalize'] + stack : bool, :class:`StackOffset`, Literal['zero', 'center', 'normalize'], None Type of stacking offset if the field should be stacked. ``stack`` is only applicable for ``x``, ``y``, ``theta``, and ``radius`` channels with continuous domains. For example, ``stack`` of ``y`` can be used to customize stacking for a vertical bar @@ -18001,7 +15543,7 @@ class ThetaDatum(DatumChannelMixin, core.PositionDatumDefBase): **See also:** `stack `__ documentation. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -18093,11 +15635,13 @@ class ThetaDatum(DatumChannelMixin, core.PositionDatumDefBase): _encoding_name = "theta" @overload - def bandPosition(self, _: float, **kwds) -> ThetaDatum: ... - + def bandPosition(self, _: float, /) -> ThetaDatum: ... + @overload + def scale(self, _: Scale | None, /) -> ThetaDatum: ... @overload def scale( self, + *, align: Optional[float | Parameter | SchemaBase | Map] = Undefined, base: Optional[float | Parameter | SchemaBase | Map] = Undefined, bins: Optional[SchemaBase | Sequence[float] | Map] = Undefined, @@ -18107,12 +15651,18 @@ def scale( Parameter | SchemaBase | Literal["unaggregated"] - | Sequence[str | bool | None | float | Parameter | SchemaBase | Map] + | Sequence[ + str | bool | float | Temporal | Parameter | SchemaBase | Map | None + ] | Map ] = Undefined, - domainMax: Optional[float | Parameter | SchemaBase | Map] = Undefined, + domainMax: Optional[ + float | Temporal | Parameter | SchemaBase | Map + ] = Undefined, domainMid: Optional[float | Parameter | SchemaBase | Map] = Undefined, - domainMin: Optional[float | Parameter | SchemaBase | Map] = Undefined, + domainMin: Optional[ + float | Temporal | Parameter | SchemaBase | Map + ] = Undefined, domainRaw: Optional[Parameter | SchemaBase | Map] = Undefined, exponent: Optional[float | Parameter | SchemaBase | Map] = Undefined, interpolate: Optional[ @@ -18137,40 +15687,21 @@ def scale( scheme: Optional[Parameter | SchemaBase | Map | ColorScheme_T] = Undefined, type: Optional[SchemaBase | ScaleType_T] = Undefined, zero: Optional[bool | Parameter | SchemaBase | Map] = Undefined, - **kwds, ) -> ThetaDatum: ... - - @overload - def scale(self, _: None, **kwds) -> ThetaDatum: ... - - @overload - def stack(self, _: StackOffset_T, **kwds) -> ThetaDatum: ... - @overload - def stack(self, _: None, **kwds) -> ThetaDatum: ... - - @overload - def stack(self, _: bool, **kwds) -> ThetaDatum: ... - - @overload - def title(self, _: str, **kwds) -> ThetaDatum: ... - - @overload - def title(self, _: list[str], **kwds) -> ThetaDatum: ... - + def stack(self, _: bool | StackOffset_T | None, /) -> ThetaDatum: ... @overload - def title(self, _: None, **kwds) -> ThetaDatum: ... - + def title(self, _: str | Sequence[str] | None, /) -> ThetaDatum: ... @overload - def type(self, _: Type_T, **kwds) -> ThetaDatum: ... + def type(self, _: Type_T, /) -> ThetaDatum: ... def __init__( self, datum, bandPosition: Optional[float] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, - stack: Optional[bool | None | SchemaBase | StackOffset_T] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, + stack: Optional[bool | SchemaBase | StackOffset_T | None] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | Type_T] = Undefined, **kwds, ): @@ -18277,7 +15808,7 @@ class Theta2(FieldChannelMixin, core.SecondaryFieldDef): **See also:** `timeUnit `__ documentation. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -18303,109 +15834,45 @@ class Theta2(FieldChannelMixin, core.SecondaryFieldDef): _encoding_name = "theta2" @overload - def aggregate(self, _: NonArgAggregateOp_T, **kwds) -> Theta2: ... - + def aggregate(self, _: NonArgAggregateOp_T, /) -> Theta2: ... @overload def aggregate( - self, argmax: Optional[str | SchemaBase] = Undefined, **kwds + self, *, argmax: Optional[str | SchemaBase] = Undefined ) -> Theta2: ... - @overload def aggregate( - self, argmin: Optional[str | SchemaBase] = Undefined, **kwds + self, *, argmin: Optional[str | SchemaBase] = Undefined ) -> Theta2: ... - @overload - def bandPosition(self, _: float, **kwds) -> Theta2: ... - + def bandPosition(self, _: float, /) -> Theta2: ... @overload - def bin(self, _: None, **kwds) -> Theta2: ... - + def bin(self, _: None, /) -> Theta2: ... @overload - def field(self, _: str, **kwds) -> Theta2: ... - + def field(self, _: str | RepeatRef, /) -> Theta2: ... @overload def field( self, + *, repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined, - **kwds, - ) -> Theta2: ... - - @overload - def timeUnit(self, _: LocalSingleTimeUnit_T, **kwds) -> Theta2: ... - - @overload - def timeUnit(self, _: UtcSingleTimeUnit_T, **kwds) -> Theta2: ... - - @overload - def timeUnit(self, _: LocalMultiTimeUnit_T, **kwds) -> Theta2: ... - - @overload - def timeUnit(self, _: UtcMultiTimeUnit_T, **kwds) -> Theta2: ... - - @overload - def timeUnit( - self, - _: Literal[ - "binnedyear", - "binnedyearquarter", - "binnedyearquartermonth", - "binnedyearmonth", - "binnedyearmonthdate", - "binnedyearmonthdatehours", - "binnedyearmonthdatehoursminutes", - "binnedyearmonthdatehoursminutesseconds", - "binnedyearweek", - "binnedyearweekday", - "binnedyearweekdayhours", - "binnedyearweekdayhoursminutes", - "binnedyearweekdayhoursminutesseconds", - "binnedyeardayofyear", - ], - **kwds, ) -> Theta2: ... - @overload def timeUnit( self, - _: Literal[ - "binnedutcyear", - "binnedutcyearquarter", - "binnedutcyearquartermonth", - "binnedutcyearmonth", - "binnedutcyearmonthdate", - "binnedutcyearmonthdatehours", - "binnedutcyearmonthdatehoursminutes", - "binnedutcyearmonthdatehoursminutesseconds", - "binnedutcyearweek", - "binnedutcyearweekday", - "binnedutcyearweekdayhours", - "binnedutcyearweekdayhoursminutes", - "binnedutcyearweekdayhoursminutesseconds", - "binnedutcyeardayofyear", - ], - **kwds, + _: TimeUnitParams | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T, + /, ) -> Theta2: ... - @overload def timeUnit( self, + *, binned: Optional[bool] = Undefined, maxbins: Optional[float] = Undefined, step: Optional[float] = Undefined, unit: Optional[SchemaBase | MultiTimeUnit_T | SingleTimeUnit_T] = Undefined, utc: Optional[bool] = Undefined, - **kwds, ) -> Theta2: ... - - @overload - def title(self, _: str, **kwds) -> Theta2: ... - @overload - def title(self, _: list[str], **kwds) -> Theta2: ... - - @overload - def title(self, _: None, **kwds) -> Theta2: ... + def title(self, _: str | Sequence[str] | None, /) -> Theta2: ... def __init__( self, @@ -18417,7 +15884,7 @@ def __init__( timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, **kwds, ): super().__init__( @@ -18443,9 +15910,9 @@ class Theta2Datum(DatumChannelMixin, core.DatumDef): Relative position on a band of a stacked, binned, time unit, or band scale. For example, the marks will be positioned at the beginning of the band if set to ``0``, and at the middle of the band if set to ``0.5``. - datum : str, bool, dict, None, float, :class:`ExprRef`, :class:`DateTime`, :class:`RepeatRef`, :class:`PrimitiveValue` + datum : str, bool, dict, float, :class:`ExprRef`, :class:`DateTime`, :class:`RepeatRef`, :class:`PrimitiveValue`, None A constant value in data domain. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -18537,25 +16004,17 @@ class Theta2Datum(DatumChannelMixin, core.DatumDef): _encoding_name = "theta2" @overload - def bandPosition(self, _: float, **kwds) -> Theta2Datum: ... - - @overload - def title(self, _: str, **kwds) -> Theta2Datum: ... - - @overload - def title(self, _: list[str], **kwds) -> Theta2Datum: ... - + def bandPosition(self, _: float, /) -> Theta2Datum: ... @overload - def title(self, _: None, **kwds) -> Theta2Datum: ... - + def title(self, _: str | Sequence[str] | None, /) -> Theta2Datum: ... @overload - def type(self, _: Type_T, **kwds) -> Theta2Datum: ... + def type(self, _: Type_T, /) -> Theta2Datum: ... def __init__( self, datum, bandPosition: Optional[float] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | Type_T] = Undefined, **kwds, ): @@ -18608,7 +16067,7 @@ class Tooltip(FieldChannelMixin, core.StringFieldDefWithCondition): Relative position on a band of a stacked, binned, time unit, or band scale. For example, the marks will be positioned at the beginning of the band if set to ``0``, and at the middle of the band if set to ``0.5``. - bin : bool, dict, None, Literal['binned'], :class:`BinParams` + bin : bool, dict, Literal['binned'], :class:`BinParams`, None A flag for binning a ``quantitative`` field, `an object defining binning parameters `__, or indicating that the data for ``x`` or ``y`` channel are binned before they are imported into @@ -18692,7 +16151,7 @@ class Tooltip(FieldChannelMixin, core.StringFieldDefWithCondition): **See also:** `timeUnit `__ documentation. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -18784,27 +16243,23 @@ class Tooltip(FieldChannelMixin, core.StringFieldDefWithCondition): _encoding_name = "tooltip" @overload - def aggregate(self, _: NonArgAggregateOp_T, **kwds) -> Tooltip: ... - + def aggregate(self, _: NonArgAggregateOp_T, /) -> Tooltip: ... @overload def aggregate( - self, argmax: Optional[str | SchemaBase] = Undefined, **kwds + self, *, argmax: Optional[str | SchemaBase] = Undefined ) -> Tooltip: ... - @overload def aggregate( - self, argmin: Optional[str | SchemaBase] = Undefined, **kwds + self, *, argmin: Optional[str | SchemaBase] = Undefined ) -> Tooltip: ... - @overload - def bandPosition(self, _: float, **kwds) -> Tooltip: ... - + def bandPosition(self, _: float, /) -> Tooltip: ... @overload - def bin(self, _: bool, **kwds) -> Tooltip: ... - + def bin(self, _: bool | Bin | Literal["binned"] | None, /) -> Tooltip: ... @overload def bin( self, + *, anchor: Optional[float] = Undefined, base: Optional[float] = Undefined, binned: Optional[bool] = Undefined, @@ -18815,141 +16270,67 @@ def bin( nice: Optional[bool] = Undefined, step: Optional[float] = Undefined, steps: Optional[Sequence[float]] = Undefined, - **kwds, ) -> Tooltip: ... - - @overload - def bin(self, _: Literal["binned"], **kwds) -> Tooltip: ... - - @overload - def bin(self, _: None, **kwds) -> Tooltip: ... - @overload def condition( self, + *, test: Optional[str | SchemaBase | Map] = Undefined, value: Optional[str | Parameter | SchemaBase | Map] = Undefined, - **kwds, ) -> Tooltip: ... - @overload def condition( self, + *, empty: Optional[bool] = Undefined, param: Optional[str | SchemaBase] = Undefined, value: Optional[str | Parameter | SchemaBase | Map] = Undefined, - **kwds, ) -> Tooltip: ... - @overload def condition( - self, _: list[core.ConditionalValueDefstringExprRef], **kwds + self, _: list[core.ConditionalValueDefstringExprRef], / ) -> Tooltip: ... - @overload - def field(self, _: str, **kwds) -> Tooltip: ... - + def field(self, _: str | RepeatRef, /) -> Tooltip: ... @overload def field( self, + *, repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined, - **kwds, ) -> Tooltip: ... - - @overload - def format(self, _: str, **kwds) -> Tooltip: ... - - @overload - def format(self, _: Map, **kwds) -> Tooltip: ... - - @overload - def formatType(self, _: str, **kwds) -> Tooltip: ... - - @overload - def timeUnit(self, _: LocalSingleTimeUnit_T, **kwds) -> Tooltip: ... - - @overload - def timeUnit(self, _: UtcSingleTimeUnit_T, **kwds) -> Tooltip: ... - @overload - def timeUnit(self, _: LocalMultiTimeUnit_T, **kwds) -> Tooltip: ... - + def format(self, _: str, /) -> Tooltip: ... @overload - def timeUnit(self, _: UtcMultiTimeUnit_T, **kwds) -> Tooltip: ... - + def format(self, _: Map, /) -> Tooltip: ... @overload - def timeUnit( - self, - _: Literal[ - "binnedyear", - "binnedyearquarter", - "binnedyearquartermonth", - "binnedyearmonth", - "binnedyearmonthdate", - "binnedyearmonthdatehours", - "binnedyearmonthdatehoursminutes", - "binnedyearmonthdatehoursminutesseconds", - "binnedyearweek", - "binnedyearweekday", - "binnedyearweekdayhours", - "binnedyearweekdayhoursminutes", - "binnedyearweekdayhoursminutesseconds", - "binnedyeardayofyear", - ], - **kwds, - ) -> Tooltip: ... - + def formatType(self, _: str, /) -> Tooltip: ... @overload def timeUnit( self, - _: Literal[ - "binnedutcyear", - "binnedutcyearquarter", - "binnedutcyearquartermonth", - "binnedutcyearmonth", - "binnedutcyearmonthdate", - "binnedutcyearmonthdatehours", - "binnedutcyearmonthdatehoursminutes", - "binnedutcyearmonthdatehoursminutesseconds", - "binnedutcyearweek", - "binnedutcyearweekday", - "binnedutcyearweekdayhours", - "binnedutcyearweekdayhoursminutes", - "binnedutcyearweekdayhoursminutesseconds", - "binnedutcyeardayofyear", - ], - **kwds, + _: TimeUnitParams | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T, + /, ) -> Tooltip: ... - @overload def timeUnit( self, + *, binned: Optional[bool] = Undefined, maxbins: Optional[float] = Undefined, step: Optional[float] = Undefined, unit: Optional[SchemaBase | MultiTimeUnit_T | SingleTimeUnit_T] = Undefined, utc: Optional[bool] = Undefined, - **kwds, ) -> Tooltip: ... - - @overload - def title(self, _: str, **kwds) -> Tooltip: ... - - @overload - def title(self, _: list[str], **kwds) -> Tooltip: ... - @overload - def title(self, _: None, **kwds) -> Tooltip: ... - + def title(self, _: str | Sequence[str] | None, /) -> Tooltip: ... @overload - def type(self, _: StandardType_T, **kwds) -> Tooltip: ... + def type(self, _: StandardType_T, /) -> Tooltip: ... def __init__( self, shorthand: Optional[str | SchemaBase | Sequence[str] | Map] = Undefined, aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Literal["binned"] | Map] = Undefined, + bin: Optional[bool | SchemaBase | Literal["binned"] | Map | None] = Undefined, condition: Optional[SchemaBase | Sequence[SchemaBase | Map] | Map] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, format: Optional[str | SchemaBase | Map] = Undefined, @@ -18957,7 +16338,7 @@ def __init__( timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, **kwds, ): @@ -18986,7 +16367,7 @@ class TooltipValue(ValueChannelMixin, core.StringValueDefWithCondition): ---------- condition : dict, :class:`ConditionalMarkPropFieldOrDatumDef`, :class:`ConditionalValueDefstringnullExprRef`, :class:`ConditionalParameterMarkPropFieldOrDatumDef`, :class:`ConditionalPredicateMarkPropFieldOrDatumDef`, :class:`ConditionalParameterValueDefstringnullExprRef`, :class:`ConditionalPredicateValueDefstringnullExprRef`, Sequence[dict, :class:`ConditionalValueDefstringnullExprRef`, :class:`ConditionalParameterValueDefstringnullExprRef`, :class:`ConditionalPredicateValueDefstringnullExprRef`] A field definition or one or more value definition(s) with a parameter predicate. - value : str, dict, None, :class:`ExprRef` + value : str, dict, :class:`ExprRef`, None A constant value in visual domain (e.g., ``"red"`` / ``"#0099ff"`` / `gradient definition `__ for color, values between ``0`` to ``1`` for opacity). @@ -18998,111 +16379,105 @@ class TooltipValue(ValueChannelMixin, core.StringValueDefWithCondition): @overload def condition( self, + *, aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Map] = Undefined, + bin: Optional[bool | SchemaBase | Map | None] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, sort: Optional[ - None - | SchemaBase + SchemaBase | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map | AllSortString_T + | None ] = Undefined, test: Optional[str | SchemaBase | Map] = Undefined, timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, - **kwds, ) -> TooltipValue: ... - @overload def condition( self, + *, bandPosition: Optional[float] = Undefined, datum: Optional[ - str | bool | None | float | Parameter | SchemaBase | Map + Temporal | Parameter | SchemaBase | Map | PrimitiveValue_T ] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, test: Optional[str | SchemaBase | Map] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | Type_T] = Undefined, - **kwds, ) -> TooltipValue: ... - @overload def condition( self, + *, aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Map] = Undefined, + bin: Optional[bool | SchemaBase | Map | None] = Undefined, empty: Optional[bool] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, param: Optional[str | SchemaBase] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, sort: Optional[ - None - | SchemaBase + SchemaBase | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map | AllSortString_T + | None ] = Undefined, timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, - **kwds, ) -> TooltipValue: ... - @overload def condition( self, + *, bandPosition: Optional[float] = Undefined, datum: Optional[ - str | bool | None | float | Parameter | SchemaBase | Map + Temporal | Parameter | SchemaBase | Map | PrimitiveValue_T ] = Undefined, empty: Optional[bool] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, param: Optional[str | SchemaBase] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | Type_T] = Undefined, - **kwds, ) -> TooltipValue: ... - @overload def condition( self, + *, test: Optional[str | SchemaBase | Map] = Undefined, - value: Optional[str | None | Parameter | SchemaBase | Map] = Undefined, - **kwds, + value: Optional[str | Parameter | SchemaBase | Map | None] = Undefined, ) -> TooltipValue: ... - @overload def condition( self, + *, empty: Optional[bool] = Undefined, param: Optional[str | SchemaBase] = Undefined, - value: Optional[str | None | Parameter | SchemaBase | Map] = Undefined, - **kwds, + value: Optional[str | Parameter | SchemaBase | Map | None] = Undefined, ) -> TooltipValue: ... - @overload def condition( - self, _: list[core.ConditionalValueDefstringnullExprRef], **kwds + self, _: list[core.ConditionalValueDefstringnullExprRef], / ) -> TooltipValue: ... def __init__( @@ -19135,7 +16510,7 @@ class Url(FieldChannelMixin, core.StringFieldDefWithCondition): Relative position on a band of a stacked, binned, time unit, or band scale. For example, the marks will be positioned at the beginning of the band if set to ``0``, and at the middle of the band if set to ``0.5``. - bin : bool, dict, None, Literal['binned'], :class:`BinParams` + bin : bool, dict, Literal['binned'], :class:`BinParams`, None A flag for binning a ``quantitative`` field, `an object defining binning parameters `__, or indicating that the data for ``x`` or ``y`` channel are binned before they are imported into @@ -19219,7 +16594,7 @@ class Url(FieldChannelMixin, core.StringFieldDefWithCondition): **See also:** `timeUnit `__ documentation. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -19311,27 +16686,19 @@ class Url(FieldChannelMixin, core.StringFieldDefWithCondition): _encoding_name = "url" @overload - def aggregate(self, _: NonArgAggregateOp_T, **kwds) -> Url: ... - + def aggregate(self, _: NonArgAggregateOp_T, /) -> Url: ... @overload - def aggregate( - self, argmax: Optional[str | SchemaBase] = Undefined, **kwds - ) -> Url: ... - + def aggregate(self, *, argmax: Optional[str | SchemaBase] = Undefined) -> Url: ... @overload - def aggregate( - self, argmin: Optional[str | SchemaBase] = Undefined, **kwds - ) -> Url: ... - + def aggregate(self, *, argmin: Optional[str | SchemaBase] = Undefined) -> Url: ... @overload - def bandPosition(self, _: float, **kwds) -> Url: ... - + def bandPosition(self, _: float, /) -> Url: ... @overload - def bin(self, _: bool, **kwds) -> Url: ... - + def bin(self, _: bool | Bin | Literal["binned"] | None, /) -> Url: ... @overload def bin( self, + *, anchor: Optional[float] = Undefined, base: Optional[float] = Undefined, binned: Optional[bool] = Undefined, @@ -19342,141 +16709,65 @@ def bin( nice: Optional[bool] = Undefined, step: Optional[float] = Undefined, steps: Optional[Sequence[float]] = Undefined, - **kwds, ) -> Url: ... - - @overload - def bin(self, _: Literal["binned"], **kwds) -> Url: ... - - @overload - def bin(self, _: None, **kwds) -> Url: ... - @overload def condition( self, + *, test: Optional[str | SchemaBase | Map] = Undefined, value: Optional[str | Parameter | SchemaBase | Map] = Undefined, - **kwds, ) -> Url: ... - @overload def condition( self, + *, empty: Optional[bool] = Undefined, param: Optional[str | SchemaBase] = Undefined, value: Optional[str | Parameter | SchemaBase | Map] = Undefined, - **kwds, ) -> Url: ... - @overload - def condition( - self, _: list[core.ConditionalValueDefstringExprRef], **kwds - ) -> Url: ... - + def condition(self, _: list[core.ConditionalValueDefstringExprRef], /) -> Url: ... @overload - def field(self, _: str, **kwds) -> Url: ... - + def field(self, _: str | RepeatRef, /) -> Url: ... @overload def field( self, + *, repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined, - **kwds, ) -> Url: ... - - @overload - def format(self, _: str, **kwds) -> Url: ... - - @overload - def format(self, _: Map, **kwds) -> Url: ... - - @overload - def formatType(self, _: str, **kwds) -> Url: ... - @overload - def timeUnit(self, _: LocalSingleTimeUnit_T, **kwds) -> Url: ... - - @overload - def timeUnit(self, _: UtcSingleTimeUnit_T, **kwds) -> Url: ... - - @overload - def timeUnit(self, _: LocalMultiTimeUnit_T, **kwds) -> Url: ... - + def format(self, _: str, /) -> Url: ... @overload - def timeUnit(self, _: UtcMultiTimeUnit_T, **kwds) -> Url: ... - + def format(self, _: Map, /) -> Url: ... @overload - def timeUnit( - self, - _: Literal[ - "binnedyear", - "binnedyearquarter", - "binnedyearquartermonth", - "binnedyearmonth", - "binnedyearmonthdate", - "binnedyearmonthdatehours", - "binnedyearmonthdatehoursminutes", - "binnedyearmonthdatehoursminutesseconds", - "binnedyearweek", - "binnedyearweekday", - "binnedyearweekdayhours", - "binnedyearweekdayhoursminutes", - "binnedyearweekdayhoursminutesseconds", - "binnedyeardayofyear", - ], - **kwds, - ) -> Url: ... - + def formatType(self, _: str, /) -> Url: ... @overload def timeUnit( self, - _: Literal[ - "binnedutcyear", - "binnedutcyearquarter", - "binnedutcyearquartermonth", - "binnedutcyearmonth", - "binnedutcyearmonthdate", - "binnedutcyearmonthdatehours", - "binnedutcyearmonthdatehoursminutes", - "binnedutcyearmonthdatehoursminutesseconds", - "binnedutcyearweek", - "binnedutcyearweekday", - "binnedutcyearweekdayhours", - "binnedutcyearweekdayhoursminutes", - "binnedutcyearweekdayhoursminutesseconds", - "binnedutcyeardayofyear", - ], - **kwds, + _: TimeUnitParams | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T, + /, ) -> Url: ... - @overload def timeUnit( self, + *, binned: Optional[bool] = Undefined, maxbins: Optional[float] = Undefined, step: Optional[float] = Undefined, unit: Optional[SchemaBase | MultiTimeUnit_T | SingleTimeUnit_T] = Undefined, utc: Optional[bool] = Undefined, - **kwds, ) -> Url: ... - - @overload - def title(self, _: str, **kwds) -> Url: ... - - @overload - def title(self, _: list[str], **kwds) -> Url: ... - @overload - def title(self, _: None, **kwds) -> Url: ... - + def title(self, _: str | Sequence[str] | None, /) -> Url: ... @overload - def type(self, _: StandardType_T, **kwds) -> Url: ... + def type(self, _: StandardType_T, /) -> Url: ... def __init__( self, shorthand: Optional[str | SchemaBase | Sequence[str] | Map] = Undefined, aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Literal["binned"] | Map] = Undefined, + bin: Optional[bool | SchemaBase | Literal["binned"] | Map | None] = Undefined, condition: Optional[SchemaBase | Sequence[SchemaBase | Map] | Map] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, format: Optional[str | SchemaBase | Map] = Undefined, @@ -19484,7 +16775,7 @@ def __init__( timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, **kwds, ): @@ -19513,7 +16804,7 @@ class UrlValue(ValueChannelMixin, core.StringValueDefWithCondition): ---------- condition : dict, :class:`ConditionalMarkPropFieldOrDatumDef`, :class:`ConditionalValueDefstringnullExprRef`, :class:`ConditionalParameterMarkPropFieldOrDatumDef`, :class:`ConditionalPredicateMarkPropFieldOrDatumDef`, :class:`ConditionalParameterValueDefstringnullExprRef`, :class:`ConditionalPredicateValueDefstringnullExprRef`, Sequence[dict, :class:`ConditionalValueDefstringnullExprRef`, :class:`ConditionalParameterValueDefstringnullExprRef`, :class:`ConditionalPredicateValueDefstringnullExprRef`] A field definition or one or more value definition(s) with a parameter predicate. - value : str, dict, None, :class:`ExprRef` + value : str, dict, :class:`ExprRef`, None A constant value in visual domain (e.g., ``"red"`` / ``"#0099ff"`` / `gradient definition `__ for color, values between ``0`` to ``1`` for opacity). @@ -19525,111 +16816,105 @@ class UrlValue(ValueChannelMixin, core.StringValueDefWithCondition): @overload def condition( self, + *, aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Map] = Undefined, + bin: Optional[bool | SchemaBase | Map | None] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, sort: Optional[ - None - | SchemaBase + SchemaBase | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map | AllSortString_T + | None ] = Undefined, test: Optional[str | SchemaBase | Map] = Undefined, timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, - **kwds, ) -> UrlValue: ... - @overload def condition( self, + *, bandPosition: Optional[float] = Undefined, datum: Optional[ - str | bool | None | float | Parameter | SchemaBase | Map + Temporal | Parameter | SchemaBase | Map | PrimitiveValue_T ] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, test: Optional[str | SchemaBase | Map] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | Type_T] = Undefined, - **kwds, ) -> UrlValue: ... - @overload def condition( self, + *, aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Map] = Undefined, + bin: Optional[bool | SchemaBase | Map | None] = Undefined, empty: Optional[bool] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, param: Optional[str | SchemaBase] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, sort: Optional[ - None - | SchemaBase + SchemaBase | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map | AllSortString_T + | None ] = Undefined, timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, - **kwds, ) -> UrlValue: ... - @overload def condition( self, + *, bandPosition: Optional[float] = Undefined, datum: Optional[ - str | bool | None | float | Parameter | SchemaBase | Map + Temporal | Parameter | SchemaBase | Map | PrimitiveValue_T ] = Undefined, empty: Optional[bool] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, param: Optional[str | SchemaBase] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | Type_T] = Undefined, - **kwds, ) -> UrlValue: ... - @overload def condition( self, + *, test: Optional[str | SchemaBase | Map] = Undefined, - value: Optional[str | None | Parameter | SchemaBase | Map] = Undefined, - **kwds, + value: Optional[str | Parameter | SchemaBase | Map | None] = Undefined, ) -> UrlValue: ... - @overload def condition( self, + *, empty: Optional[bool] = Undefined, param: Optional[str | SchemaBase] = Undefined, - value: Optional[str | None | Parameter | SchemaBase | Map] = Undefined, - **kwds, + value: Optional[str | Parameter | SchemaBase | Map | None] = Undefined, ) -> UrlValue: ... - @overload def condition( - self, _: list[core.ConditionalValueDefstringnullExprRef], **kwds + self, _: list[core.ConditionalValueDefstringnullExprRef], / ) -> UrlValue: ... def __init__( @@ -19658,7 +16943,7 @@ class X(FieldChannelMixin, core.PositionFieldDef): **See also:** `aggregate `__ documentation. - axis : dict, None, :class:`Axis` + axis : dict, :class:`Axis`, None An object defining properties of axis's gridlines, ticks and labels. If ``null``, the axis for the encoding channel will be removed. @@ -19671,7 +16956,7 @@ class X(FieldChannelMixin, core.PositionFieldDef): Relative position on a band of a stacked, binned, time unit, or band scale. For example, the marks will be positioned at the beginning of the band if set to ``0``, and at the middle of the band if set to ``0.5``. - bin : bool, dict, None, Literal['binned'], :class:`BinParams` + bin : bool, dict, Literal['binned'], :class:`BinParams`, None A flag for binning a ``quantitative`` field, `an object defining binning parameters `__, or indicating that the data for ``x`` or ``y`` channel are binned before they are imported into @@ -19707,7 +16992,7 @@ class X(FieldChannelMixin, core.PositionFieldDef): about escaping in the `field documentation `__. 2) ``field`` is not required if ``aggregate`` is ``count``. - impute : dict, None, :class:`ImputeParams` + impute : dict, :class:`ImputeParams`, None An object defining the properties of the Impute Operation to be applied. The field value of the other positional channel is taken as ``key`` of the ``Impute`` Operation. The field of the ``color`` channel if specified is used as ``groupby`` of @@ -19715,7 +17000,7 @@ class X(FieldChannelMixin, core.PositionFieldDef): **See also:** `impute `__ documentation. - scale : dict, None, :class:`Scale` + scale : dict, :class:`Scale`, None An object defining properties of the channel's scale, which is the function that transforms values in the data domain (numbers, dates, strings, etc) to visual values (pixels, colors, sizes) of the encoding channels. @@ -19728,7 +17013,7 @@ class X(FieldChannelMixin, core.PositionFieldDef): **See also:** `scale `__ documentation. - sort : dict, None, :class:`Sort`, Sequence[str], Sequence[bool], Sequence[float], :class:`SortArray`, :class:`SortOrder`, :class:`AllSortString`, :class:`SortByChannel`, :class:`SortByEncoding`, :class:`EncodingSortField`, :class:`SortByChannelDesc`, Sequence[dict, :class:`DateTime`], Literal['-x', '-y', '-color', '-fill', '-stroke', '-strokeWidth', '-size', '-shape', '-fillOpacity', '-strokeOpacity', '-opacity', '-text', 'ascending', 'descending', 'x', 'y', 'color', 'fill', 'stroke', 'strokeWidth', 'size', 'shape', 'fillOpacity', 'strokeOpacity', 'opacity', 'text'] + sort : dict, :class:`Sort`, Sequence[str], Sequence[bool], Sequence[float], :class:`SortArray`, :class:`SortOrder`, :class:`AllSortString`, :class:`SortByChannel`, :class:`SortByEncoding`, :class:`EncodingSortField`, :class:`SortByChannelDesc`, Sequence[dict, :class:`DateTime`], Literal['-x', '-y', '-color', '-fill', '-stroke', '-strokeWidth', '-size', '-shape', '-fillOpacity', '-strokeOpacity', '-opacity', '-text', 'ascending', 'descending', 'x', 'y', 'color', 'fill', 'stroke', 'strokeWidth', 'size', 'shape', 'fillOpacity', 'strokeOpacity', 'opacity', 'text'], None Sort order for the encoded field. For continuous fields (quantitative or temporal), ``sort`` can be either @@ -19766,7 +17051,7 @@ class X(FieldChannelMixin, core.PositionFieldDef): **See also:** `sort `__ documentation. - stack : bool, None, :class:`StackOffset`, Literal['zero', 'center', 'normalize'] + stack : bool, :class:`StackOffset`, Literal['zero', 'center', 'normalize'], None Type of stacking offset if the field should be stacked. ``stack`` is only applicable for ``x``, ``y``, ``theta``, and ``radius`` channels with continuous domains. For example, ``stack`` of ``y`` can be used to customize stacking for a vertical bar @@ -19805,7 +17090,7 @@ class X(FieldChannelMixin, core.PositionFieldDef): **See also:** `timeUnit `__ documentation. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -19897,28 +17182,24 @@ class X(FieldChannelMixin, core.PositionFieldDef): _encoding_name = "x" @overload - def aggregate(self, _: NonArgAggregateOp_T, **kwds) -> X: ... - + def aggregate(self, _: NonArgAggregateOp_T, /) -> X: ... @overload - def aggregate( - self, argmax: Optional[str | SchemaBase] = Undefined, **kwds - ) -> X: ... - + def aggregate(self, *, argmax: Optional[str | SchemaBase] = Undefined) -> X: ... @overload - def aggregate( - self, argmin: Optional[str | SchemaBase] = Undefined, **kwds - ) -> X: ... - + def aggregate(self, *, argmin: Optional[str | SchemaBase] = Undefined) -> X: ... + @overload + def axis(self, _: Axis | None, /) -> X: ... @overload def axis( self, + *, aria: Optional[bool | Parameter | SchemaBase | Map] = Undefined, bandPosition: Optional[float | Parameter | SchemaBase | Map] = Undefined, description: Optional[str | Parameter | SchemaBase | Map] = Undefined, domain: Optional[bool] = Undefined, domainCap: Optional[Parameter | SchemaBase | Map | StrokeCap_T] = Undefined, domainColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, domainDash: Optional[ Parameter | SchemaBase | Sequence[float] | Map @@ -19931,7 +17212,7 @@ def axis( grid: Optional[bool] = Undefined, gridCap: Optional[Parameter | SchemaBase | Map | StrokeCap_T] = Undefined, gridColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, gridDash: Optional[Parameter | SchemaBase | Sequence[float] | Map] = Undefined, gridDashOffset: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -19944,7 +17225,7 @@ def axis( ] = Undefined, labelBound: Optional[bool | float | Parameter | SchemaBase | Map] = Undefined, labelColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, labelExpr: Optional[str] = Undefined, labelFlush: Optional[bool | float] = Undefined, @@ -19976,7 +17257,7 @@ def axis( ] = Undefined, tickCap: Optional[Parameter | SchemaBase | Map | StrokeCap_T] = Undefined, tickColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, tickCount: Optional[ float | Parameter | SchemaBase | Map | TimeInterval_T @@ -19991,7 +17272,7 @@ def axis( tickSize: Optional[float | Parameter | SchemaBase | Map] = Undefined, tickWidth: Optional[float | Parameter | SchemaBase | Map] = Undefined, ticks: Optional[bool] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, titleAlign: Optional[Parameter | SchemaBase | Map | Align_T] = Undefined, titleAnchor: Optional[Parameter | SchemaBase | Map | TitleAnchor_T] = Undefined, titleAngle: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -19999,7 +17280,7 @@ def axis( Parameter | SchemaBase | Map | TextBaseline_T ] = Undefined, titleColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, titleFont: Optional[str | Parameter | SchemaBase | Map] = Undefined, titleFontSize: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -20020,25 +17301,19 @@ def axis( | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map ] = Undefined, zindex: Optional[float] = Undefined, - **kwds, ) -> X: ... - - @overload - def axis(self, _: None, **kwds) -> X: ... - @overload - def bandPosition(self, _: float, **kwds) -> X: ... - + def bandPosition(self, _: float, /) -> X: ... @overload - def bin(self, _: bool, **kwds) -> X: ... - + def bin(self, _: bool | Bin | Literal["binned"] | None, /) -> X: ... @overload def bin( self, + *, anchor: Optional[float] = Undefined, base: Optional[float] = Undefined, binned: Optional[bool] = Undefined, @@ -20049,41 +17324,32 @@ def bin( nice: Optional[bool] = Undefined, step: Optional[float] = Undefined, steps: Optional[Sequence[float]] = Undefined, - **kwds, ) -> X: ... - - @overload - def bin(self, _: Literal["binned"], **kwds) -> X: ... - - @overload - def bin(self, _: None, **kwds) -> X: ... - @overload - def field(self, _: str, **kwds) -> X: ... - + def field(self, _: str | RepeatRef, /) -> X: ... @overload def field( self, + *, repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined, - **kwds, ) -> X: ... - + @overload + def impute(self, _: Impute | None, /) -> X: ... @overload def impute( self, - frame: Optional[Sequence[None | float]] = Undefined, + *, + frame: Optional[Sequence[float | None]] = Undefined, keyvals: Optional[SchemaBase | Sequence[Any] | Map] = Undefined, method: Optional[SchemaBase | ImputeMethod_T] = Undefined, value: Optional[Any] = Undefined, - **kwds, ) -> X: ... - @overload - def impute(self, _: None, **kwds) -> X: ... - + def scale(self, _: Scale | None, /) -> X: ... @overload def scale( self, + *, align: Optional[float | Parameter | SchemaBase | Map] = Undefined, base: Optional[float | Parameter | SchemaBase | Map] = Undefined, bins: Optional[SchemaBase | Sequence[float] | Map] = Undefined, @@ -20093,12 +17359,18 @@ def scale( Parameter | SchemaBase | Literal["unaggregated"] - | Sequence[str | bool | None | float | Parameter | SchemaBase | Map] + | Sequence[ + str | bool | float | Temporal | Parameter | SchemaBase | Map | None + ] | Map ] = Undefined, - domainMax: Optional[float | Parameter | SchemaBase | Map] = Undefined, + domainMax: Optional[ + float | Temporal | Parameter | SchemaBase | Map + ] = Undefined, domainMid: Optional[float | Parameter | SchemaBase | Map] = Undefined, - domainMin: Optional[float | Parameter | SchemaBase | Map] = Undefined, + domainMin: Optional[ + float | Temporal | Parameter | SchemaBase | Map + ] = Undefined, domainRaw: Optional[Parameter | SchemaBase | Map] = Undefined, exponent: Optional[float | Parameter | SchemaBase | Map] = Undefined, interpolate: Optional[ @@ -20123,166 +17395,81 @@ def scale( scheme: Optional[Parameter | SchemaBase | Map | ColorScheme_T] = Undefined, type: Optional[SchemaBase | ScaleType_T] = Undefined, zero: Optional[bool | Parameter | SchemaBase | Map] = Undefined, - **kwds, ) -> X: ... - - @overload - def scale(self, _: None, **kwds) -> X: ... - - @overload - def sort(self, _: list[float], **kwds) -> X: ... - - @overload - def sort(self, _: list[str], **kwds) -> X: ... - - @overload - def sort(self, _: list[bool], **kwds) -> X: ... - - @overload - def sort(self, _: list[core.DateTime], **kwds) -> X: ... - - @overload - def sort(self, _: SortOrder_T, **kwds) -> X: ... - @overload - def sort(self, _: SortByChannel_T, **kwds) -> X: ... - - @overload - def sort(self, _: SortByChannelDesc_T, **kwds) -> X: ... - + def sort( + self, + _: Sequence[str] + | Sequence[bool] + | Sequence[float] + | Sequence[DateTime | Temporal] + | AllSortString_T + | None, + /, + ) -> X: ... @overload def sort( self, + *, field: Optional[str | SchemaBase | Map] = Undefined, op: Optional[SchemaBase | NonArgAggregateOp_T] = Undefined, - order: Optional[None | SchemaBase | SortOrder_T] = Undefined, - **kwds, + order: Optional[SchemaBase | SortOrder_T | None] = Undefined, ) -> X: ... - @overload def sort( self, + *, encoding: Optional[SchemaBase | SortByChannel_T] = Undefined, - order: Optional[None | SchemaBase | SortOrder_T] = Undefined, - **kwds, + order: Optional[SchemaBase | SortOrder_T | None] = Undefined, ) -> X: ... - - @overload - def sort(self, _: None, **kwds) -> X: ... - - @overload - def stack(self, _: StackOffset_T, **kwds) -> X: ... - - @overload - def stack(self, _: None, **kwds) -> X: ... - @overload - def stack(self, _: bool, **kwds) -> X: ... - - @overload - def timeUnit(self, _: LocalSingleTimeUnit_T, **kwds) -> X: ... - - @overload - def timeUnit(self, _: UtcSingleTimeUnit_T, **kwds) -> X: ... - - @overload - def timeUnit(self, _: LocalMultiTimeUnit_T, **kwds) -> X: ... - - @overload - def timeUnit(self, _: UtcMultiTimeUnit_T, **kwds) -> X: ... - - @overload - def timeUnit( - self, - _: Literal[ - "binnedyear", - "binnedyearquarter", - "binnedyearquartermonth", - "binnedyearmonth", - "binnedyearmonthdate", - "binnedyearmonthdatehours", - "binnedyearmonthdatehoursminutes", - "binnedyearmonthdatehoursminutesseconds", - "binnedyearweek", - "binnedyearweekday", - "binnedyearweekdayhours", - "binnedyearweekdayhoursminutes", - "binnedyearweekdayhoursminutesseconds", - "binnedyeardayofyear", - ], - **kwds, - ) -> X: ... - + def stack(self, _: bool | StackOffset_T | None, /) -> X: ... @overload def timeUnit( self, - _: Literal[ - "binnedutcyear", - "binnedutcyearquarter", - "binnedutcyearquartermonth", - "binnedutcyearmonth", - "binnedutcyearmonthdate", - "binnedutcyearmonthdatehours", - "binnedutcyearmonthdatehoursminutes", - "binnedutcyearmonthdatehoursminutesseconds", - "binnedutcyearweek", - "binnedutcyearweekday", - "binnedutcyearweekdayhours", - "binnedutcyearweekdayhoursminutes", - "binnedutcyearweekdayhoursminutesseconds", - "binnedutcyeardayofyear", - ], - **kwds, + _: TimeUnitParams | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T, + /, ) -> X: ... - @overload def timeUnit( self, + *, binned: Optional[bool] = Undefined, maxbins: Optional[float] = Undefined, step: Optional[float] = Undefined, unit: Optional[SchemaBase | MultiTimeUnit_T | SingleTimeUnit_T] = Undefined, utc: Optional[bool] = Undefined, - **kwds, ) -> X: ... - - @overload - def title(self, _: str, **kwds) -> X: ... - - @overload - def title(self, _: list[str], **kwds) -> X: ... - @overload - def title(self, _: None, **kwds) -> X: ... - + def title(self, _: str | Sequence[str] | None, /) -> X: ... @overload - def type(self, _: StandardType_T, **kwds) -> X: ... + def type(self, _: StandardType_T, /) -> X: ... def __init__( self, shorthand: Optional[str | SchemaBase | Sequence[str] | Map] = Undefined, aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, - axis: Optional[None | SchemaBase | Map] = Undefined, + axis: Optional[SchemaBase | Map | None] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Literal["binned"] | Map] = Undefined, + bin: Optional[bool | SchemaBase | Literal["binned"] | Map | None] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, - impute: Optional[None | SchemaBase | Map] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, + impute: Optional[SchemaBase | Map | None] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, sort: Optional[ - None - | SchemaBase + SchemaBase | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map | AllSortString_T + | None ] = Undefined, - stack: Optional[bool | None | SchemaBase | StackOffset_T] = Undefined, + stack: Optional[bool | SchemaBase | StackOffset_T | None] = Undefined, timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, **kwds, ): @@ -20311,7 +17498,7 @@ class XDatum(DatumChannelMixin, core.PositionDatumDef): Parameters ---------- - axis : dict, None, :class:`Axis` + axis : dict, :class:`Axis`, None An object defining properties of axis's gridlines, ticks and labels. If ``null``, the axis for the encoding channel will be removed. @@ -20324,9 +17511,9 @@ class XDatum(DatumChannelMixin, core.PositionDatumDef): Relative position on a band of a stacked, binned, time unit, or band scale. For example, the marks will be positioned at the beginning of the band if set to ``0``, and at the middle of the band if set to ``0.5``. - datum : str, bool, dict, None, float, :class:`ExprRef`, :class:`DateTime`, :class:`RepeatRef`, :class:`PrimitiveValue` + datum : str, bool, dict, float, :class:`ExprRef`, :class:`DateTime`, :class:`RepeatRef`, :class:`PrimitiveValue`, None A constant value in data domain. - impute : dict, None, :class:`ImputeParams` + impute : dict, :class:`ImputeParams`, None An object defining the properties of the Impute Operation to be applied. The field value of the other positional channel is taken as ``key`` of the ``Impute`` Operation. The field of the ``color`` channel if specified is used as ``groupby`` of @@ -20334,7 +17521,7 @@ class XDatum(DatumChannelMixin, core.PositionDatumDef): **See also:** `impute `__ documentation. - scale : dict, None, :class:`Scale` + scale : dict, :class:`Scale`, None An object defining properties of the channel's scale, which is the function that transforms values in the data domain (numbers, dates, strings, etc) to visual values (pixels, colors, sizes) of the encoding channels. @@ -20347,7 +17534,7 @@ class XDatum(DatumChannelMixin, core.PositionDatumDef): **See also:** `scale `__ documentation. - stack : bool, None, :class:`StackOffset`, Literal['zero', 'center', 'normalize'] + stack : bool, :class:`StackOffset`, Literal['zero', 'center', 'normalize'], None Type of stacking offset if the field should be stacked. ``stack`` is only applicable for ``x``, ``y``, ``theta``, and ``radius`` channels with continuous domains. For example, ``stack`` of ``y`` can be used to customize stacking for a vertical bar @@ -20377,7 +17564,7 @@ class XDatum(DatumChannelMixin, core.PositionDatumDef): **See also:** `stack `__ documentation. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -20468,16 +17655,19 @@ class XDatum(DatumChannelMixin, core.PositionDatumDef): _class_is_valid_at_instantiation = False _encoding_name = "x" + @overload + def axis(self, _: Axis | None, /) -> XDatum: ... @overload def axis( self, + *, aria: Optional[bool | Parameter | SchemaBase | Map] = Undefined, bandPosition: Optional[float | Parameter | SchemaBase | Map] = Undefined, description: Optional[str | Parameter | SchemaBase | Map] = Undefined, domain: Optional[bool] = Undefined, domainCap: Optional[Parameter | SchemaBase | Map | StrokeCap_T] = Undefined, domainColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, domainDash: Optional[ Parameter | SchemaBase | Sequence[float] | Map @@ -20490,7 +17680,7 @@ def axis( grid: Optional[bool] = Undefined, gridCap: Optional[Parameter | SchemaBase | Map | StrokeCap_T] = Undefined, gridColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, gridDash: Optional[Parameter | SchemaBase | Sequence[float] | Map] = Undefined, gridDashOffset: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -20503,7 +17693,7 @@ def axis( ] = Undefined, labelBound: Optional[bool | float | Parameter | SchemaBase | Map] = Undefined, labelColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, labelExpr: Optional[str] = Undefined, labelFlush: Optional[bool | float] = Undefined, @@ -20535,7 +17725,7 @@ def axis( ] = Undefined, tickCap: Optional[Parameter | SchemaBase | Map | StrokeCap_T] = Undefined, tickColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, tickCount: Optional[ float | Parameter | SchemaBase | Map | TimeInterval_T @@ -20550,7 +17740,7 @@ def axis( tickSize: Optional[float | Parameter | SchemaBase | Map] = Undefined, tickWidth: Optional[float | Parameter | SchemaBase | Map] = Undefined, ticks: Optional[bool] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, titleAlign: Optional[Parameter | SchemaBase | Map | Align_T] = Undefined, titleAnchor: Optional[Parameter | SchemaBase | Map | TitleAnchor_T] = Undefined, titleAngle: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -20558,7 +17748,7 @@ def axis( Parameter | SchemaBase | Map | TextBaseline_T ] = Undefined, titleColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, titleFont: Optional[str | Parameter | SchemaBase | Map] = Undefined, titleFontSize: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -20579,35 +17769,30 @@ def axis( | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map ] = Undefined, zindex: Optional[float] = Undefined, - **kwds, ) -> XDatum: ... - @overload - def axis(self, _: None, **kwds) -> XDatum: ... - + def bandPosition(self, _: float, /) -> XDatum: ... @overload - def bandPosition(self, _: float, **kwds) -> XDatum: ... - + def impute(self, _: Impute | None, /) -> XDatum: ... @overload def impute( self, - frame: Optional[Sequence[None | float]] = Undefined, + *, + frame: Optional[Sequence[float | None]] = Undefined, keyvals: Optional[SchemaBase | Sequence[Any] | Map] = Undefined, method: Optional[SchemaBase | ImputeMethod_T] = Undefined, value: Optional[Any] = Undefined, - **kwds, ) -> XDatum: ... - @overload - def impute(self, _: None, **kwds) -> XDatum: ... - + def scale(self, _: Scale | None, /) -> XDatum: ... @overload def scale( self, + *, align: Optional[float | Parameter | SchemaBase | Map] = Undefined, base: Optional[float | Parameter | SchemaBase | Map] = Undefined, bins: Optional[SchemaBase | Sequence[float] | Map] = Undefined, @@ -20617,12 +17802,18 @@ def scale( Parameter | SchemaBase | Literal["unaggregated"] - | Sequence[str | bool | None | float | Parameter | SchemaBase | Map] + | Sequence[ + str | bool | float | Temporal | Parameter | SchemaBase | Map | None + ] | Map ] = Undefined, - domainMax: Optional[float | Parameter | SchemaBase | Map] = Undefined, + domainMax: Optional[ + float | Temporal | Parameter | SchemaBase | Map + ] = Undefined, domainMid: Optional[float | Parameter | SchemaBase | Map] = Undefined, - domainMin: Optional[float | Parameter | SchemaBase | Map] = Undefined, + domainMin: Optional[ + float | Temporal | Parameter | SchemaBase | Map + ] = Undefined, domainRaw: Optional[Parameter | SchemaBase | Map] = Undefined, exponent: Optional[float | Parameter | SchemaBase | Map] = Undefined, interpolate: Optional[ @@ -20647,42 +17838,23 @@ def scale( scheme: Optional[Parameter | SchemaBase | Map | ColorScheme_T] = Undefined, type: Optional[SchemaBase | ScaleType_T] = Undefined, zero: Optional[bool | Parameter | SchemaBase | Map] = Undefined, - **kwds, ) -> XDatum: ... - - @overload - def scale(self, _: None, **kwds) -> XDatum: ... - - @overload - def stack(self, _: StackOffset_T, **kwds) -> XDatum: ... - - @overload - def stack(self, _: None, **kwds) -> XDatum: ... - - @overload - def stack(self, _: bool, **kwds) -> XDatum: ... - - @overload - def title(self, _: str, **kwds) -> XDatum: ... - @overload - def title(self, _: list[str], **kwds) -> XDatum: ... - + def stack(self, _: bool | StackOffset_T | None, /) -> XDatum: ... @overload - def title(self, _: None, **kwds) -> XDatum: ... - + def title(self, _: str | Sequence[str] | None, /) -> XDatum: ... @overload - def type(self, _: Type_T, **kwds) -> XDatum: ... + def type(self, _: Type_T, /) -> XDatum: ... def __init__( self, datum, - axis: Optional[None | SchemaBase | Map] = Undefined, + axis: Optional[SchemaBase | Map | None] = Undefined, bandPosition: Optional[float] = Undefined, - impute: Optional[None | SchemaBase | Map] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, - stack: Optional[bool | None | SchemaBase | StackOffset_T] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + impute: Optional[SchemaBase | Map | None] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, + stack: Optional[bool | SchemaBase | StackOffset_T | None] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | Type_T] = Undefined, **kwds, ): @@ -20791,7 +17963,7 @@ class X2(FieldChannelMixin, core.SecondaryFieldDef): **See also:** `timeUnit `__ documentation. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -20817,109 +17989,41 @@ class X2(FieldChannelMixin, core.SecondaryFieldDef): _encoding_name = "x2" @overload - def aggregate(self, _: NonArgAggregateOp_T, **kwds) -> X2: ... - + def aggregate(self, _: NonArgAggregateOp_T, /) -> X2: ... @overload - def aggregate( - self, argmax: Optional[str | SchemaBase] = Undefined, **kwds - ) -> X2: ... - + def aggregate(self, *, argmax: Optional[str | SchemaBase] = Undefined) -> X2: ... @overload - def aggregate( - self, argmin: Optional[str | SchemaBase] = Undefined, **kwds - ) -> X2: ... - + def aggregate(self, *, argmin: Optional[str | SchemaBase] = Undefined) -> X2: ... @overload - def bandPosition(self, _: float, **kwds) -> X2: ... - + def bandPosition(self, _: float, /) -> X2: ... @overload - def bin(self, _: None, **kwds) -> X2: ... - + def bin(self, _: None, /) -> X2: ... @overload - def field(self, _: str, **kwds) -> X2: ... - + def field(self, _: str | RepeatRef, /) -> X2: ... @overload def field( self, + *, repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined, - **kwds, - ) -> X2: ... - - @overload - def timeUnit(self, _: LocalSingleTimeUnit_T, **kwds) -> X2: ... - - @overload - def timeUnit(self, _: UtcSingleTimeUnit_T, **kwds) -> X2: ... - - @overload - def timeUnit(self, _: LocalMultiTimeUnit_T, **kwds) -> X2: ... - - @overload - def timeUnit(self, _: UtcMultiTimeUnit_T, **kwds) -> X2: ... - - @overload - def timeUnit( - self, - _: Literal[ - "binnedyear", - "binnedyearquarter", - "binnedyearquartermonth", - "binnedyearmonth", - "binnedyearmonthdate", - "binnedyearmonthdatehours", - "binnedyearmonthdatehoursminutes", - "binnedyearmonthdatehoursminutesseconds", - "binnedyearweek", - "binnedyearweekday", - "binnedyearweekdayhours", - "binnedyearweekdayhoursminutes", - "binnedyearweekdayhoursminutesseconds", - "binnedyeardayofyear", - ], - **kwds, ) -> X2: ... - @overload def timeUnit( self, - _: Literal[ - "binnedutcyear", - "binnedutcyearquarter", - "binnedutcyearquartermonth", - "binnedutcyearmonth", - "binnedutcyearmonthdate", - "binnedutcyearmonthdatehours", - "binnedutcyearmonthdatehoursminutes", - "binnedutcyearmonthdatehoursminutesseconds", - "binnedutcyearweek", - "binnedutcyearweekday", - "binnedutcyearweekdayhours", - "binnedutcyearweekdayhoursminutes", - "binnedutcyearweekdayhoursminutesseconds", - "binnedutcyeardayofyear", - ], - **kwds, + _: TimeUnitParams | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T, + /, ) -> X2: ... - @overload def timeUnit( self, + *, binned: Optional[bool] = Undefined, maxbins: Optional[float] = Undefined, step: Optional[float] = Undefined, unit: Optional[SchemaBase | MultiTimeUnit_T | SingleTimeUnit_T] = Undefined, utc: Optional[bool] = Undefined, - **kwds, ) -> X2: ... - - @overload - def title(self, _: str, **kwds) -> X2: ... - - @overload - def title(self, _: list[str], **kwds) -> X2: ... - @overload - def title(self, _: None, **kwds) -> X2: ... + def title(self, _: str | Sequence[str] | None, /) -> X2: ... def __init__( self, @@ -20931,7 +18035,7 @@ def __init__( timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, **kwds, ): super().__init__( @@ -20957,9 +18061,9 @@ class X2Datum(DatumChannelMixin, core.DatumDef): Relative position on a band of a stacked, binned, time unit, or band scale. For example, the marks will be positioned at the beginning of the band if set to ``0``, and at the middle of the band if set to ``0.5``. - datum : str, bool, dict, None, float, :class:`ExprRef`, :class:`DateTime`, :class:`RepeatRef`, :class:`PrimitiveValue` + datum : str, bool, dict, float, :class:`ExprRef`, :class:`DateTime`, :class:`RepeatRef`, :class:`PrimitiveValue`, None A constant value in data domain. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -21051,25 +18155,17 @@ class X2Datum(DatumChannelMixin, core.DatumDef): _encoding_name = "x2" @overload - def bandPosition(self, _: float, **kwds) -> X2Datum: ... - - @overload - def title(self, _: str, **kwds) -> X2Datum: ... - - @overload - def title(self, _: list[str], **kwds) -> X2Datum: ... - + def bandPosition(self, _: float, /) -> X2Datum: ... @overload - def title(self, _: None, **kwds) -> X2Datum: ... - + def title(self, _: str | Sequence[str] | None, /) -> X2Datum: ... @overload - def type(self, _: Type_T, **kwds) -> X2Datum: ... + def type(self, _: Type_T, /) -> X2Datum: ... def __init__( self, datum, bandPosition: Optional[float] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | Type_T] = Undefined, **kwds, ): @@ -21170,7 +18266,7 @@ class XError(FieldChannelMixin, core.SecondaryFieldDef): **See also:** `timeUnit `__ documentation. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -21196,109 +18292,45 @@ class XError(FieldChannelMixin, core.SecondaryFieldDef): _encoding_name = "xError" @overload - def aggregate(self, _: NonArgAggregateOp_T, **kwds) -> XError: ... - + def aggregate(self, _: NonArgAggregateOp_T, /) -> XError: ... @overload def aggregate( - self, argmax: Optional[str | SchemaBase] = Undefined, **kwds + self, *, argmax: Optional[str | SchemaBase] = Undefined ) -> XError: ... - @overload def aggregate( - self, argmin: Optional[str | SchemaBase] = Undefined, **kwds + self, *, argmin: Optional[str | SchemaBase] = Undefined ) -> XError: ... - @overload - def bandPosition(self, _: float, **kwds) -> XError: ... - + def bandPosition(self, _: float, /) -> XError: ... @overload - def bin(self, _: None, **kwds) -> XError: ... - + def bin(self, _: None, /) -> XError: ... @overload - def field(self, _: str, **kwds) -> XError: ... - + def field(self, _: str | RepeatRef, /) -> XError: ... @overload def field( self, + *, repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined, - **kwds, - ) -> XError: ... - - @overload - def timeUnit(self, _: LocalSingleTimeUnit_T, **kwds) -> XError: ... - - @overload - def timeUnit(self, _: UtcSingleTimeUnit_T, **kwds) -> XError: ... - - @overload - def timeUnit(self, _: LocalMultiTimeUnit_T, **kwds) -> XError: ... - - @overload - def timeUnit(self, _: UtcMultiTimeUnit_T, **kwds) -> XError: ... - - @overload - def timeUnit( - self, - _: Literal[ - "binnedyear", - "binnedyearquarter", - "binnedyearquartermonth", - "binnedyearmonth", - "binnedyearmonthdate", - "binnedyearmonthdatehours", - "binnedyearmonthdatehoursminutes", - "binnedyearmonthdatehoursminutesseconds", - "binnedyearweek", - "binnedyearweekday", - "binnedyearweekdayhours", - "binnedyearweekdayhoursminutes", - "binnedyearweekdayhoursminutesseconds", - "binnedyeardayofyear", - ], - **kwds, ) -> XError: ... - @overload def timeUnit( self, - _: Literal[ - "binnedutcyear", - "binnedutcyearquarter", - "binnedutcyearquartermonth", - "binnedutcyearmonth", - "binnedutcyearmonthdate", - "binnedutcyearmonthdatehours", - "binnedutcyearmonthdatehoursminutes", - "binnedutcyearmonthdatehoursminutesseconds", - "binnedutcyearweek", - "binnedutcyearweekday", - "binnedutcyearweekdayhours", - "binnedutcyearweekdayhoursminutes", - "binnedutcyearweekdayhoursminutesseconds", - "binnedutcyeardayofyear", - ], - **kwds, + _: TimeUnitParams | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T, + /, ) -> XError: ... - @overload def timeUnit( self, + *, binned: Optional[bool] = Undefined, maxbins: Optional[float] = Undefined, step: Optional[float] = Undefined, unit: Optional[SchemaBase | MultiTimeUnit_T | SingleTimeUnit_T] = Undefined, utc: Optional[bool] = Undefined, - **kwds, ) -> XError: ... - - @overload - def title(self, _: str, **kwds) -> XError: ... - - @overload - def title(self, _: list[str], **kwds) -> XError: ... - @overload - def title(self, _: None, **kwds) -> XError: ... + def title(self, _: str | Sequence[str] | None, /) -> XError: ... def __init__( self, @@ -21310,7 +18342,7 @@ def __init__( timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, **kwds, ): super().__init__( @@ -21417,7 +18449,7 @@ class XError2(FieldChannelMixin, core.SecondaryFieldDef): **See also:** `timeUnit `__ documentation. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -21443,109 +18475,45 @@ class XError2(FieldChannelMixin, core.SecondaryFieldDef): _encoding_name = "xError2" @overload - def aggregate(self, _: NonArgAggregateOp_T, **kwds) -> XError2: ... - + def aggregate(self, _: NonArgAggregateOp_T, /) -> XError2: ... @overload def aggregate( - self, argmax: Optional[str | SchemaBase] = Undefined, **kwds + self, *, argmax: Optional[str | SchemaBase] = Undefined ) -> XError2: ... - @overload def aggregate( - self, argmin: Optional[str | SchemaBase] = Undefined, **kwds + self, *, argmin: Optional[str | SchemaBase] = Undefined ) -> XError2: ... - @overload - def bandPosition(self, _: float, **kwds) -> XError2: ... - + def bandPosition(self, _: float, /) -> XError2: ... @overload - def bin(self, _: None, **kwds) -> XError2: ... - + def bin(self, _: None, /) -> XError2: ... @overload - def field(self, _: str, **kwds) -> XError2: ... - + def field(self, _: str | RepeatRef, /) -> XError2: ... @overload def field( self, + *, repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined, - **kwds, ) -> XError2: ... - - @overload - def timeUnit(self, _: LocalSingleTimeUnit_T, **kwds) -> XError2: ... - - @overload - def timeUnit(self, _: UtcSingleTimeUnit_T, **kwds) -> XError2: ... - - @overload - def timeUnit(self, _: LocalMultiTimeUnit_T, **kwds) -> XError2: ... - - @overload - def timeUnit(self, _: UtcMultiTimeUnit_T, **kwds) -> XError2: ... - - @overload - def timeUnit( - self, - _: Literal[ - "binnedyear", - "binnedyearquarter", - "binnedyearquartermonth", - "binnedyearmonth", - "binnedyearmonthdate", - "binnedyearmonthdatehours", - "binnedyearmonthdatehoursminutes", - "binnedyearmonthdatehoursminutesseconds", - "binnedyearweek", - "binnedyearweekday", - "binnedyearweekdayhours", - "binnedyearweekdayhoursminutes", - "binnedyearweekdayhoursminutesseconds", - "binnedyeardayofyear", - ], - **kwds, - ) -> XError2: ... - @overload def timeUnit( self, - _: Literal[ - "binnedutcyear", - "binnedutcyearquarter", - "binnedutcyearquartermonth", - "binnedutcyearmonth", - "binnedutcyearmonthdate", - "binnedutcyearmonthdatehours", - "binnedutcyearmonthdatehoursminutes", - "binnedutcyearmonthdatehoursminutesseconds", - "binnedutcyearweek", - "binnedutcyearweekday", - "binnedutcyearweekdayhours", - "binnedutcyearweekdayhoursminutes", - "binnedutcyearweekdayhoursminutesseconds", - "binnedutcyeardayofyear", - ], - **kwds, + _: TimeUnitParams | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T, + /, ) -> XError2: ... - @overload def timeUnit( self, + *, binned: Optional[bool] = Undefined, maxbins: Optional[float] = Undefined, step: Optional[float] = Undefined, unit: Optional[SchemaBase | MultiTimeUnit_T | SingleTimeUnit_T] = Undefined, utc: Optional[bool] = Undefined, - **kwds, ) -> XError2: ... - - @overload - def title(self, _: str, **kwds) -> XError2: ... - - @overload - def title(self, _: list[str], **kwds) -> XError2: ... - @overload - def title(self, _: None, **kwds) -> XError2: ... + def title(self, _: str | Sequence[str] | None, /) -> XError2: ... def __init__( self, @@ -21557,7 +18525,7 @@ def __init__( timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, **kwds, ): super().__init__( @@ -21616,7 +18584,7 @@ class XOffset(FieldChannelMixin, core.ScaleFieldDef): Relative position on a band of a stacked, binned, time unit, or band scale. For example, the marks will be positioned at the beginning of the band if set to ``0``, and at the middle of the band if set to ``0.5``. - bin : bool, dict, None, :class:`BinParams` + bin : bool, dict, :class:`BinParams`, None A flag for binning a ``quantitative`` field, `an object defining binning parameters `__, or indicating that the data for ``x`` or ``y`` channel are binned before they are imported into @@ -21652,7 +18620,7 @@ class XOffset(FieldChannelMixin, core.ScaleFieldDef): about escaping in the `field documentation `__. 2) ``field`` is not required if ``aggregate`` is ``count``. - scale : dict, None, :class:`Scale` + scale : dict, :class:`Scale`, None An object defining properties of the channel's scale, which is the function that transforms values in the data domain (numbers, dates, strings, etc) to visual values (pixels, colors, sizes) of the encoding channels. @@ -21665,7 +18633,7 @@ class XOffset(FieldChannelMixin, core.ScaleFieldDef): **See also:** `scale `__ documentation. - sort : dict, None, :class:`Sort`, Sequence[str], Sequence[bool], Sequence[float], :class:`SortArray`, :class:`SortOrder`, :class:`AllSortString`, :class:`SortByChannel`, :class:`SortByEncoding`, :class:`EncodingSortField`, :class:`SortByChannelDesc`, Sequence[dict, :class:`DateTime`], Literal['-x', '-y', '-color', '-fill', '-stroke', '-strokeWidth', '-size', '-shape', '-fillOpacity', '-strokeOpacity', '-opacity', '-text', 'ascending', 'descending', 'x', 'y', 'color', 'fill', 'stroke', 'strokeWidth', 'size', 'shape', 'fillOpacity', 'strokeOpacity', 'opacity', 'text'] + sort : dict, :class:`Sort`, Sequence[str], Sequence[bool], Sequence[float], :class:`SortArray`, :class:`SortOrder`, :class:`AllSortString`, :class:`SortByChannel`, :class:`SortByEncoding`, :class:`EncodingSortField`, :class:`SortByChannelDesc`, Sequence[dict, :class:`DateTime`], Literal['-x', '-y', '-color', '-fill', '-stroke', '-strokeWidth', '-size', '-shape', '-fillOpacity', '-strokeOpacity', '-opacity', '-text', 'ascending', 'descending', 'x', 'y', 'color', 'fill', 'stroke', 'strokeWidth', 'size', 'shape', 'fillOpacity', 'strokeOpacity', 'opacity', 'text'], None Sort order for the encoded field. For continuous fields (quantitative or temporal), ``sort`` can be either @@ -21712,7 +18680,7 @@ class XOffset(FieldChannelMixin, core.ScaleFieldDef): **See also:** `timeUnit `__ documentation. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -21804,27 +18772,23 @@ class XOffset(FieldChannelMixin, core.ScaleFieldDef): _encoding_name = "xOffset" @overload - def aggregate(self, _: NonArgAggregateOp_T, **kwds) -> XOffset: ... - + def aggregate(self, _: NonArgAggregateOp_T, /) -> XOffset: ... @overload def aggregate( - self, argmax: Optional[str | SchemaBase] = Undefined, **kwds + self, *, argmax: Optional[str | SchemaBase] = Undefined ) -> XOffset: ... - @overload def aggregate( - self, argmin: Optional[str | SchemaBase] = Undefined, **kwds + self, *, argmin: Optional[str | SchemaBase] = Undefined ) -> XOffset: ... - @overload - def bandPosition(self, _: float, **kwds) -> XOffset: ... - + def bandPosition(self, _: float, /) -> XOffset: ... @overload - def bin(self, _: bool, **kwds) -> XOffset: ... - + def bin(self, _: bool | Bin | None, /) -> XOffset: ... @overload def bin( self, + *, anchor: Optional[float] = Undefined, base: Optional[float] = Undefined, binned: Optional[bool] = Undefined, @@ -21835,25 +18799,21 @@ def bin( nice: Optional[bool] = Undefined, step: Optional[float] = Undefined, steps: Optional[Sequence[float]] = Undefined, - **kwds, ) -> XOffset: ... - - @overload - def bin(self, _: None, **kwds) -> XOffset: ... - @overload - def field(self, _: str, **kwds) -> XOffset: ... - + def field(self, _: str | RepeatRef, /) -> XOffset: ... @overload def field( self, + *, repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined, - **kwds, ) -> XOffset: ... - + @overload + def scale(self, _: Scale | None, /) -> XOffset: ... @overload def scale( self, + *, align: Optional[float | Parameter | SchemaBase | Map] = Undefined, base: Optional[float | Parameter | SchemaBase | Map] = Undefined, bins: Optional[SchemaBase | Sequence[float] | Map] = Undefined, @@ -21863,12 +18823,18 @@ def scale( Parameter | SchemaBase | Literal["unaggregated"] - | Sequence[str | bool | None | float | Parameter | SchemaBase | Map] + | Sequence[ + str | bool | float | Temporal | Parameter | SchemaBase | Map | None + ] | Map ] = Undefined, - domainMax: Optional[float | Parameter | SchemaBase | Map] = Undefined, + domainMax: Optional[ + float | Temporal | Parameter | SchemaBase | Map + ] = Undefined, domainMid: Optional[float | Parameter | SchemaBase | Map] = Undefined, - domainMin: Optional[float | Parameter | SchemaBase | Map] = Undefined, + domainMin: Optional[ + float | Temporal | Parameter | SchemaBase | Map + ] = Undefined, domainRaw: Optional[Parameter | SchemaBase | Map] = Undefined, exponent: Optional[float | Parameter | SchemaBase | Map] = Undefined, interpolate: Optional[ @@ -21893,154 +18859,76 @@ def scale( scheme: Optional[Parameter | SchemaBase | Map | ColorScheme_T] = Undefined, type: Optional[SchemaBase | ScaleType_T] = Undefined, zero: Optional[bool | Parameter | SchemaBase | Map] = Undefined, - **kwds, ) -> XOffset: ... - - @overload - def scale(self, _: None, **kwds) -> XOffset: ... - - @overload - def sort(self, _: list[float], **kwds) -> XOffset: ... - - @overload - def sort(self, _: list[str], **kwds) -> XOffset: ... - - @overload - def sort(self, _: list[bool], **kwds) -> XOffset: ... - - @overload - def sort(self, _: list[core.DateTime], **kwds) -> XOffset: ... - - @overload - def sort(self, _: SortOrder_T, **kwds) -> XOffset: ... - - @overload - def sort(self, _: SortByChannel_T, **kwds) -> XOffset: ... - @overload - def sort(self, _: SortByChannelDesc_T, **kwds) -> XOffset: ... - + def sort( + self, + _: Sequence[str] + | Sequence[bool] + | Sequence[float] + | Sequence[DateTime | Temporal] + | AllSortString_T + | None, + /, + ) -> XOffset: ... @overload def sort( self, + *, field: Optional[str | SchemaBase | Map] = Undefined, op: Optional[SchemaBase | NonArgAggregateOp_T] = Undefined, - order: Optional[None | SchemaBase | SortOrder_T] = Undefined, - **kwds, + order: Optional[SchemaBase | SortOrder_T | None] = Undefined, ) -> XOffset: ... - @overload def sort( self, + *, encoding: Optional[SchemaBase | SortByChannel_T] = Undefined, - order: Optional[None | SchemaBase | SortOrder_T] = Undefined, - **kwds, - ) -> XOffset: ... - - @overload - def sort(self, _: None, **kwds) -> XOffset: ... - - @overload - def timeUnit(self, _: LocalSingleTimeUnit_T, **kwds) -> XOffset: ... - - @overload - def timeUnit(self, _: UtcSingleTimeUnit_T, **kwds) -> XOffset: ... - - @overload - def timeUnit(self, _: LocalMultiTimeUnit_T, **kwds) -> XOffset: ... - - @overload - def timeUnit(self, _: UtcMultiTimeUnit_T, **kwds) -> XOffset: ... - - @overload - def timeUnit( - self, - _: Literal[ - "binnedyear", - "binnedyearquarter", - "binnedyearquartermonth", - "binnedyearmonth", - "binnedyearmonthdate", - "binnedyearmonthdatehours", - "binnedyearmonthdatehoursminutes", - "binnedyearmonthdatehoursminutesseconds", - "binnedyearweek", - "binnedyearweekday", - "binnedyearweekdayhours", - "binnedyearweekdayhoursminutes", - "binnedyearweekdayhoursminutesseconds", - "binnedyeardayofyear", - ], - **kwds, + order: Optional[SchemaBase | SortOrder_T | None] = Undefined, ) -> XOffset: ... - @overload def timeUnit( self, - _: Literal[ - "binnedutcyear", - "binnedutcyearquarter", - "binnedutcyearquartermonth", - "binnedutcyearmonth", - "binnedutcyearmonthdate", - "binnedutcyearmonthdatehours", - "binnedutcyearmonthdatehoursminutes", - "binnedutcyearmonthdatehoursminutesseconds", - "binnedutcyearweek", - "binnedutcyearweekday", - "binnedutcyearweekdayhours", - "binnedutcyearweekdayhoursminutes", - "binnedutcyearweekdayhoursminutesseconds", - "binnedutcyeardayofyear", - ], - **kwds, + _: TimeUnitParams | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T, + /, ) -> XOffset: ... - @overload def timeUnit( self, + *, binned: Optional[bool] = Undefined, maxbins: Optional[float] = Undefined, step: Optional[float] = Undefined, unit: Optional[SchemaBase | MultiTimeUnit_T | SingleTimeUnit_T] = Undefined, utc: Optional[bool] = Undefined, - **kwds, ) -> XOffset: ... - - @overload - def title(self, _: str, **kwds) -> XOffset: ... - - @overload - def title(self, _: list[str], **kwds) -> XOffset: ... - @overload - def title(self, _: None, **kwds) -> XOffset: ... - + def title(self, _: str | Sequence[str] | None, /) -> XOffset: ... @overload - def type(self, _: StandardType_T, **kwds) -> XOffset: ... + def type(self, _: StandardType_T, /) -> XOffset: ... def __init__( self, shorthand: Optional[str | SchemaBase | Sequence[str] | Map] = Undefined, aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Map] = Undefined, + bin: Optional[bool | SchemaBase | Map | None] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, sort: Optional[ - None - | SchemaBase + SchemaBase | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map | AllSortString_T + | None ] = Undefined, timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, **kwds, ): @@ -22070,9 +18958,9 @@ class XOffsetDatum(DatumChannelMixin, core.ScaleDatumDef): Relative position on a band of a stacked, binned, time unit, or band scale. For example, the marks will be positioned at the beginning of the band if set to ``0``, and at the middle of the band if set to ``0.5``. - datum : str, bool, dict, None, float, :class:`ExprRef`, :class:`DateTime`, :class:`RepeatRef`, :class:`PrimitiveValue` + datum : str, bool, dict, float, :class:`ExprRef`, :class:`DateTime`, :class:`RepeatRef`, :class:`PrimitiveValue`, None A constant value in data domain. - scale : dict, None, :class:`Scale` + scale : dict, :class:`Scale`, None An object defining properties of the channel's scale, which is the function that transforms values in the data domain (numbers, dates, strings, etc) to visual values (pixels, colors, sizes) of the encoding channels. @@ -22085,7 +18973,7 @@ class XOffsetDatum(DatumChannelMixin, core.ScaleDatumDef): **See also:** `scale `__ documentation. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -22177,11 +19065,13 @@ class XOffsetDatum(DatumChannelMixin, core.ScaleDatumDef): _encoding_name = "xOffset" @overload - def bandPosition(self, _: float, **kwds) -> XOffsetDatum: ... - + def bandPosition(self, _: float, /) -> XOffsetDatum: ... + @overload + def scale(self, _: Scale | None, /) -> XOffsetDatum: ... @overload def scale( self, + *, align: Optional[float | Parameter | SchemaBase | Map] = Undefined, base: Optional[float | Parameter | SchemaBase | Map] = Undefined, bins: Optional[SchemaBase | Sequence[float] | Map] = Undefined, @@ -22191,12 +19081,18 @@ def scale( Parameter | SchemaBase | Literal["unaggregated"] - | Sequence[str | bool | None | float | Parameter | SchemaBase | Map] + | Sequence[ + str | bool | float | Temporal | Parameter | SchemaBase | Map | None + ] | Map ] = Undefined, - domainMax: Optional[float | Parameter | SchemaBase | Map] = Undefined, + domainMax: Optional[ + float | Temporal | Parameter | SchemaBase | Map + ] = Undefined, domainMid: Optional[float | Parameter | SchemaBase | Map] = Undefined, - domainMin: Optional[float | Parameter | SchemaBase | Map] = Undefined, + domainMin: Optional[ + float | Temporal | Parameter | SchemaBase | Map + ] = Undefined, domainRaw: Optional[Parameter | SchemaBase | Map] = Undefined, exponent: Optional[float | Parameter | SchemaBase | Map] = Undefined, interpolate: Optional[ @@ -22221,30 +19117,18 @@ def scale( scheme: Optional[Parameter | SchemaBase | Map | ColorScheme_T] = Undefined, type: Optional[SchemaBase | ScaleType_T] = Undefined, zero: Optional[bool | Parameter | SchemaBase | Map] = Undefined, - **kwds, ) -> XOffsetDatum: ... - - @overload - def scale(self, _: None, **kwds) -> XOffsetDatum: ... - - @overload - def title(self, _: str, **kwds) -> XOffsetDatum: ... - - @overload - def title(self, _: list[str], **kwds) -> XOffsetDatum: ... - @overload - def title(self, _: None, **kwds) -> XOffsetDatum: ... - + def title(self, _: str | Sequence[str] | None, /) -> XOffsetDatum: ... @overload - def type(self, _: Type_T, **kwds) -> XOffsetDatum: ... + def type(self, _: Type_T, /) -> XOffsetDatum: ... def __init__( self, datum, bandPosition: Optional[float] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | Type_T] = Undefined, **kwds, ): @@ -22298,7 +19182,7 @@ class Y(FieldChannelMixin, core.PositionFieldDef): **See also:** `aggregate `__ documentation. - axis : dict, None, :class:`Axis` + axis : dict, :class:`Axis`, None An object defining properties of axis's gridlines, ticks and labels. If ``null``, the axis for the encoding channel will be removed. @@ -22311,7 +19195,7 @@ class Y(FieldChannelMixin, core.PositionFieldDef): Relative position on a band of a stacked, binned, time unit, or band scale. For example, the marks will be positioned at the beginning of the band if set to ``0``, and at the middle of the band if set to ``0.5``. - bin : bool, dict, None, Literal['binned'], :class:`BinParams` + bin : bool, dict, Literal['binned'], :class:`BinParams`, None A flag for binning a ``quantitative`` field, `an object defining binning parameters `__, or indicating that the data for ``x`` or ``y`` channel are binned before they are imported into @@ -22347,7 +19231,7 @@ class Y(FieldChannelMixin, core.PositionFieldDef): about escaping in the `field documentation `__. 2) ``field`` is not required if ``aggregate`` is ``count``. - impute : dict, None, :class:`ImputeParams` + impute : dict, :class:`ImputeParams`, None An object defining the properties of the Impute Operation to be applied. The field value of the other positional channel is taken as ``key`` of the ``Impute`` Operation. The field of the ``color`` channel if specified is used as ``groupby`` of @@ -22355,7 +19239,7 @@ class Y(FieldChannelMixin, core.PositionFieldDef): **See also:** `impute `__ documentation. - scale : dict, None, :class:`Scale` + scale : dict, :class:`Scale`, None An object defining properties of the channel's scale, which is the function that transforms values in the data domain (numbers, dates, strings, etc) to visual values (pixels, colors, sizes) of the encoding channels. @@ -22368,7 +19252,7 @@ class Y(FieldChannelMixin, core.PositionFieldDef): **See also:** `scale `__ documentation. - sort : dict, None, :class:`Sort`, Sequence[str], Sequence[bool], Sequence[float], :class:`SortArray`, :class:`SortOrder`, :class:`AllSortString`, :class:`SortByChannel`, :class:`SortByEncoding`, :class:`EncodingSortField`, :class:`SortByChannelDesc`, Sequence[dict, :class:`DateTime`], Literal['-x', '-y', '-color', '-fill', '-stroke', '-strokeWidth', '-size', '-shape', '-fillOpacity', '-strokeOpacity', '-opacity', '-text', 'ascending', 'descending', 'x', 'y', 'color', 'fill', 'stroke', 'strokeWidth', 'size', 'shape', 'fillOpacity', 'strokeOpacity', 'opacity', 'text'] + sort : dict, :class:`Sort`, Sequence[str], Sequence[bool], Sequence[float], :class:`SortArray`, :class:`SortOrder`, :class:`AllSortString`, :class:`SortByChannel`, :class:`SortByEncoding`, :class:`EncodingSortField`, :class:`SortByChannelDesc`, Sequence[dict, :class:`DateTime`], Literal['-x', '-y', '-color', '-fill', '-stroke', '-strokeWidth', '-size', '-shape', '-fillOpacity', '-strokeOpacity', '-opacity', '-text', 'ascending', 'descending', 'x', 'y', 'color', 'fill', 'stroke', 'strokeWidth', 'size', 'shape', 'fillOpacity', 'strokeOpacity', 'opacity', 'text'], None Sort order for the encoded field. For continuous fields (quantitative or temporal), ``sort`` can be either @@ -22406,7 +19290,7 @@ class Y(FieldChannelMixin, core.PositionFieldDef): **See also:** `sort `__ documentation. - stack : bool, None, :class:`StackOffset`, Literal['zero', 'center', 'normalize'] + stack : bool, :class:`StackOffset`, Literal['zero', 'center', 'normalize'], None Type of stacking offset if the field should be stacked. ``stack`` is only applicable for ``x``, ``y``, ``theta``, and ``radius`` channels with continuous domains. For example, ``stack`` of ``y`` can be used to customize stacking for a vertical bar @@ -22445,7 +19329,7 @@ class Y(FieldChannelMixin, core.PositionFieldDef): **See also:** `timeUnit `__ documentation. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -22537,28 +19421,24 @@ class Y(FieldChannelMixin, core.PositionFieldDef): _encoding_name = "y" @overload - def aggregate(self, _: NonArgAggregateOp_T, **kwds) -> Y: ... - + def aggregate(self, _: NonArgAggregateOp_T, /) -> Y: ... @overload - def aggregate( - self, argmax: Optional[str | SchemaBase] = Undefined, **kwds - ) -> Y: ... - + def aggregate(self, *, argmax: Optional[str | SchemaBase] = Undefined) -> Y: ... @overload - def aggregate( - self, argmin: Optional[str | SchemaBase] = Undefined, **kwds - ) -> Y: ... - + def aggregate(self, *, argmin: Optional[str | SchemaBase] = Undefined) -> Y: ... + @overload + def axis(self, _: Axis | None, /) -> Y: ... @overload def axis( self, + *, aria: Optional[bool | Parameter | SchemaBase | Map] = Undefined, bandPosition: Optional[float | Parameter | SchemaBase | Map] = Undefined, description: Optional[str | Parameter | SchemaBase | Map] = Undefined, domain: Optional[bool] = Undefined, domainCap: Optional[Parameter | SchemaBase | Map | StrokeCap_T] = Undefined, domainColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, domainDash: Optional[ Parameter | SchemaBase | Sequence[float] | Map @@ -22571,7 +19451,7 @@ def axis( grid: Optional[bool] = Undefined, gridCap: Optional[Parameter | SchemaBase | Map | StrokeCap_T] = Undefined, gridColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, gridDash: Optional[Parameter | SchemaBase | Sequence[float] | Map] = Undefined, gridDashOffset: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -22584,7 +19464,7 @@ def axis( ] = Undefined, labelBound: Optional[bool | float | Parameter | SchemaBase | Map] = Undefined, labelColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, labelExpr: Optional[str] = Undefined, labelFlush: Optional[bool | float] = Undefined, @@ -22616,7 +19496,7 @@ def axis( ] = Undefined, tickCap: Optional[Parameter | SchemaBase | Map | StrokeCap_T] = Undefined, tickColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, tickCount: Optional[ float | Parameter | SchemaBase | Map | TimeInterval_T @@ -22631,7 +19511,7 @@ def axis( tickSize: Optional[float | Parameter | SchemaBase | Map] = Undefined, tickWidth: Optional[float | Parameter | SchemaBase | Map] = Undefined, ticks: Optional[bool] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, titleAlign: Optional[Parameter | SchemaBase | Map | Align_T] = Undefined, titleAnchor: Optional[Parameter | SchemaBase | Map | TitleAnchor_T] = Undefined, titleAngle: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -22639,7 +19519,7 @@ def axis( Parameter | SchemaBase | Map | TextBaseline_T ] = Undefined, titleColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, titleFont: Optional[str | Parameter | SchemaBase | Map] = Undefined, titleFontSize: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -22660,25 +19540,19 @@ def axis( | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map ] = Undefined, zindex: Optional[float] = Undefined, - **kwds, ) -> Y: ... - - @overload - def axis(self, _: None, **kwds) -> Y: ... - @overload - def bandPosition(self, _: float, **kwds) -> Y: ... - + def bandPosition(self, _: float, /) -> Y: ... @overload - def bin(self, _: bool, **kwds) -> Y: ... - + def bin(self, _: bool | Bin | Literal["binned"] | None, /) -> Y: ... @overload def bin( self, + *, anchor: Optional[float] = Undefined, base: Optional[float] = Undefined, binned: Optional[bool] = Undefined, @@ -22689,41 +19563,32 @@ def bin( nice: Optional[bool] = Undefined, step: Optional[float] = Undefined, steps: Optional[Sequence[float]] = Undefined, - **kwds, ) -> Y: ... - @overload - def bin(self, _: Literal["binned"], **kwds) -> Y: ... - - @overload - def bin(self, _: None, **kwds) -> Y: ... - - @overload - def field(self, _: str, **kwds) -> Y: ... - + def field(self, _: str | RepeatRef, /) -> Y: ... @overload def field( self, + *, repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined, - **kwds, ) -> Y: ... - + @overload + def impute(self, _: Impute | None, /) -> Y: ... @overload def impute( self, - frame: Optional[Sequence[None | float]] = Undefined, + *, + frame: Optional[Sequence[float | None]] = Undefined, keyvals: Optional[SchemaBase | Sequence[Any] | Map] = Undefined, method: Optional[SchemaBase | ImputeMethod_T] = Undefined, value: Optional[Any] = Undefined, - **kwds, ) -> Y: ... - @overload - def impute(self, _: None, **kwds) -> Y: ... - + def scale(self, _: Scale | None, /) -> Y: ... @overload def scale( self, + *, align: Optional[float | Parameter | SchemaBase | Map] = Undefined, base: Optional[float | Parameter | SchemaBase | Map] = Undefined, bins: Optional[SchemaBase | Sequence[float] | Map] = Undefined, @@ -22733,12 +19598,18 @@ def scale( Parameter | SchemaBase | Literal["unaggregated"] - | Sequence[str | bool | None | float | Parameter | SchemaBase | Map] + | Sequence[ + str | bool | float | Temporal | Parameter | SchemaBase | Map | None + ] | Map ] = Undefined, - domainMax: Optional[float | Parameter | SchemaBase | Map] = Undefined, + domainMax: Optional[ + float | Temporal | Parameter | SchemaBase | Map + ] = Undefined, domainMid: Optional[float | Parameter | SchemaBase | Map] = Undefined, - domainMin: Optional[float | Parameter | SchemaBase | Map] = Undefined, + domainMin: Optional[ + float | Temporal | Parameter | SchemaBase | Map + ] = Undefined, domainRaw: Optional[Parameter | SchemaBase | Map] = Undefined, exponent: Optional[float | Parameter | SchemaBase | Map] = Undefined, interpolate: Optional[ @@ -22754,175 +19625,90 @@ def scale( SchemaBase | Sequence[str | float | Parameter | SchemaBase | Sequence[float] | Map] | Map - | RangeEnum_T - ] = Undefined, - rangeMax: Optional[str | float | Parameter | SchemaBase | Map] = Undefined, - rangeMin: Optional[str | float | Parameter | SchemaBase | Map] = Undefined, - reverse: Optional[bool | Parameter | SchemaBase | Map] = Undefined, - round: Optional[bool | Parameter | SchemaBase | Map] = Undefined, - scheme: Optional[Parameter | SchemaBase | Map | ColorScheme_T] = Undefined, - type: Optional[SchemaBase | ScaleType_T] = Undefined, - zero: Optional[bool | Parameter | SchemaBase | Map] = Undefined, - **kwds, - ) -> Y: ... - - @overload - def scale(self, _: None, **kwds) -> Y: ... - - @overload - def sort(self, _: list[float], **kwds) -> Y: ... - - @overload - def sort(self, _: list[str], **kwds) -> Y: ... - - @overload - def sort(self, _: list[bool], **kwds) -> Y: ... - - @overload - def sort(self, _: list[core.DateTime], **kwds) -> Y: ... - - @overload - def sort(self, _: SortOrder_T, **kwds) -> Y: ... - - @overload - def sort(self, _: SortByChannel_T, **kwds) -> Y: ... - + | RangeEnum_T + ] = Undefined, + rangeMax: Optional[str | float | Parameter | SchemaBase | Map] = Undefined, + rangeMin: Optional[str | float | Parameter | SchemaBase | Map] = Undefined, + reverse: Optional[bool | Parameter | SchemaBase | Map] = Undefined, + round: Optional[bool | Parameter | SchemaBase | Map] = Undefined, + scheme: Optional[Parameter | SchemaBase | Map | ColorScheme_T] = Undefined, + type: Optional[SchemaBase | ScaleType_T] = Undefined, + zero: Optional[bool | Parameter | SchemaBase | Map] = Undefined, + ) -> Y: ... @overload - def sort(self, _: SortByChannelDesc_T, **kwds) -> Y: ... - + def sort( + self, + _: Sequence[str] + | Sequence[bool] + | Sequence[float] + | Sequence[DateTime | Temporal] + | AllSortString_T + | None, + /, + ) -> Y: ... @overload def sort( self, + *, field: Optional[str | SchemaBase | Map] = Undefined, op: Optional[SchemaBase | NonArgAggregateOp_T] = Undefined, - order: Optional[None | SchemaBase | SortOrder_T] = Undefined, - **kwds, + order: Optional[SchemaBase | SortOrder_T | None] = Undefined, ) -> Y: ... - @overload def sort( self, + *, encoding: Optional[SchemaBase | SortByChannel_T] = Undefined, - order: Optional[None | SchemaBase | SortOrder_T] = Undefined, - **kwds, + order: Optional[SchemaBase | SortOrder_T | None] = Undefined, ) -> Y: ... - - @overload - def sort(self, _: None, **kwds) -> Y: ... - - @overload - def stack(self, _: StackOffset_T, **kwds) -> Y: ... - - @overload - def stack(self, _: None, **kwds) -> Y: ... - - @overload - def stack(self, _: bool, **kwds) -> Y: ... - - @overload - def timeUnit(self, _: LocalSingleTimeUnit_T, **kwds) -> Y: ... - - @overload - def timeUnit(self, _: UtcSingleTimeUnit_T, **kwds) -> Y: ... - - @overload - def timeUnit(self, _: LocalMultiTimeUnit_T, **kwds) -> Y: ... - @overload - def timeUnit(self, _: UtcMultiTimeUnit_T, **kwds) -> Y: ... - - @overload - def timeUnit( - self, - _: Literal[ - "binnedyear", - "binnedyearquarter", - "binnedyearquartermonth", - "binnedyearmonth", - "binnedyearmonthdate", - "binnedyearmonthdatehours", - "binnedyearmonthdatehoursminutes", - "binnedyearmonthdatehoursminutesseconds", - "binnedyearweek", - "binnedyearweekday", - "binnedyearweekdayhours", - "binnedyearweekdayhoursminutes", - "binnedyearweekdayhoursminutesseconds", - "binnedyeardayofyear", - ], - **kwds, - ) -> Y: ... - + def stack(self, _: bool | StackOffset_T | None, /) -> Y: ... @overload def timeUnit( self, - _: Literal[ - "binnedutcyear", - "binnedutcyearquarter", - "binnedutcyearquartermonth", - "binnedutcyearmonth", - "binnedutcyearmonthdate", - "binnedutcyearmonthdatehours", - "binnedutcyearmonthdatehoursminutes", - "binnedutcyearmonthdatehoursminutesseconds", - "binnedutcyearweek", - "binnedutcyearweekday", - "binnedutcyearweekdayhours", - "binnedutcyearweekdayhoursminutes", - "binnedutcyearweekdayhoursminutesseconds", - "binnedutcyeardayofyear", - ], - **kwds, + _: TimeUnitParams | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T, + /, ) -> Y: ... - @overload def timeUnit( self, + *, binned: Optional[bool] = Undefined, maxbins: Optional[float] = Undefined, step: Optional[float] = Undefined, unit: Optional[SchemaBase | MultiTimeUnit_T | SingleTimeUnit_T] = Undefined, utc: Optional[bool] = Undefined, - **kwds, ) -> Y: ... - - @overload - def title(self, _: str, **kwds) -> Y: ... - - @overload - def title(self, _: list[str], **kwds) -> Y: ... - @overload - def title(self, _: None, **kwds) -> Y: ... - + def title(self, _: str | Sequence[str] | None, /) -> Y: ... @overload - def type(self, _: StandardType_T, **kwds) -> Y: ... + def type(self, _: StandardType_T, /) -> Y: ... def __init__( self, shorthand: Optional[str | SchemaBase | Sequence[str] | Map] = Undefined, aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, - axis: Optional[None | SchemaBase | Map] = Undefined, + axis: Optional[SchemaBase | Map | None] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Literal["binned"] | Map] = Undefined, + bin: Optional[bool | SchemaBase | Literal["binned"] | Map | None] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, - impute: Optional[None | SchemaBase | Map] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, + impute: Optional[SchemaBase | Map | None] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, sort: Optional[ - None - | SchemaBase + SchemaBase | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map | AllSortString_T + | None ] = Undefined, - stack: Optional[bool | None | SchemaBase | StackOffset_T] = Undefined, + stack: Optional[bool | SchemaBase | StackOffset_T | None] = Undefined, timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, **kwds, ): @@ -22951,7 +19737,7 @@ class YDatum(DatumChannelMixin, core.PositionDatumDef): Parameters ---------- - axis : dict, None, :class:`Axis` + axis : dict, :class:`Axis`, None An object defining properties of axis's gridlines, ticks and labels. If ``null``, the axis for the encoding channel will be removed. @@ -22964,9 +19750,9 @@ class YDatum(DatumChannelMixin, core.PositionDatumDef): Relative position on a band of a stacked, binned, time unit, or band scale. For example, the marks will be positioned at the beginning of the band if set to ``0``, and at the middle of the band if set to ``0.5``. - datum : str, bool, dict, None, float, :class:`ExprRef`, :class:`DateTime`, :class:`RepeatRef`, :class:`PrimitiveValue` + datum : str, bool, dict, float, :class:`ExprRef`, :class:`DateTime`, :class:`RepeatRef`, :class:`PrimitiveValue`, None A constant value in data domain. - impute : dict, None, :class:`ImputeParams` + impute : dict, :class:`ImputeParams`, None An object defining the properties of the Impute Operation to be applied. The field value of the other positional channel is taken as ``key`` of the ``Impute`` Operation. The field of the ``color`` channel if specified is used as ``groupby`` of @@ -22974,7 +19760,7 @@ class YDatum(DatumChannelMixin, core.PositionDatumDef): **See also:** `impute `__ documentation. - scale : dict, None, :class:`Scale` + scale : dict, :class:`Scale`, None An object defining properties of the channel's scale, which is the function that transforms values in the data domain (numbers, dates, strings, etc) to visual values (pixels, colors, sizes) of the encoding channels. @@ -22987,7 +19773,7 @@ class YDatum(DatumChannelMixin, core.PositionDatumDef): **See also:** `scale `__ documentation. - stack : bool, None, :class:`StackOffset`, Literal['zero', 'center', 'normalize'] + stack : bool, :class:`StackOffset`, Literal['zero', 'center', 'normalize'], None Type of stacking offset if the field should be stacked. ``stack`` is only applicable for ``x``, ``y``, ``theta``, and ``radius`` channels with continuous domains. For example, ``stack`` of ``y`` can be used to customize stacking for a vertical bar @@ -23017,7 +19803,7 @@ class YDatum(DatumChannelMixin, core.PositionDatumDef): **See also:** `stack `__ documentation. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -23108,16 +19894,19 @@ class YDatum(DatumChannelMixin, core.PositionDatumDef): _class_is_valid_at_instantiation = False _encoding_name = "y" + @overload + def axis(self, _: Axis | None, /) -> YDatum: ... @overload def axis( self, + *, aria: Optional[bool | Parameter | SchemaBase | Map] = Undefined, bandPosition: Optional[float | Parameter | SchemaBase | Map] = Undefined, description: Optional[str | Parameter | SchemaBase | Map] = Undefined, domain: Optional[bool] = Undefined, domainCap: Optional[Parameter | SchemaBase | Map | StrokeCap_T] = Undefined, domainColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, domainDash: Optional[ Parameter | SchemaBase | Sequence[float] | Map @@ -23130,7 +19919,7 @@ def axis( grid: Optional[bool] = Undefined, gridCap: Optional[Parameter | SchemaBase | Map | StrokeCap_T] = Undefined, gridColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, gridDash: Optional[Parameter | SchemaBase | Sequence[float] | Map] = Undefined, gridDashOffset: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -23143,7 +19932,7 @@ def axis( ] = Undefined, labelBound: Optional[bool | float | Parameter | SchemaBase | Map] = Undefined, labelColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, labelExpr: Optional[str] = Undefined, labelFlush: Optional[bool | float] = Undefined, @@ -23175,7 +19964,7 @@ def axis( ] = Undefined, tickCap: Optional[Parameter | SchemaBase | Map | StrokeCap_T] = Undefined, tickColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, tickCount: Optional[ float | Parameter | SchemaBase | Map | TimeInterval_T @@ -23190,7 +19979,7 @@ def axis( tickSize: Optional[float | Parameter | SchemaBase | Map] = Undefined, tickWidth: Optional[float | Parameter | SchemaBase | Map] = Undefined, ticks: Optional[bool] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, titleAlign: Optional[Parameter | SchemaBase | Map | Align_T] = Undefined, titleAnchor: Optional[Parameter | SchemaBase | Map | TitleAnchor_T] = Undefined, titleAngle: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -23198,7 +19987,7 @@ def axis( Parameter | SchemaBase | Map | TextBaseline_T ] = Undefined, titleColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, titleFont: Optional[str | Parameter | SchemaBase | Map] = Undefined, titleFontSize: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -23219,35 +20008,30 @@ def axis( | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map ] = Undefined, zindex: Optional[float] = Undefined, - **kwds, ) -> YDatum: ... - @overload - def axis(self, _: None, **kwds) -> YDatum: ... - + def bandPosition(self, _: float, /) -> YDatum: ... @overload - def bandPosition(self, _: float, **kwds) -> YDatum: ... - + def impute(self, _: Impute | None, /) -> YDatum: ... @overload def impute( self, - frame: Optional[Sequence[None | float]] = Undefined, + *, + frame: Optional[Sequence[float | None]] = Undefined, keyvals: Optional[SchemaBase | Sequence[Any] | Map] = Undefined, method: Optional[SchemaBase | ImputeMethod_T] = Undefined, value: Optional[Any] = Undefined, - **kwds, ) -> YDatum: ... - @overload - def impute(self, _: None, **kwds) -> YDatum: ... - + def scale(self, _: Scale | None, /) -> YDatum: ... @overload def scale( self, + *, align: Optional[float | Parameter | SchemaBase | Map] = Undefined, base: Optional[float | Parameter | SchemaBase | Map] = Undefined, bins: Optional[SchemaBase | Sequence[float] | Map] = Undefined, @@ -23257,12 +20041,18 @@ def scale( Parameter | SchemaBase | Literal["unaggregated"] - | Sequence[str | bool | None | float | Parameter | SchemaBase | Map] + | Sequence[ + str | bool | float | Temporal | Parameter | SchemaBase | Map | None + ] | Map ] = Undefined, - domainMax: Optional[float | Parameter | SchemaBase | Map] = Undefined, + domainMax: Optional[ + float | Temporal | Parameter | SchemaBase | Map + ] = Undefined, domainMid: Optional[float | Parameter | SchemaBase | Map] = Undefined, - domainMin: Optional[float | Parameter | SchemaBase | Map] = Undefined, + domainMin: Optional[ + float | Temporal | Parameter | SchemaBase | Map + ] = Undefined, domainRaw: Optional[Parameter | SchemaBase | Map] = Undefined, exponent: Optional[float | Parameter | SchemaBase | Map] = Undefined, interpolate: Optional[ @@ -23287,42 +20077,23 @@ def scale( scheme: Optional[Parameter | SchemaBase | Map | ColorScheme_T] = Undefined, type: Optional[SchemaBase | ScaleType_T] = Undefined, zero: Optional[bool | Parameter | SchemaBase | Map] = Undefined, - **kwds, ) -> YDatum: ... - - @overload - def scale(self, _: None, **kwds) -> YDatum: ... - - @overload - def stack(self, _: StackOffset_T, **kwds) -> YDatum: ... - - @overload - def stack(self, _: None, **kwds) -> YDatum: ... - - @overload - def stack(self, _: bool, **kwds) -> YDatum: ... - - @overload - def title(self, _: str, **kwds) -> YDatum: ... - @overload - def title(self, _: list[str], **kwds) -> YDatum: ... - + def stack(self, _: bool | StackOffset_T | None, /) -> YDatum: ... @overload - def title(self, _: None, **kwds) -> YDatum: ... - + def title(self, _: str | Sequence[str] | None, /) -> YDatum: ... @overload - def type(self, _: Type_T, **kwds) -> YDatum: ... + def type(self, _: Type_T, /) -> YDatum: ... def __init__( self, datum, - axis: Optional[None | SchemaBase | Map] = Undefined, + axis: Optional[SchemaBase | Map | None] = Undefined, bandPosition: Optional[float] = Undefined, - impute: Optional[None | SchemaBase | Map] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, - stack: Optional[bool | None | SchemaBase | StackOffset_T] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + impute: Optional[SchemaBase | Map | None] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, + stack: Optional[bool | SchemaBase | StackOffset_T | None] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | Type_T] = Undefined, **kwds, ): @@ -23431,7 +20202,7 @@ class Y2(FieldChannelMixin, core.SecondaryFieldDef): **See also:** `timeUnit `__ documentation. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -23457,109 +20228,41 @@ class Y2(FieldChannelMixin, core.SecondaryFieldDef): _encoding_name = "y2" @overload - def aggregate(self, _: NonArgAggregateOp_T, **kwds) -> Y2: ... - + def aggregate(self, _: NonArgAggregateOp_T, /) -> Y2: ... @overload - def aggregate( - self, argmax: Optional[str | SchemaBase] = Undefined, **kwds - ) -> Y2: ... - + def aggregate(self, *, argmax: Optional[str | SchemaBase] = Undefined) -> Y2: ... @overload - def aggregate( - self, argmin: Optional[str | SchemaBase] = Undefined, **kwds - ) -> Y2: ... - + def aggregate(self, *, argmin: Optional[str | SchemaBase] = Undefined) -> Y2: ... @overload - def bandPosition(self, _: float, **kwds) -> Y2: ... - + def bandPosition(self, _: float, /) -> Y2: ... @overload - def bin(self, _: None, **kwds) -> Y2: ... - + def bin(self, _: None, /) -> Y2: ... @overload - def field(self, _: str, **kwds) -> Y2: ... - + def field(self, _: str | RepeatRef, /) -> Y2: ... @overload def field( self, + *, repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined, - **kwds, - ) -> Y2: ... - - @overload - def timeUnit(self, _: LocalSingleTimeUnit_T, **kwds) -> Y2: ... - - @overload - def timeUnit(self, _: UtcSingleTimeUnit_T, **kwds) -> Y2: ... - - @overload - def timeUnit(self, _: LocalMultiTimeUnit_T, **kwds) -> Y2: ... - - @overload - def timeUnit(self, _: UtcMultiTimeUnit_T, **kwds) -> Y2: ... - - @overload - def timeUnit( - self, - _: Literal[ - "binnedyear", - "binnedyearquarter", - "binnedyearquartermonth", - "binnedyearmonth", - "binnedyearmonthdate", - "binnedyearmonthdatehours", - "binnedyearmonthdatehoursminutes", - "binnedyearmonthdatehoursminutesseconds", - "binnedyearweek", - "binnedyearweekday", - "binnedyearweekdayhours", - "binnedyearweekdayhoursminutes", - "binnedyearweekdayhoursminutesseconds", - "binnedyeardayofyear", - ], - **kwds, ) -> Y2: ... - @overload def timeUnit( self, - _: Literal[ - "binnedutcyear", - "binnedutcyearquarter", - "binnedutcyearquartermonth", - "binnedutcyearmonth", - "binnedutcyearmonthdate", - "binnedutcyearmonthdatehours", - "binnedutcyearmonthdatehoursminutes", - "binnedutcyearmonthdatehoursminutesseconds", - "binnedutcyearweek", - "binnedutcyearweekday", - "binnedutcyearweekdayhours", - "binnedutcyearweekdayhoursminutes", - "binnedutcyearweekdayhoursminutesseconds", - "binnedutcyeardayofyear", - ], - **kwds, + _: TimeUnitParams | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T, + /, ) -> Y2: ... - @overload def timeUnit( self, + *, binned: Optional[bool] = Undefined, maxbins: Optional[float] = Undefined, step: Optional[float] = Undefined, unit: Optional[SchemaBase | MultiTimeUnit_T | SingleTimeUnit_T] = Undefined, utc: Optional[bool] = Undefined, - **kwds, ) -> Y2: ... - - @overload - def title(self, _: str, **kwds) -> Y2: ... - - @overload - def title(self, _: list[str], **kwds) -> Y2: ... - @overload - def title(self, _: None, **kwds) -> Y2: ... + def title(self, _: str | Sequence[str] | None, /) -> Y2: ... def __init__( self, @@ -23571,7 +20274,7 @@ def __init__( timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, **kwds, ): super().__init__( @@ -23597,9 +20300,9 @@ class Y2Datum(DatumChannelMixin, core.DatumDef): Relative position on a band of a stacked, binned, time unit, or band scale. For example, the marks will be positioned at the beginning of the band if set to ``0``, and at the middle of the band if set to ``0.5``. - datum : str, bool, dict, None, float, :class:`ExprRef`, :class:`DateTime`, :class:`RepeatRef`, :class:`PrimitiveValue` + datum : str, bool, dict, float, :class:`ExprRef`, :class:`DateTime`, :class:`RepeatRef`, :class:`PrimitiveValue`, None A constant value in data domain. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -23691,25 +20394,17 @@ class Y2Datum(DatumChannelMixin, core.DatumDef): _encoding_name = "y2" @overload - def bandPosition(self, _: float, **kwds) -> Y2Datum: ... - - @overload - def title(self, _: str, **kwds) -> Y2Datum: ... - - @overload - def title(self, _: list[str], **kwds) -> Y2Datum: ... - + def bandPosition(self, _: float, /) -> Y2Datum: ... @overload - def title(self, _: None, **kwds) -> Y2Datum: ... - + def title(self, _: str | Sequence[str] | None, /) -> Y2Datum: ... @overload - def type(self, _: Type_T, **kwds) -> Y2Datum: ... + def type(self, _: Type_T, /) -> Y2Datum: ... def __init__( self, datum, bandPosition: Optional[float] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | Type_T] = Undefined, **kwds, ): @@ -23810,7 +20505,7 @@ class YError(FieldChannelMixin, core.SecondaryFieldDef): **See also:** `timeUnit `__ documentation. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -23836,109 +20531,45 @@ class YError(FieldChannelMixin, core.SecondaryFieldDef): _encoding_name = "yError" @overload - def aggregate(self, _: NonArgAggregateOp_T, **kwds) -> YError: ... - + def aggregate(self, _: NonArgAggregateOp_T, /) -> YError: ... @overload def aggregate( - self, argmax: Optional[str | SchemaBase] = Undefined, **kwds + self, *, argmax: Optional[str | SchemaBase] = Undefined ) -> YError: ... - @overload def aggregate( - self, argmin: Optional[str | SchemaBase] = Undefined, **kwds + self, *, argmin: Optional[str | SchemaBase] = Undefined ) -> YError: ... - @overload - def bandPosition(self, _: float, **kwds) -> YError: ... - + def bandPosition(self, _: float, /) -> YError: ... @overload - def bin(self, _: None, **kwds) -> YError: ... - + def bin(self, _: None, /) -> YError: ... @overload - def field(self, _: str, **kwds) -> YError: ... - + def field(self, _: str | RepeatRef, /) -> YError: ... @overload def field( self, + *, repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined, - **kwds, - ) -> YError: ... - - @overload - def timeUnit(self, _: LocalSingleTimeUnit_T, **kwds) -> YError: ... - - @overload - def timeUnit(self, _: UtcSingleTimeUnit_T, **kwds) -> YError: ... - - @overload - def timeUnit(self, _: LocalMultiTimeUnit_T, **kwds) -> YError: ... - - @overload - def timeUnit(self, _: UtcMultiTimeUnit_T, **kwds) -> YError: ... - - @overload - def timeUnit( - self, - _: Literal[ - "binnedyear", - "binnedyearquarter", - "binnedyearquartermonth", - "binnedyearmonth", - "binnedyearmonthdate", - "binnedyearmonthdatehours", - "binnedyearmonthdatehoursminutes", - "binnedyearmonthdatehoursminutesseconds", - "binnedyearweek", - "binnedyearweekday", - "binnedyearweekdayhours", - "binnedyearweekdayhoursminutes", - "binnedyearweekdayhoursminutesseconds", - "binnedyeardayofyear", - ], - **kwds, ) -> YError: ... - @overload def timeUnit( self, - _: Literal[ - "binnedutcyear", - "binnedutcyearquarter", - "binnedutcyearquartermonth", - "binnedutcyearmonth", - "binnedutcyearmonthdate", - "binnedutcyearmonthdatehours", - "binnedutcyearmonthdatehoursminutes", - "binnedutcyearmonthdatehoursminutesseconds", - "binnedutcyearweek", - "binnedutcyearweekday", - "binnedutcyearweekdayhours", - "binnedutcyearweekdayhoursminutes", - "binnedutcyearweekdayhoursminutesseconds", - "binnedutcyeardayofyear", - ], - **kwds, + _: TimeUnitParams | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T, + /, ) -> YError: ... - @overload def timeUnit( self, + *, binned: Optional[bool] = Undefined, maxbins: Optional[float] = Undefined, step: Optional[float] = Undefined, unit: Optional[SchemaBase | MultiTimeUnit_T | SingleTimeUnit_T] = Undefined, utc: Optional[bool] = Undefined, - **kwds, ) -> YError: ... - - @overload - def title(self, _: str, **kwds) -> YError: ... - - @overload - def title(self, _: list[str], **kwds) -> YError: ... - @overload - def title(self, _: None, **kwds) -> YError: ... + def title(self, _: str | Sequence[str] | None, /) -> YError: ... def __init__( self, @@ -23950,7 +20581,7 @@ def __init__( timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, **kwds, ): super().__init__( @@ -24057,7 +20688,7 @@ class YError2(FieldChannelMixin, core.SecondaryFieldDef): **See also:** `timeUnit `__ documentation. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -24083,109 +20714,45 @@ class YError2(FieldChannelMixin, core.SecondaryFieldDef): _encoding_name = "yError2" @overload - def aggregate(self, _: NonArgAggregateOp_T, **kwds) -> YError2: ... - + def aggregate(self, _: NonArgAggregateOp_T, /) -> YError2: ... @overload def aggregate( - self, argmax: Optional[str | SchemaBase] = Undefined, **kwds + self, *, argmax: Optional[str | SchemaBase] = Undefined ) -> YError2: ... - @overload def aggregate( - self, argmin: Optional[str | SchemaBase] = Undefined, **kwds + self, *, argmin: Optional[str | SchemaBase] = Undefined ) -> YError2: ... - @overload - def bandPosition(self, _: float, **kwds) -> YError2: ... - + def bandPosition(self, _: float, /) -> YError2: ... @overload - def bin(self, _: None, **kwds) -> YError2: ... - + def bin(self, _: None, /) -> YError2: ... @overload - def field(self, _: str, **kwds) -> YError2: ... - + def field(self, _: str | RepeatRef, /) -> YError2: ... @overload def field( self, + *, repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined, - **kwds, - ) -> YError2: ... - - @overload - def timeUnit(self, _: LocalSingleTimeUnit_T, **kwds) -> YError2: ... - - @overload - def timeUnit(self, _: UtcSingleTimeUnit_T, **kwds) -> YError2: ... - - @overload - def timeUnit(self, _: LocalMultiTimeUnit_T, **kwds) -> YError2: ... - - @overload - def timeUnit(self, _: UtcMultiTimeUnit_T, **kwds) -> YError2: ... - - @overload - def timeUnit( - self, - _: Literal[ - "binnedyear", - "binnedyearquarter", - "binnedyearquartermonth", - "binnedyearmonth", - "binnedyearmonthdate", - "binnedyearmonthdatehours", - "binnedyearmonthdatehoursminutes", - "binnedyearmonthdatehoursminutesseconds", - "binnedyearweek", - "binnedyearweekday", - "binnedyearweekdayhours", - "binnedyearweekdayhoursminutes", - "binnedyearweekdayhoursminutesseconds", - "binnedyeardayofyear", - ], - **kwds, ) -> YError2: ... - @overload def timeUnit( self, - _: Literal[ - "binnedutcyear", - "binnedutcyearquarter", - "binnedutcyearquartermonth", - "binnedutcyearmonth", - "binnedutcyearmonthdate", - "binnedutcyearmonthdatehours", - "binnedutcyearmonthdatehoursminutes", - "binnedutcyearmonthdatehoursminutesseconds", - "binnedutcyearweek", - "binnedutcyearweekday", - "binnedutcyearweekdayhours", - "binnedutcyearweekdayhoursminutes", - "binnedutcyearweekdayhoursminutesseconds", - "binnedutcyeardayofyear", - ], - **kwds, + _: TimeUnitParams | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T, + /, ) -> YError2: ... - @overload def timeUnit( self, + *, binned: Optional[bool] = Undefined, maxbins: Optional[float] = Undefined, step: Optional[float] = Undefined, unit: Optional[SchemaBase | MultiTimeUnit_T | SingleTimeUnit_T] = Undefined, utc: Optional[bool] = Undefined, - **kwds, ) -> YError2: ... - - @overload - def title(self, _: str, **kwds) -> YError2: ... - - @overload - def title(self, _: list[str], **kwds) -> YError2: ... - @overload - def title(self, _: None, **kwds) -> YError2: ... + def title(self, _: str | Sequence[str] | None, /) -> YError2: ... def __init__( self, @@ -24197,7 +20764,7 @@ def __init__( timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, **kwds, ): super().__init__( @@ -24256,7 +20823,7 @@ class YOffset(FieldChannelMixin, core.ScaleFieldDef): Relative position on a band of a stacked, binned, time unit, or band scale. For example, the marks will be positioned at the beginning of the band if set to ``0``, and at the middle of the band if set to ``0.5``. - bin : bool, dict, None, :class:`BinParams` + bin : bool, dict, :class:`BinParams`, None A flag for binning a ``quantitative`` field, `an object defining binning parameters `__, or indicating that the data for ``x`` or ``y`` channel are binned before they are imported into @@ -24292,7 +20859,7 @@ class YOffset(FieldChannelMixin, core.ScaleFieldDef): about escaping in the `field documentation `__. 2) ``field`` is not required if ``aggregate`` is ``count``. - scale : dict, None, :class:`Scale` + scale : dict, :class:`Scale`, None An object defining properties of the channel's scale, which is the function that transforms values in the data domain (numbers, dates, strings, etc) to visual values (pixels, colors, sizes) of the encoding channels. @@ -24305,7 +20872,7 @@ class YOffset(FieldChannelMixin, core.ScaleFieldDef): **See also:** `scale `__ documentation. - sort : dict, None, :class:`Sort`, Sequence[str], Sequence[bool], Sequence[float], :class:`SortArray`, :class:`SortOrder`, :class:`AllSortString`, :class:`SortByChannel`, :class:`SortByEncoding`, :class:`EncodingSortField`, :class:`SortByChannelDesc`, Sequence[dict, :class:`DateTime`], Literal['-x', '-y', '-color', '-fill', '-stroke', '-strokeWidth', '-size', '-shape', '-fillOpacity', '-strokeOpacity', '-opacity', '-text', 'ascending', 'descending', 'x', 'y', 'color', 'fill', 'stroke', 'strokeWidth', 'size', 'shape', 'fillOpacity', 'strokeOpacity', 'opacity', 'text'] + sort : dict, :class:`Sort`, Sequence[str], Sequence[bool], Sequence[float], :class:`SortArray`, :class:`SortOrder`, :class:`AllSortString`, :class:`SortByChannel`, :class:`SortByEncoding`, :class:`EncodingSortField`, :class:`SortByChannelDesc`, Sequence[dict, :class:`DateTime`], Literal['-x', '-y', '-color', '-fill', '-stroke', '-strokeWidth', '-size', '-shape', '-fillOpacity', '-strokeOpacity', '-opacity', '-text', 'ascending', 'descending', 'x', 'y', 'color', 'fill', 'stroke', 'strokeWidth', 'size', 'shape', 'fillOpacity', 'strokeOpacity', 'opacity', 'text'], None Sort order for the encoded field. For continuous fields (quantitative or temporal), ``sort`` can be either @@ -24352,7 +20919,7 @@ class YOffset(FieldChannelMixin, core.ScaleFieldDef): **See also:** `timeUnit `__ documentation. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -24444,27 +21011,23 @@ class YOffset(FieldChannelMixin, core.ScaleFieldDef): _encoding_name = "yOffset" @overload - def aggregate(self, _: NonArgAggregateOp_T, **kwds) -> YOffset: ... - + def aggregate(self, _: NonArgAggregateOp_T, /) -> YOffset: ... @overload def aggregate( - self, argmax: Optional[str | SchemaBase] = Undefined, **kwds + self, *, argmax: Optional[str | SchemaBase] = Undefined ) -> YOffset: ... - @overload def aggregate( - self, argmin: Optional[str | SchemaBase] = Undefined, **kwds + self, *, argmin: Optional[str | SchemaBase] = Undefined ) -> YOffset: ... - @overload - def bandPosition(self, _: float, **kwds) -> YOffset: ... - + def bandPosition(self, _: float, /) -> YOffset: ... @overload - def bin(self, _: bool, **kwds) -> YOffset: ... - + def bin(self, _: bool | Bin | None, /) -> YOffset: ... @overload def bin( self, + *, anchor: Optional[float] = Undefined, base: Optional[float] = Undefined, binned: Optional[bool] = Undefined, @@ -24475,25 +21038,21 @@ def bin( nice: Optional[bool] = Undefined, step: Optional[float] = Undefined, steps: Optional[Sequence[float]] = Undefined, - **kwds, ) -> YOffset: ... - - @overload - def bin(self, _: None, **kwds) -> YOffset: ... - @overload - def field(self, _: str, **kwds) -> YOffset: ... - + def field(self, _: str | RepeatRef, /) -> YOffset: ... @overload def field( self, + *, repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined, - **kwds, ) -> YOffset: ... - + @overload + def scale(self, _: Scale | None, /) -> YOffset: ... @overload def scale( self, + *, align: Optional[float | Parameter | SchemaBase | Map] = Undefined, base: Optional[float | Parameter | SchemaBase | Map] = Undefined, bins: Optional[SchemaBase | Sequence[float] | Map] = Undefined, @@ -24503,12 +21062,18 @@ def scale( Parameter | SchemaBase | Literal["unaggregated"] - | Sequence[str | bool | None | float | Parameter | SchemaBase | Map] + | Sequence[ + str | bool | float | Temporal | Parameter | SchemaBase | Map | None + ] | Map ] = Undefined, - domainMax: Optional[float | Parameter | SchemaBase | Map] = Undefined, + domainMax: Optional[ + float | Temporal | Parameter | SchemaBase | Map + ] = Undefined, domainMid: Optional[float | Parameter | SchemaBase | Map] = Undefined, - domainMin: Optional[float | Parameter | SchemaBase | Map] = Undefined, + domainMin: Optional[ + float | Temporal | Parameter | SchemaBase | Map + ] = Undefined, domainRaw: Optional[Parameter | SchemaBase | Map] = Undefined, exponent: Optional[float | Parameter | SchemaBase | Map] = Undefined, interpolate: Optional[ @@ -24533,154 +21098,76 @@ def scale( scheme: Optional[Parameter | SchemaBase | Map | ColorScheme_T] = Undefined, type: Optional[SchemaBase | ScaleType_T] = Undefined, zero: Optional[bool | Parameter | SchemaBase | Map] = Undefined, - **kwds, ) -> YOffset: ... - - @overload - def scale(self, _: None, **kwds) -> YOffset: ... - - @overload - def sort(self, _: list[float], **kwds) -> YOffset: ... - - @overload - def sort(self, _: list[str], **kwds) -> YOffset: ... - - @overload - def sort(self, _: list[bool], **kwds) -> YOffset: ... - - @overload - def sort(self, _: list[core.DateTime], **kwds) -> YOffset: ... - - @overload - def sort(self, _: SortOrder_T, **kwds) -> YOffset: ... - - @overload - def sort(self, _: SortByChannel_T, **kwds) -> YOffset: ... - @overload - def sort(self, _: SortByChannelDesc_T, **kwds) -> YOffset: ... - + def sort( + self, + _: Sequence[str] + | Sequence[bool] + | Sequence[float] + | Sequence[DateTime | Temporal] + | AllSortString_T + | None, + /, + ) -> YOffset: ... @overload def sort( self, + *, field: Optional[str | SchemaBase | Map] = Undefined, op: Optional[SchemaBase | NonArgAggregateOp_T] = Undefined, - order: Optional[None | SchemaBase | SortOrder_T] = Undefined, - **kwds, + order: Optional[SchemaBase | SortOrder_T | None] = Undefined, ) -> YOffset: ... - @overload def sort( self, + *, encoding: Optional[SchemaBase | SortByChannel_T] = Undefined, - order: Optional[None | SchemaBase | SortOrder_T] = Undefined, - **kwds, - ) -> YOffset: ... - - @overload - def sort(self, _: None, **kwds) -> YOffset: ... - - @overload - def timeUnit(self, _: LocalSingleTimeUnit_T, **kwds) -> YOffset: ... - - @overload - def timeUnit(self, _: UtcSingleTimeUnit_T, **kwds) -> YOffset: ... - - @overload - def timeUnit(self, _: LocalMultiTimeUnit_T, **kwds) -> YOffset: ... - - @overload - def timeUnit(self, _: UtcMultiTimeUnit_T, **kwds) -> YOffset: ... - - @overload - def timeUnit( - self, - _: Literal[ - "binnedyear", - "binnedyearquarter", - "binnedyearquartermonth", - "binnedyearmonth", - "binnedyearmonthdate", - "binnedyearmonthdatehours", - "binnedyearmonthdatehoursminutes", - "binnedyearmonthdatehoursminutesseconds", - "binnedyearweek", - "binnedyearweekday", - "binnedyearweekdayhours", - "binnedyearweekdayhoursminutes", - "binnedyearweekdayhoursminutesseconds", - "binnedyeardayofyear", - ], - **kwds, + order: Optional[SchemaBase | SortOrder_T | None] = Undefined, ) -> YOffset: ... - @overload def timeUnit( self, - _: Literal[ - "binnedutcyear", - "binnedutcyearquarter", - "binnedutcyearquartermonth", - "binnedutcyearmonth", - "binnedutcyearmonthdate", - "binnedutcyearmonthdatehours", - "binnedutcyearmonthdatehoursminutes", - "binnedutcyearmonthdatehoursminutesseconds", - "binnedutcyearweek", - "binnedutcyearweekday", - "binnedutcyearweekdayhours", - "binnedutcyearweekdayhoursminutes", - "binnedutcyearweekdayhoursminutesseconds", - "binnedutcyeardayofyear", - ], - **kwds, + _: TimeUnitParams | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T, + /, ) -> YOffset: ... - @overload def timeUnit( self, + *, binned: Optional[bool] = Undefined, maxbins: Optional[float] = Undefined, step: Optional[float] = Undefined, unit: Optional[SchemaBase | MultiTimeUnit_T | SingleTimeUnit_T] = Undefined, utc: Optional[bool] = Undefined, - **kwds, ) -> YOffset: ... - - @overload - def title(self, _: str, **kwds) -> YOffset: ... - - @overload - def title(self, _: list[str], **kwds) -> YOffset: ... - @overload - def title(self, _: None, **kwds) -> YOffset: ... - + def title(self, _: str | Sequence[str] | None, /) -> YOffset: ... @overload - def type(self, _: StandardType_T, **kwds) -> YOffset: ... + def type(self, _: StandardType_T, /) -> YOffset: ... def __init__( self, shorthand: Optional[str | SchemaBase | Sequence[str] | Map] = Undefined, aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Map] = Undefined, + bin: Optional[bool | SchemaBase | Map | None] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, sort: Optional[ - None - | SchemaBase + SchemaBase | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map | AllSortString_T + | None ] = Undefined, timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, **kwds, ): @@ -24710,9 +21197,9 @@ class YOffsetDatum(DatumChannelMixin, core.ScaleDatumDef): Relative position on a band of a stacked, binned, time unit, or band scale. For example, the marks will be positioned at the beginning of the band if set to ``0``, and at the middle of the band if set to ``0.5``. - datum : str, bool, dict, None, float, :class:`ExprRef`, :class:`DateTime`, :class:`RepeatRef`, :class:`PrimitiveValue` + datum : str, bool, dict, float, :class:`ExprRef`, :class:`DateTime`, :class:`RepeatRef`, :class:`PrimitiveValue`, None A constant value in data domain. - scale : dict, None, :class:`Scale` + scale : dict, :class:`Scale`, None An object defining properties of the channel's scale, which is the function that transforms values in the data domain (numbers, dates, strings, etc) to visual values (pixels, colors, sizes) of the encoding channels. @@ -24725,7 +21212,7 @@ class YOffsetDatum(DatumChannelMixin, core.ScaleDatumDef): **See also:** `scale `__ documentation. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -24817,11 +21304,13 @@ class YOffsetDatum(DatumChannelMixin, core.ScaleDatumDef): _encoding_name = "yOffset" @overload - def bandPosition(self, _: float, **kwds) -> YOffsetDatum: ... - + def bandPosition(self, _: float, /) -> YOffsetDatum: ... + @overload + def scale(self, _: Scale | None, /) -> YOffsetDatum: ... @overload def scale( self, + *, align: Optional[float | Parameter | SchemaBase | Map] = Undefined, base: Optional[float | Parameter | SchemaBase | Map] = Undefined, bins: Optional[SchemaBase | Sequence[float] | Map] = Undefined, @@ -24831,12 +21320,18 @@ def scale( Parameter | SchemaBase | Literal["unaggregated"] - | Sequence[str | bool | None | float | Parameter | SchemaBase | Map] + | Sequence[ + str | bool | float | Temporal | Parameter | SchemaBase | Map | None + ] | Map ] = Undefined, - domainMax: Optional[float | Parameter | SchemaBase | Map] = Undefined, + domainMax: Optional[ + float | Temporal | Parameter | SchemaBase | Map + ] = Undefined, domainMid: Optional[float | Parameter | SchemaBase | Map] = Undefined, - domainMin: Optional[float | Parameter | SchemaBase | Map] = Undefined, + domainMin: Optional[ + float | Temporal | Parameter | SchemaBase | Map + ] = Undefined, domainRaw: Optional[Parameter | SchemaBase | Map] = Undefined, exponent: Optional[float | Parameter | SchemaBase | Map] = Undefined, interpolate: Optional[ @@ -24861,30 +21356,18 @@ def scale( scheme: Optional[Parameter | SchemaBase | Map | ColorScheme_T] = Undefined, type: Optional[SchemaBase | ScaleType_T] = Undefined, zero: Optional[bool | Parameter | SchemaBase | Map] = Undefined, - **kwds, ) -> YOffsetDatum: ... - - @overload - def scale(self, _: None, **kwds) -> YOffsetDatum: ... - - @overload - def title(self, _: str, **kwds) -> YOffsetDatum: ... - - @overload - def title(self, _: list[str], **kwds) -> YOffsetDatum: ... - @overload - def title(self, _: None, **kwds) -> YOffsetDatum: ... - + def title(self, _: str | Sequence[str] | None, /) -> YOffsetDatum: ... @overload - def type(self, _: Type_T, **kwds) -> YOffsetDatum: ... + def type(self, _: Type_T, /) -> YOffsetDatum: ... def __init__( self, datum, bandPosition: Optional[float] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | Type_T] = Undefined, **kwds, ): @@ -25256,10 +21739,48 @@ def encode( yOffset : str, :class:`YOffset`, Dict, :class:`YOffsetDatum`, :class:`YOffsetValue` Offset of y-position of the marks """ - # Compat prep for `infer_encoding_types` signature - kwargs = locals() - kwargs.pop("self") - args = kwargs.pop("args") + kwargs = { + "angle": angle, + "color": color, + "column": column, + "description": description, + "detail": detail, + "facet": facet, + "fill": fill, + "fillOpacity": fillOpacity, + "href": href, + "key": key, + "latitude": latitude, + "latitude2": latitude2, + "longitude": longitude, + "longitude2": longitude2, + "opacity": opacity, + "order": order, + "radius": radius, + "radius2": radius2, + "row": row, + "shape": shape, + "size": size, + "stroke": stroke, + "strokeDash": strokeDash, + "strokeOpacity": strokeOpacity, + "strokeWidth": strokeWidth, + "text": text, + "theta": theta, + "theta2": theta2, + "tooltip": tooltip, + "url": url, + "x": x, + "x2": x2, + "xError": xError, + "xError2": xError2, + "xOffset": xOffset, + "y": y, + "y2": y2, + "yError": yError, + "yError2": yError2, + "yOffset": yOffset, + } if args: kwargs = {k: v for k, v in kwargs.items() if v is not Undefined} diff --git a/altair/vegalite/v5/schema/core.py b/altair/vegalite/v5/schema/core.py index 623b27ee5..17ba53d10 100644 --- a/altair/vegalite/v5/schema/core.py +++ b/altair/vegalite/v5/schema/core.py @@ -5,7 +5,7 @@ import json import pkgutil -from typing import TYPE_CHECKING, Any, Iterator, Literal, Sequence +from typing import TYPE_CHECKING, Any, Literal from altair.utils.schemapi import ( # noqa: F401 SchemaBase, @@ -16,6 +16,8 @@ if TYPE_CHECKING: # ruff: noqa: F405 + from collections.abc import Iterator, Sequence + from altair import Parameter from altair.typing import Optional @@ -687,7 +689,7 @@ class AreaConfig(AnyMarkConfig): endAngle : dict, float, :class:`ExprRef` The end angle in radians for arc marks. A value of ``0`` indicates up (north), increasing values proceed clockwise. - fill : str, dict, None, :class:`Color`, :class:`ExprRef`, :class:`Gradient`, :class:`HexColor`, :class:`ColorName`, :class:`LinearGradient`, :class:`RadialGradient`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'] + fill : str, dict, :class:`Color`, :class:`ExprRef`, :class:`Gradient`, :class:`HexColor`, :class:`ColorName`, :class:`LinearGradient`, :class:`RadialGradient`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'], None Default fill color. This property has higher precedence than ``config.color``. Set to ``null`` to remove fill. @@ -748,7 +750,7 @@ class AreaConfig(AnyMarkConfig): * ``"bundle"``: equivalent to basis, except the tension parameter is used to straighten the spline. * ``"monotone"``: cubic interpolation that preserves monotonicity in y. - invalid : None, :class:`MarkInvalidDataMode`, Literal['filter', 'break-paths-filter-domains', 'break-paths-show-domains', 'break-paths-show-path-domains', 'show'] + invalid : :class:`MarkInvalidDataMode`, Literal['filter', 'break-paths-filter-domains', 'break-paths-show-domains', 'break-paths-show-path-domains', 'show'], None Invalid data mode, which defines how the marks and corresponding scales should represent invalid values (``null`` and ``NaN`` in continuous scales *without* defined output for invalid values). @@ -887,7 +889,7 @@ class AreaConfig(AnyMarkConfig): startAngle : dict, float, :class:`ExprRef` The start angle in radians for arc marks. A value of ``0`` indicates up (north), increasing values proceed clockwise. - stroke : str, dict, None, :class:`Color`, :class:`ExprRef`, :class:`Gradient`, :class:`HexColor`, :class:`ColorName`, :class:`LinearGradient`, :class:`RadialGradient`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'] + stroke : str, dict, :class:`Color`, :class:`ExprRef`, :class:`Gradient`, :class:`HexColor`, :class:`ColorName`, :class:`LinearGradient`, :class:`RadialGradient`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'], None Default stroke color. This property has higher precedence than ``config.color``. Set to ``null`` to remove stroke. @@ -939,7 +941,7 @@ class AreaConfig(AnyMarkConfig): Default relative band size for a time unit. If set to ``1``, the bandwidth of the marks will be equal to the time unit band step. If set to ``0.5``, bandwidth of the marks will be half of the time unit band step. - tooltip : str, bool, dict, None, float, :class:`ExprRef`, :class:`TooltipContent` + tooltip : str, bool, dict, float, :class:`ExprRef`, :class:`TooltipContent`, None The tooltip text string to show upon mouse hover or an object defining which fields should the tooltip be derived from. @@ -1013,7 +1015,7 @@ def __init__( ellipsis: Optional[str | Parameter | SchemaBase | Map] = Undefined, endAngle: Optional[float | Parameter | SchemaBase | Map] = Undefined, fill: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, fillOpacity: Optional[float | Parameter | SchemaBase | Map] = Undefined, filled: Optional[bool] = Undefined, @@ -1025,7 +1027,7 @@ def __init__( href: Optional[str | Parameter | SchemaBase | Map] = Undefined, innerRadius: Optional[float | Parameter | SchemaBase | Map] = Undefined, interpolate: Optional[Parameter | SchemaBase | Map | Interpolate_T] = Undefined, - invalid: Optional[None | SchemaBase | MarkInvalidDataMode_T] = Undefined, + invalid: Optional[SchemaBase | MarkInvalidDataMode_T | None] = Undefined, limit: Optional[float | Parameter | SchemaBase | Map] = Undefined, line: Optional[bool | SchemaBase | Map] = Undefined, lineBreak: Optional[str | Parameter | SchemaBase | Map] = Undefined, @@ -1043,7 +1045,7 @@ def __init__( smooth: Optional[bool | Parameter | SchemaBase | Map] = Undefined, startAngle: Optional[float | Parameter | SchemaBase | Map] = Undefined, stroke: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, strokeCap: Optional[Parameter | SchemaBase | Map | StrokeCap_T] = Undefined, strokeDash: Optional[ @@ -1062,7 +1064,7 @@ def __init__( timeUnitBandPosition: Optional[float] = Undefined, timeUnitBandSize: Optional[float] = Undefined, tooltip: Optional[ - str | bool | None | float | Parameter | SchemaBase | Map + str | bool | float | Parameter | SchemaBase | Map | None ] = Undefined, url: Optional[str | Parameter | SchemaBase | Map] = Undefined, width: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -1274,7 +1276,7 @@ class Axis(VegaLiteSchema): ``"square"``. **Default value:** ``"butt"`` - domainColor : str, dict, None, :class:`Color`, :class:`ExprRef`, :class:`HexColor`, :class:`ColorName`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'] + domainColor : str, dict, :class:`Color`, :class:`ExprRef`, :class:`HexColor`, :class:`ColorName`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'], None Color of axis domain line. **Default value:** ``"gray"``. @@ -1331,7 +1333,7 @@ class Axis(VegaLiteSchema): ``"square"``. **Default value:** ``"butt"`` - gridColor : str, dict, None, :class:`Color`, :class:`ExprRef`, :class:`HexColor`, :class:`ColorName`, :class:`ConditionalAxisColor`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'] + gridColor : str, dict, :class:`Color`, :class:`ExprRef`, :class:`HexColor`, :class:`ColorName`, :class:`ConditionalAxisColor`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'], None Color of gridlines. **Default value:** ``"lightGray"``. @@ -1368,7 +1370,7 @@ class Axis(VegaLiteSchema): bounding box may exceed the axis range. **Default value:** ``false``. - labelColor : str, dict, None, :class:`Color`, :class:`ExprRef`, :class:`HexColor`, :class:`ColorName`, :class:`ConditionalAxisColor`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'] + labelColor : str, dict, :class:`Color`, :class:`ExprRef`, :class:`HexColor`, :class:`ColorName`, :class:`ConditionalAxisColor`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'], None The color of the tick label, can be in hex color code or regular color name. labelExpr : str `Vega expression `__ for customizing @@ -1483,7 +1485,7 @@ class Axis(VegaLiteSchema): ``"square"``. **Default value:** ``"butt"`` - tickColor : str, dict, None, :class:`Color`, :class:`ExprRef`, :class:`HexColor`, :class:`ColorName`, :class:`ConditionalAxisColor`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'] + tickColor : str, dict, :class:`Color`, :class:`ExprRef`, :class:`HexColor`, :class:`ColorName`, :class:`ConditionalAxisColor`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'], None The color of the axis's tick. **Default value:** ``"gray"`` @@ -1536,7 +1538,7 @@ class Axis(VegaLiteSchema): Boolean value that determines whether the axis should include ticks. **Default value:** ``true`` - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -1568,7 +1570,7 @@ class Axis(VegaLiteSchema): ``"line-top"`` and ``"line-bottom"`` values operate similarly to ``"top"`` and ``"bottom"``, but are calculated relative to the *lineHeight* rather than *fontSize* alone. - titleColor : str, dict, None, :class:`Color`, :class:`ExprRef`, :class:`HexColor`, :class:`ColorName`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'] + titleColor : str, dict, :class:`Color`, :class:`ExprRef`, :class:`HexColor`, :class:`ColorName`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'], None Color of the title, can be in hex color code or regular color name. titleFont : str, dict, :class:`ExprRef` Font of the title. (e.g., ``"Helvetica Neue"``). @@ -1621,7 +1623,7 @@ def __init__( domain: Optional[bool] = Undefined, domainCap: Optional[Parameter | SchemaBase | Map | StrokeCap_T] = Undefined, domainColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, domainDash: Optional[ Parameter | SchemaBase | Sequence[float] | Map @@ -1634,7 +1636,7 @@ def __init__( grid: Optional[bool] = Undefined, gridCap: Optional[Parameter | SchemaBase | Map | StrokeCap_T] = Undefined, gridColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, gridDash: Optional[Parameter | SchemaBase | Sequence[float] | Map] = Undefined, gridDashOffset: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -1647,7 +1649,7 @@ def __init__( ] = Undefined, labelBound: Optional[bool | float | Parameter | SchemaBase | Map] = Undefined, labelColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, labelExpr: Optional[str] = Undefined, labelFlush: Optional[bool | float] = Undefined, @@ -1679,7 +1681,7 @@ def __init__( ] = Undefined, tickCap: Optional[Parameter | SchemaBase | Map | StrokeCap_T] = Undefined, tickColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, tickCount: Optional[ float | Parameter | SchemaBase | Map | TimeInterval_T @@ -1694,7 +1696,7 @@ def __init__( tickSize: Optional[float | Parameter | SchemaBase | Map] = Undefined, tickWidth: Optional[float | Parameter | SchemaBase | Map] = Undefined, ticks: Optional[bool] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, titleAlign: Optional[Parameter | SchemaBase | Map | Align_T] = Undefined, titleAnchor: Optional[Parameter | SchemaBase | Map | TitleAnchor_T] = Undefined, titleAngle: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -1702,7 +1704,7 @@ def __init__( Parameter | SchemaBase | Map | TextBaseline_T ] = Undefined, titleColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, titleFont: Optional[str | Parameter | SchemaBase | Map] = Undefined, titleFontSize: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -1723,7 +1725,7 @@ def __init__( | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map ] = Undefined, zindex: Optional[float] = Undefined, @@ -1850,7 +1852,7 @@ class AxisConfig(VegaLiteSchema): ``"square"``. **Default value:** ``"butt"`` - domainColor : str, dict, None, :class:`Color`, :class:`ExprRef`, :class:`HexColor`, :class:`ColorName`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'] + domainColor : str, dict, :class:`Color`, :class:`ExprRef`, :class:`HexColor`, :class:`ColorName`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'], None Color of axis domain line. **Default value:** ``"gray"``. @@ -1907,7 +1909,7 @@ class AxisConfig(VegaLiteSchema): ``"square"``. **Default value:** ``"butt"`` - gridColor : str, dict, None, :class:`Color`, :class:`ExprRef`, :class:`HexColor`, :class:`ColorName`, :class:`ConditionalAxisColor`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'] + gridColor : str, dict, :class:`Color`, :class:`ExprRef`, :class:`HexColor`, :class:`ColorName`, :class:`ConditionalAxisColor`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'], None Color of gridlines. **Default value:** ``"lightGray"``. @@ -1944,7 +1946,7 @@ class AxisConfig(VegaLiteSchema): bounding box may exceed the axis range. **Default value:** ``false``. - labelColor : str, dict, None, :class:`Color`, :class:`ExprRef`, :class:`HexColor`, :class:`ColorName`, :class:`ConditionalAxisColor`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'] + labelColor : str, dict, :class:`Color`, :class:`ExprRef`, :class:`HexColor`, :class:`ColorName`, :class:`ConditionalAxisColor`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'], None The color of the tick label, can be in hex color code or regular color name. labelExpr : str `Vega expression `__ for customizing @@ -2059,7 +2061,7 @@ class AxisConfig(VegaLiteSchema): ``"square"``. **Default value:** ``"butt"`` - tickColor : str, dict, None, :class:`Color`, :class:`ExprRef`, :class:`HexColor`, :class:`ColorName`, :class:`ConditionalAxisColor`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'] + tickColor : str, dict, :class:`Color`, :class:`ExprRef`, :class:`HexColor`, :class:`ColorName`, :class:`ConditionalAxisColor`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'], None The color of the axis's tick. **Default value:** ``"gray"`` @@ -2112,7 +2114,7 @@ class AxisConfig(VegaLiteSchema): Boolean value that determines whether the axis should include ticks. **Default value:** ``true`` - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -2144,7 +2146,7 @@ class AxisConfig(VegaLiteSchema): ``"line-top"`` and ``"line-bottom"`` values operate similarly to ``"top"`` and ``"bottom"``, but are calculated relative to the *lineHeight* rather than *fontSize* alone. - titleColor : str, dict, None, :class:`Color`, :class:`ExprRef`, :class:`HexColor`, :class:`ColorName`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'] + titleColor : str, dict, :class:`Color`, :class:`ExprRef`, :class:`HexColor`, :class:`ColorName`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'], None Color of the title, can be in hex color code or regular color name. titleFont : str, dict, :class:`ExprRef` Font of the title. (e.g., ``"Helvetica Neue"``). @@ -2198,7 +2200,7 @@ def __init__( domain: Optional[bool] = Undefined, domainCap: Optional[Parameter | SchemaBase | Map | StrokeCap_T] = Undefined, domainColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, domainDash: Optional[ Parameter | SchemaBase | Sequence[float] | Map @@ -2211,7 +2213,7 @@ def __init__( grid: Optional[bool] = Undefined, gridCap: Optional[Parameter | SchemaBase | Map | StrokeCap_T] = Undefined, gridColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, gridDash: Optional[Parameter | SchemaBase | Sequence[float] | Map] = Undefined, gridDashOffset: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -2224,7 +2226,7 @@ def __init__( ] = Undefined, labelBound: Optional[bool | float | Parameter | SchemaBase | Map] = Undefined, labelColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, labelExpr: Optional[str] = Undefined, labelFlush: Optional[bool | float] = Undefined, @@ -2256,7 +2258,7 @@ def __init__( ] = Undefined, tickCap: Optional[Parameter | SchemaBase | Map | StrokeCap_T] = Undefined, tickColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, tickCount: Optional[ float | Parameter | SchemaBase | Map | TimeInterval_T @@ -2271,7 +2273,7 @@ def __init__( tickSize: Optional[float | Parameter | SchemaBase | Map] = Undefined, tickWidth: Optional[float | Parameter | SchemaBase | Map] = Undefined, ticks: Optional[bool] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, titleAlign: Optional[Parameter | SchemaBase | Map | Align_T] = Undefined, titleAnchor: Optional[Parameter | SchemaBase | Map | TitleAnchor_T] = Undefined, titleAngle: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -2279,7 +2281,7 @@ def __init__( Parameter | SchemaBase | Map | TextBaseline_T ] = Undefined, titleColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, titleFont: Optional[str | Parameter | SchemaBase | Map] = Undefined, titleFontSize: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -2300,7 +2302,7 @@ def __init__( | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map ] = Undefined, zindex: Optional[float] = Undefined, @@ -2558,7 +2560,7 @@ class BarConfig(AnyMarkConfig): endAngle : dict, float, :class:`ExprRef` The end angle in radians for arc marks. A value of ``0`` indicates up (north), increasing values proceed clockwise. - fill : str, dict, None, :class:`Color`, :class:`ExprRef`, :class:`Gradient`, :class:`HexColor`, :class:`ColorName`, :class:`LinearGradient`, :class:`RadialGradient`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'] + fill : str, dict, :class:`Color`, :class:`ExprRef`, :class:`Gradient`, :class:`HexColor`, :class:`ColorName`, :class:`LinearGradient`, :class:`RadialGradient`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'], None Default fill color. This property has higher precedence than ``config.color``. Set to ``null`` to remove fill. @@ -2619,7 +2621,7 @@ class BarConfig(AnyMarkConfig): * ``"bundle"``: equivalent to basis, except the tension parameter is used to straighten the spline. * ``"monotone"``: cubic interpolation that preserves monotonicity in y. - invalid : None, :class:`MarkInvalidDataMode`, Literal['filter', 'break-paths-filter-domains', 'break-paths-show-domains', 'break-paths-show-path-domains', 'show'] + invalid : :class:`MarkInvalidDataMode`, Literal['filter', 'break-paths-filter-domains', 'break-paths-show-domains', 'break-paths-show-path-domains', 'show'], None Invalid data mode, which defines how the marks and corresponding scales should represent invalid values (``null`` and ``NaN`` in continuous scales *without* defined output for invalid values). @@ -2736,7 +2738,7 @@ class BarConfig(AnyMarkConfig): startAngle : dict, float, :class:`ExprRef` The start angle in radians for arc marks. A value of ``0`` indicates up (north), increasing values proceed clockwise. - stroke : str, dict, None, :class:`Color`, :class:`ExprRef`, :class:`Gradient`, :class:`HexColor`, :class:`ColorName`, :class:`LinearGradient`, :class:`RadialGradient`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'] + stroke : str, dict, :class:`Color`, :class:`ExprRef`, :class:`Gradient`, :class:`HexColor`, :class:`ColorName`, :class:`LinearGradient`, :class:`RadialGradient`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'], None Default stroke color. This property has higher precedence than ``config.color``. Set to ``null`` to remove stroke. @@ -2788,7 +2790,7 @@ class BarConfig(AnyMarkConfig): Default relative band size for a time unit. If set to ``1``, the bandwidth of the marks will be equal to the time unit band step. If set to ``0.5``, bandwidth of the marks will be half of the time unit band step. - tooltip : str, bool, dict, None, float, :class:`ExprRef`, :class:`TooltipContent` + tooltip : str, bool, dict, float, :class:`ExprRef`, :class:`TooltipContent`, None The tooltip text string to show upon mouse hover or an object defining which fields should the tooltip be derived from. @@ -2866,7 +2868,7 @@ def __init__( ellipsis: Optional[str | Parameter | SchemaBase | Map] = Undefined, endAngle: Optional[float | Parameter | SchemaBase | Map] = Undefined, fill: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, fillOpacity: Optional[float | Parameter | SchemaBase | Map] = Undefined, filled: Optional[bool] = Undefined, @@ -2878,7 +2880,7 @@ def __init__( href: Optional[str | Parameter | SchemaBase | Map] = Undefined, innerRadius: Optional[float | Parameter | SchemaBase | Map] = Undefined, interpolate: Optional[Parameter | SchemaBase | Map | Interpolate_T] = Undefined, - invalid: Optional[None | SchemaBase | MarkInvalidDataMode_T] = Undefined, + invalid: Optional[SchemaBase | MarkInvalidDataMode_T | None] = Undefined, limit: Optional[float | Parameter | SchemaBase | Map] = Undefined, lineBreak: Optional[str | Parameter | SchemaBase | Map] = Undefined, lineHeight: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -2895,7 +2897,7 @@ def __init__( smooth: Optional[bool | Parameter | SchemaBase | Map] = Undefined, startAngle: Optional[float | Parameter | SchemaBase | Map] = Undefined, stroke: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, strokeCap: Optional[Parameter | SchemaBase | Map | StrokeCap_T] = Undefined, strokeDash: Optional[ @@ -2914,7 +2916,7 @@ def __init__( timeUnitBandPosition: Optional[float] = Undefined, timeUnitBandSize: Optional[float] = Undefined, tooltip: Optional[ - str | bool | None | float | Parameter | SchemaBase | Map + str | bool | float | Parameter | SchemaBase | Map | None ] = Undefined, url: Optional[str | Parameter | SchemaBase | Map] = Undefined, width: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -3039,7 +3041,7 @@ class BaseTitleNoValueRefs(VegaLiteSchema): ``"line-bottom"``. The ``"line-top"`` and ``"line-bottom"`` values operate similarly to ``"top"`` and ``"bottom"``, but are calculated relative to the *lineHeight* rather than *fontSize* alone. - color : str, dict, None, :class:`Color`, :class:`ExprRef`, :class:`HexColor`, :class:`ColorName`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'] + color : str, dict, :class:`Color`, :class:`ExprRef`, :class:`HexColor`, :class:`ColorName`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'], None Text color for title text. dx : dict, float, :class:`ExprRef` Delta offset for title and subtitle text x-coordinate. @@ -3069,7 +3071,7 @@ class BaseTitleNoValueRefs(VegaLiteSchema): position along the edge of the chart. orient : dict, :class:`ExprRef`, :class:`TitleOrient`, Literal['none', 'left', 'right', 'top', 'bottom'] Default title orientation (``"top"``, ``"bottom"``, ``"left"``, or ``"right"``) - subtitleColor : str, dict, None, :class:`Color`, :class:`ExprRef`, :class:`HexColor`, :class:`ColorName`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'] + subtitleColor : str, dict, :class:`Color`, :class:`ExprRef`, :class:`HexColor`, :class:`ColorName`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'], None Text color for subtitle text. subtitleFont : str, dict, :class:`ExprRef` Font name for subtitle text. @@ -3102,7 +3104,7 @@ def __init__( aria: Optional[bool | Parameter | SchemaBase | Map] = Undefined, baseline: Optional[SchemaBase | TextBaseline_T] = Undefined, color: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, dx: Optional[float | Parameter | SchemaBase | Map] = Undefined, dy: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -3116,7 +3118,7 @@ def __init__( offset: Optional[float | Parameter | SchemaBase | Map] = Undefined, orient: Optional[Parameter | SchemaBase | Map | TitleOrient_T] = Undefined, subtitleColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, subtitleFont: Optional[str | Parameter | SchemaBase | Map] = Undefined, subtitleFontSize: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -3721,7 +3723,7 @@ class BoxPlotDef(CompositeMarkDef): range (*Q3-Q1*). **Default value:** ``1.5``. - invalid : None, :class:`MarkInvalidDataMode`, Literal['filter', 'break-paths-filter-domains', 'break-paths-show-domains', 'break-paths-show-path-domains', 'show'] + invalid : :class:`MarkInvalidDataMode`, Literal['filter', 'break-paths-filter-domains', 'break-paths-show-domains', 'break-paths-show-path-domains', 'show'], None Invalid data mode, which defines how the marks and corresponding scales should represent invalid values (``null`` and ``NaN`` in continuous scales *without* defined output for invalid values). @@ -3781,7 +3783,7 @@ def __init__( clip: Optional[bool] = Undefined, color: Optional[str | Parameter | SchemaBase | Map | ColorName_T] = Undefined, extent: Optional[float | Literal["min-max"]] = Undefined, - invalid: Optional[None | SchemaBase | MarkInvalidDataMode_T] = Undefined, + invalid: Optional[SchemaBase | MarkInvalidDataMode_T | None] = Undefined, median: Optional[bool | SchemaBase | Map] = Undefined, opacity: Optional[float] = Undefined, orient: Optional[SchemaBase | Orientation_T] = Undefined, @@ -4161,7 +4163,7 @@ class ConditionalParameterStringFieldDef(ConditionalStringFieldDef): Relative position on a band of a stacked, binned, time unit, or band scale. For example, the marks will be positioned at the beginning of the band if set to ``0``, and at the middle of the band if set to ``0.5``. - bin : bool, dict, None, Literal['binned'], :class:`BinParams` + bin : bool, dict, Literal['binned'], :class:`BinParams`, None A flag for binning a ``quantitative`` field, `an object defining binning parameters `__, or indicating that the data for ``x`` or ``y`` channel are binned before they are imported into @@ -4241,7 +4243,7 @@ class ConditionalParameterStringFieldDef(ConditionalStringFieldDef): **See also:** `timeUnit `__ documentation. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -4336,7 +4338,7 @@ def __init__( param: Optional[str | SchemaBase] = Undefined, aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Literal["binned"] | Map] = Undefined, + bin: Optional[bool | SchemaBase | Literal["binned"] | Map | None] = Undefined, empty: Optional[bool] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, format: Optional[str | SchemaBase | Map] = Undefined, @@ -4344,7 +4346,7 @@ def __init__( timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, **kwds, ): @@ -4384,7 +4386,7 @@ class ConditionalPredicateStringFieldDef(ConditionalStringFieldDef): Relative position on a band of a stacked, binned, time unit, or band scale. For example, the marks will be positioned at the beginning of the band if set to ``0``, and at the middle of the band if set to ``0.5``. - bin : bool, dict, None, Literal['binned'], :class:`BinParams` + bin : bool, dict, Literal['binned'], :class:`BinParams`, None A flag for binning a ``quantitative`` field, `an object defining binning parameters `__, or indicating that the data for ``x`` or ``y`` channel are binned before they are imported into @@ -4461,7 +4463,7 @@ class ConditionalPredicateStringFieldDef(ConditionalStringFieldDef): **See also:** `timeUnit `__ documentation. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -4556,14 +4558,14 @@ def __init__( test: Optional[str | SchemaBase | Map] = Undefined, aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Literal["binned"] | Map] = Undefined, + bin: Optional[bool | SchemaBase | Literal["binned"] | Map | None] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, format: Optional[str | SchemaBase | Map] = Undefined, formatType: Optional[str] = Undefined, timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, **kwds, ): @@ -4603,7 +4605,7 @@ class ConditionalParameterValueDefGradientstringnullExprRef( ---------- param : str, :class:`ParameterName` Filter using a parameter name. - value : str, dict, None, :class:`ExprRef`, :class:`Gradient`, :class:`LinearGradient`, :class:`RadialGradient` + value : str, dict, :class:`ExprRef`, :class:`Gradient`, :class:`LinearGradient`, :class:`RadialGradient`, None A constant value in visual domain (e.g., ``"red"`` / ``"#0099ff"`` / `gradient definition `__ for color, values between ``0`` to ``1`` for opacity). @@ -4619,7 +4621,7 @@ class ConditionalParameterValueDefGradientstringnullExprRef( def __init__( self, param: Optional[str | SchemaBase] = Undefined, - value: Optional[str | None | Parameter | SchemaBase | Map] = Undefined, + value: Optional[str | Parameter | SchemaBase | Map | None] = Undefined, empty: Optional[bool] = Undefined, **kwds, ): @@ -4636,7 +4638,7 @@ class ConditionalPredicateValueDefGradientstringnullExprRef( ---------- test : str, dict, :class:`Predicate`, :class:`FieldGTPredicate`, :class:`FieldLTPredicate`, :class:`FieldGTEPredicate`, :class:`FieldLTEPredicate`, :class:`LogicalOrPredicate`, :class:`ParameterPredicate`, :class:`FieldEqualPredicate`, :class:`FieldOneOfPredicate`, :class:`FieldRangePredicate`, :class:`FieldValidPredicate`, :class:`LogicalAndPredicate`, :class:`LogicalNotPredicate`, :class:`PredicateComposition` Predicate for triggering the condition - value : str, dict, None, :class:`ExprRef`, :class:`Gradient`, :class:`LinearGradient`, :class:`RadialGradient` + value : str, dict, :class:`ExprRef`, :class:`Gradient`, :class:`LinearGradient`, :class:`RadialGradient`, None A constant value in visual domain (e.g., ``"red"`` / ``"#0099ff"`` / `gradient definition `__ for color, values between ``0`` to ``1`` for opacity). @@ -4649,7 +4651,7 @@ class ConditionalPredicateValueDefGradientstringnullExprRef( def __init__( self, test: Optional[str | SchemaBase | Map] = Undefined, - value: Optional[str | None | Parameter | SchemaBase | Map] = Undefined, + value: Optional[str | Parameter | SchemaBase | Map | None] = Undefined, **kwds, ): super().__init__(test=test, value=value, **kwds) @@ -4997,7 +4999,7 @@ class ConditionalParameterValueDefstringnullExprRef( ---------- param : str, :class:`ParameterName` Filter using a parameter name. - value : str, dict, None, :class:`ExprRef` + value : str, dict, :class:`ExprRef`, None A constant value in visual domain (e.g., ``"red"`` / ``"#0099ff"`` / `gradient definition `__ for color, values between ``0`` to ``1`` for opacity). @@ -5013,7 +5015,7 @@ class ConditionalParameterValueDefstringnullExprRef( def __init__( self, param: Optional[str | SchemaBase] = Undefined, - value: Optional[str | None | Parameter | SchemaBase | Map] = Undefined, + value: Optional[str | Parameter | SchemaBase | Map | None] = Undefined, empty: Optional[bool] = Undefined, **kwds, ): @@ -5030,7 +5032,7 @@ class ConditionalPredicateValueDefstringnullExprRef( ---------- test : str, dict, :class:`Predicate`, :class:`FieldGTPredicate`, :class:`FieldLTPredicate`, :class:`FieldGTEPredicate`, :class:`FieldLTEPredicate`, :class:`LogicalOrPredicate`, :class:`ParameterPredicate`, :class:`FieldEqualPredicate`, :class:`FieldOneOfPredicate`, :class:`FieldRangePredicate`, :class:`FieldValidPredicate`, :class:`LogicalAndPredicate`, :class:`LogicalNotPredicate`, :class:`PredicateComposition` Predicate for triggering the condition - value : str, dict, None, :class:`ExprRef` + value : str, dict, :class:`ExprRef`, None A constant value in visual domain (e.g., ``"red"`` / ``"#0099ff"`` / `gradient definition `__ for color, values between ``0`` to ``1`` for opacity). @@ -5043,7 +5045,7 @@ class ConditionalPredicateValueDefstringnullExprRef( def __init__( self, test: Optional[str | SchemaBase | Map] = Undefined, - value: Optional[str | None | Parameter | SchemaBase | Map] = Undefined, + value: Optional[str | Parameter | SchemaBase | Map | None] = Undefined, **kwds, ): super().__init__(test=test, value=value, **kwds) @@ -5523,7 +5525,7 @@ class CsvDataFormat(DataFormat): Parameters ---------- - parse : dict, None, :class:`Parse` + parse : dict, :class:`Parse`, None If set to ``null``, disable type inference based on the spec and only use type inference based on the data. Alternatively, a parsing directive object can be provided for explicit data types. Each property of the object corresponds to a field @@ -5550,7 +5552,7 @@ class CsvDataFormat(DataFormat): def __init__( self, - parse: Optional[None | SchemaBase | Map] = Undefined, + parse: Optional[SchemaBase | Map | None] = Undefined, type: Optional[Literal["csv", "tsv"]] = Undefined, **kwds, ): @@ -5645,7 +5647,7 @@ class DomainUnionWith(VegaLiteSchema): def __init__( self, unionWith: Optional[ - Sequence[str | bool | float | SchemaBase | Map] + Sequence[str | bool | float | Temporal | SchemaBase | Map] ] = Undefined, **kwds, ): @@ -5662,7 +5664,7 @@ class DsvDataFormat(DataFormat): The delimiter between records. The delimiter must be a single character (i.e., a single 16-bit code unit); so, ASCII delimiters are fine, but emoji delimiters are not. - parse : dict, None, :class:`Parse` + parse : dict, :class:`Parse`, None If set to ``null``, disable type inference based on the spec and only use type inference based on the data. Alternatively, a parsing directive object can be provided for explicit data types. Each property of the object corresponds to a field @@ -5690,7 +5692,7 @@ class DsvDataFormat(DataFormat): def __init__( self, delimiter: Optional[str] = Undefined, - parse: Optional[None | SchemaBase | Map] = Undefined, + parse: Optional[SchemaBase | Map | None] = Undefined, type: Optional[Literal["dsv"]] = Undefined, **kwds, ): @@ -5851,7 +5853,7 @@ class Encoding(VegaLiteSchema): theta2 : dict, :class:`DatumDef`, :class:`Position2Def`, :class:`PositionValueDef`, :class:`SecondaryFieldDef` The end angle of arc marks in radians. A value of 0 indicates up or “north”, increasing values proceed clockwise. - tooltip : dict, None, :class:`StringFieldDefWithCondition`, :class:`StringValueDefWithCondition`, Sequence[dict, :class:`StringFieldDef`] + tooltip : dict, :class:`StringFieldDefWithCondition`, :class:`StringValueDefWithCondition`, Sequence[dict, :class:`StringFieldDef`], None The tooltip text to show upon mouse hover. Specifying ``tooltip`` encoding overrides `the tooltip property in the mark definition `__. @@ -5928,7 +5930,7 @@ def __init__( theta: Optional[SchemaBase | Map] = Undefined, theta2: Optional[SchemaBase | Map] = Undefined, tooltip: Optional[ - None | SchemaBase | Sequence[SchemaBase | Map] | Map + SchemaBase | Sequence[SchemaBase | Map] | Map | None ] = Undefined, url: Optional[SchemaBase | Map] = Undefined, x: Optional[SchemaBase | Map] = Undefined, @@ -6373,7 +6375,7 @@ class FacetEncodingFieldDef(VegaLiteSchema): Relative position on a band of a stacked, binned, time unit, or band scale. For example, the marks will be positioned at the beginning of the band if set to ``0``, and at the middle of the band if set to ``0.5``. - bin : bool, dict, None, :class:`BinParams` + bin : bool, dict, :class:`BinParams`, None A flag for binning a ``quantitative`` field, `an object defining binning parameters `__, or indicating that the data for ``x`` or ``y`` channel are binned before they are imported into @@ -6445,9 +6447,9 @@ class FacetEncodingFieldDef(VegaLiteSchema): about escaping in the `field documentation `__. 2) ``field`` is not required if ``aggregate`` is ``count``. - header : dict, None, :class:`Header` + header : dict, :class:`Header`, None An object defining properties of a facet's header. - sort : dict, None, Sequence[str], Sequence[bool], Sequence[float], :class:`SortArray`, :class:`SortOrder`, :class:`EncodingSortField`, Sequence[dict, :class:`DateTime`], Literal['ascending', 'descending'] + sort : dict, Sequence[str], Sequence[bool], Sequence[float], :class:`SortArray`, :class:`SortOrder`, :class:`EncodingSortField`, Sequence[dict, :class:`DateTime`], Literal['ascending', 'descending'], None Sort order for the encoded field. For continuous fields (quantitative or temporal), ``sort`` can be either @@ -6490,7 +6492,7 @@ class FacetEncodingFieldDef(VegaLiteSchema): **See also:** `timeUnit `__ documentation. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -6586,27 +6588,27 @@ def __init__( aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, align: Optional[SchemaBase | Map | LayoutAlign_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Map] = Undefined, + bin: Optional[bool | SchemaBase | Map | None] = Undefined, bounds: Optional[Literal["full", "flush"]] = Undefined, center: Optional[bool | SchemaBase | Map] = Undefined, columns: Optional[float] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, - header: Optional[None | SchemaBase | Map] = Undefined, + header: Optional[SchemaBase | Map | None] = Undefined, sort: Optional[ - None - | SchemaBase + SchemaBase | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map | SortOrder_T + | None ] = Undefined, spacing: Optional[float | SchemaBase | Map] = Undefined, timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, **kwds, ): @@ -6648,7 +6650,7 @@ class FacetFieldDef(VegaLiteSchema): Relative position on a band of a stacked, binned, time unit, or band scale. For example, the marks will be positioned at the beginning of the band if set to ``0``, and at the middle of the band if set to ``0.5``. - bin : bool, dict, None, :class:`BinParams` + bin : bool, dict, :class:`BinParams`, None A flag for binning a ``quantitative`` field, `an object defining binning parameters `__, or indicating that the data for ``x`` or ``y`` channel are binned before they are imported into @@ -6684,9 +6686,9 @@ class FacetFieldDef(VegaLiteSchema): about escaping in the `field documentation `__. 2) ``field`` is not required if ``aggregate`` is ``count``. - header : dict, None, :class:`Header` + header : dict, :class:`Header`, None An object defining properties of a facet's header. - sort : dict, None, Sequence[str], Sequence[bool], Sequence[float], :class:`SortArray`, :class:`SortOrder`, :class:`EncodingSortField`, Sequence[dict, :class:`DateTime`], Literal['ascending', 'descending'] + sort : dict, Sequence[str], Sequence[bool], Sequence[float], :class:`SortArray`, :class:`SortOrder`, :class:`EncodingSortField`, Sequence[dict, :class:`DateTime`], Literal['ascending', 'descending'], None Sort order for the encoded field. For continuous fields (quantitative or temporal), ``sort`` can be either @@ -6721,7 +6723,7 @@ class FacetFieldDef(VegaLiteSchema): **See also:** `timeUnit `__ documentation. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -6815,23 +6817,23 @@ def __init__( self, aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Map] = Undefined, + bin: Optional[bool | SchemaBase | Map | None] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, - header: Optional[None | SchemaBase | Map] = Undefined, + header: Optional[SchemaBase | Map | None] = Undefined, sort: Optional[ - None - | SchemaBase + SchemaBase | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map | SortOrder_T + | None ] = Undefined, timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, **kwds, ): @@ -7025,7 +7027,7 @@ class FacetedEncoding(VegaLiteSchema): theta2 : dict, :class:`DatumDef`, :class:`Position2Def`, :class:`PositionValueDef`, :class:`SecondaryFieldDef` The end angle of arc marks in radians. A value of 0 indicates up or “north”, increasing values proceed clockwise. - tooltip : dict, None, :class:`StringFieldDefWithCondition`, :class:`StringValueDefWithCondition`, Sequence[dict, :class:`StringFieldDef`] + tooltip : dict, :class:`StringFieldDefWithCondition`, :class:`StringValueDefWithCondition`, Sequence[dict, :class:`StringFieldDef`], None The tooltip text to show upon mouse hover. Specifying ``tooltip`` encoding overrides `the tooltip property in the mark definition `__. @@ -7105,7 +7107,7 @@ def __init__( theta: Optional[SchemaBase | Map] = Undefined, theta2: Optional[SchemaBase | Map] = Undefined, tooltip: Optional[ - None | SchemaBase | Sequence[SchemaBase | Map] | Map + SchemaBase | Sequence[SchemaBase | Map] | Map | None ] = Undefined, url: Optional[SchemaBase | Map] = Undefined, x: Optional[SchemaBase | Map] = Undefined, @@ -7176,7 +7178,7 @@ class Feature(VegaLiteSchema): ---------- geometry : dict, :class:`Point`, :class:`Polygon`, :class:`Geometry`, :class:`LineString`, :class:`MultiPoint`, :class:`MultiPolygon`, :class:`MultiLineString`, :class:`GeometryCollection` The feature's geometry - properties : dict, None, :class:`GeoJsonProperties` + properties : dict, :class:`GeoJsonProperties`, None Properties associated with this feature. type : Literal['Feature'] Specifies the type of GeoJSON object. @@ -7193,7 +7195,7 @@ class Feature(VegaLiteSchema): def __init__( self, geometry: Optional[SchemaBase | Map] = Undefined, - properties: Optional[None | SchemaBase | Map] = Undefined, + properties: Optional[SchemaBase | Map | None] = Undefined, type: Optional[Literal["Feature"]] = Undefined, bbox: Optional[SchemaBase | Sequence[float]] = Undefined, id: Optional[str | float] = Undefined, @@ -7249,7 +7251,7 @@ class FeatureGeometryGeoJsonProperties(VegaLiteSchema): ---------- geometry : dict, :class:`Point`, :class:`Polygon`, :class:`Geometry`, :class:`LineString`, :class:`MultiPoint`, :class:`MultiPolygon`, :class:`MultiLineString`, :class:`GeometryCollection` The feature's geometry - properties : dict, None, :class:`GeoJsonProperties` + properties : dict, :class:`GeoJsonProperties`, None Properties associated with this feature. type : Literal['Feature'] Specifies the type of GeoJSON object. @@ -7266,7 +7268,7 @@ class FeatureGeometryGeoJsonProperties(VegaLiteSchema): def __init__( self, geometry: Optional[SchemaBase | Map] = Undefined, - properties: Optional[None | SchemaBase | Map] = Undefined, + properties: Optional[SchemaBase | Map | None] = Undefined, type: Optional[Literal["Feature"]] = Undefined, bbox: Optional[SchemaBase | Sequence[float]] = Undefined, id: Optional[str | float] = Undefined, @@ -7313,7 +7315,7 @@ class FieldDefWithoutScale(VegaLiteSchema): Relative position on a band of a stacked, binned, time unit, or band scale. For example, the marks will be positioned at the beginning of the band if set to ``0``, and at the middle of the band if set to ``0.5``. - bin : bool, dict, None, Literal['binned'], :class:`BinParams` + bin : bool, dict, Literal['binned'], :class:`BinParams`, None A flag for binning a ``quantitative`` field, `an object defining binning parameters `__, or indicating that the data for ``x`` or ``y`` channel are binned before they are imported into @@ -7358,7 +7360,7 @@ class FieldDefWithoutScale(VegaLiteSchema): **See also:** `timeUnit `__ documentation. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -7453,12 +7455,12 @@ def __init__( shorthand: Optional[str | SchemaBase | Sequence[str] | Map] = Undefined, aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Literal["binned"] | Map] = Undefined, + bin: Optional[bool | SchemaBase | Literal["binned"] | Map | None] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, **kwds, ): @@ -7502,7 +7504,7 @@ class FieldOrDatumDefWithConditionStringFieldDefstring(VegaLiteSchema): Relative position on a band of a stacked, binned, time unit, or band scale. For example, the marks will be positioned at the beginning of the band if set to ``0``, and at the middle of the band if set to ``0.5``. - bin : bool, dict, None, Literal['binned'], :class:`BinParams` + bin : bool, dict, Literal['binned'], :class:`BinParams`, None A flag for binning a ``quantitative`` field, `an object defining binning parameters `__, or indicating that the data for ``x`` or ``y`` channel are binned before they are imported into @@ -7586,7 +7588,7 @@ class FieldOrDatumDefWithConditionStringFieldDefstring(VegaLiteSchema): **See also:** `timeUnit `__ documentation. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -7682,7 +7684,7 @@ def __init__( self, aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Literal["binned"] | Map] = Undefined, + bin: Optional[bool | SchemaBase | Literal["binned"] | Map | None] = Undefined, condition: Optional[SchemaBase | Sequence[SchemaBase | Map] | Map] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, format: Optional[str | SchemaBase | Map] = Undefined, @@ -7690,7 +7692,7 @@ def __init__( timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, **kwds, ): @@ -7858,7 +7860,7 @@ class GenericUnitSpecEncodingAnyMark(VegaLiteSchema): ``"tick"``, ``"line"``, ``"area"``, ``"point"``, ``"rule"``, ``"geoshape"``, and ``"text"``) or a `mark definition object `__. - data : dict, None, :class:`Data`, :class:`UrlData`, :class:`Generator`, :class:`NamedData`, :class:`DataSource`, :class:`InlineData`, :class:`SphereGenerator`, :class:`SequenceGenerator`, :class:`GraticuleGenerator` + data : dict, :class:`Data`, :class:`UrlData`, :class:`Generator`, :class:`NamedData`, :class:`DataSource`, :class:`InlineData`, :class:`SphereGenerator`, :class:`SequenceGenerator`, :class:`GraticuleGenerator`, None An object describing the data source. Set to ``null`` to ignore the parent's data source. If no data is set, it is derived from the parent. description : str @@ -7885,7 +7887,7 @@ class GenericUnitSpecEncodingAnyMark(VegaLiteSchema): def __init__( self, mark: Optional[SchemaBase | Map | Mark_T | CompositeMark_T] = Undefined, - data: Optional[None | SchemaBase | Map] = Undefined, + data: Optional[SchemaBase | Map | None] = Undefined, description: Optional[str] = Undefined, encoding: Optional[SchemaBase | Map] = Undefined, name: Optional[str] = Undefined, @@ -7920,7 +7922,7 @@ class GeoJsonFeature(Fit): ---------- geometry : dict, :class:`Point`, :class:`Polygon`, :class:`Geometry`, :class:`LineString`, :class:`MultiPoint`, :class:`MultiPolygon`, :class:`MultiLineString`, :class:`GeometryCollection` The feature's geometry - properties : dict, None, :class:`GeoJsonProperties` + properties : dict, :class:`GeoJsonProperties`, None Properties associated with this feature. type : Literal['Feature'] Specifies the type of GeoJSON object. @@ -7937,7 +7939,7 @@ class GeoJsonFeature(Fit): def __init__( self, geometry: Optional[SchemaBase | Map] = Undefined, - properties: Optional[None | SchemaBase | Map] = Undefined, + properties: Optional[SchemaBase | Map | None] = Undefined, type: Optional[Literal["Feature"]] = Undefined, bbox: Optional[SchemaBase | Sequence[float]] = Undefined, id: Optional[str | float] = Undefined, @@ -8241,7 +8243,7 @@ class Header(VegaLiteSchema): **Default value:** ``true``. orient : :class:`Orient`, Literal['left', 'right', 'top', 'bottom'] Shortcut for setting both labelOrient and titleOrient. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -8336,7 +8338,7 @@ def __init__( labelPadding: Optional[float | Parameter | SchemaBase | Map] = Undefined, labels: Optional[bool] = Undefined, orient: Optional[SchemaBase | Orient_T] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, titleAlign: Optional[Parameter | SchemaBase | Map | Align_T] = Undefined, titleAnchor: Optional[SchemaBase | TitleAnchor_T] = Undefined, titleAngle: Optional[float] = Undefined, @@ -8647,7 +8649,7 @@ class ImputeParams(VegaLiteSchema): Parameters ---------- - frame : Sequence[None, float] + frame : Sequence[float, None] A frame specification as a two-element array used to control the window over which the specified method is applied. The array entries should either be a number indicating the offset from the current data object, or null to indicate unbounded @@ -8681,7 +8683,7 @@ class ImputeParams(VegaLiteSchema): def __init__( self, - frame: Optional[Sequence[None | float]] = Undefined, + frame: Optional[Sequence[float | None]] = Undefined, keyvals: Optional[SchemaBase | Sequence[Any] | Map] = Undefined, method: Optional[SchemaBase | ImputeMethod_T] = Undefined, value: Optional[Any] = Undefined, @@ -9054,7 +9056,7 @@ class JsonDataFormat(DataFormat): Parameters ---------- - parse : dict, None, :class:`Parse` + parse : dict, :class:`Parse`, None If set to ``null``, disable type inference based on the spec and only use type inference based on the data. Alternatively, a parsing directive object can be provided for explicit data types. Each property of the object corresponds to a field @@ -9086,7 +9088,7 @@ class JsonDataFormat(DataFormat): def __init__( self, - parse: Optional[None | SchemaBase | Map] = Undefined, + parse: Optional[SchemaBase | Map | None] = Undefined, property: Optional[str] = Undefined, type: Optional[Literal["json"]] = Undefined, **kwds, @@ -9177,7 +9179,7 @@ class LatLongFieldDef(LatLongDef): **See also:** `timeUnit `__ documentation. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -9277,7 +9279,7 @@ def __init__( timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[Literal["quantitative"]] = Undefined, **kwds, ): @@ -9371,7 +9373,7 @@ class Legend(VegaLiteSchema): * For left-/right-``orient``ed legends, ``"vertical"`` * For top/bottom-left/right-``orient``ed legends, ``"horizontal"`` for gradient legends and ``"vertical"`` for symbol legends. - fillColor : str, dict, None, :class:`Color`, :class:`ExprRef`, :class:`HexColor`, :class:`ColorName`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'] + fillColor : str, dict, :class:`Color`, :class:`ExprRef`, :class:`HexColor`, :class:`ColorName`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'], None Background fill color for the full legend. format : str, dict, :class:`Dict` When used with the default ``"number"`` and ``"time"`` format type, the text @@ -9412,7 +9414,7 @@ class Legend(VegaLiteSchema): **Default value:** ``200``. gradientOpacity : dict, float, :class:`ExprRef` Opacity of the color gradient. - gradientStrokeColor : str, dict, None, :class:`Color`, :class:`ExprRef`, :class:`HexColor`, :class:`ColorName`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'] + gradientStrokeColor : str, dict, :class:`Color`, :class:`ExprRef`, :class:`HexColor`, :class:`ColorName`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'], None The color of the gradient stroke, can be in hex color code or regular color name. **Default value:** ``"lightGray"``. @@ -9438,7 +9440,7 @@ class Legend(VegaLiteSchema): ``"bottom"``, or ``"alphabetic"``. **Default value:** ``"middle"``. - labelColor : str, dict, None, :class:`Color`, :class:`ExprRef`, :class:`HexColor`, :class:`ColorName`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'] + labelColor : str, dict, :class:`Color`, :class:`ExprRef`, :class:`HexColor`, :class:`ColorName`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'], None The color of the legend label, can be in hex color code or regular color name. labelExpr : str `Vega expression `__ for customizing @@ -9503,13 +9505,13 @@ class Legend(VegaLiteSchema): The vertical padding in pixels between symbol legend entries. **Default value:** ``2``. - strokeColor : str, dict, None, :class:`Color`, :class:`ExprRef`, :class:`HexColor`, :class:`ColorName`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'] + strokeColor : str, dict, :class:`Color`, :class:`ExprRef`, :class:`HexColor`, :class:`ColorName`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'], None Border stroke color for the full legend. symbolDash : dict, Sequence[float], :class:`ExprRef` An array of alternating [stroke, space] lengths for dashed symbol strokes. symbolDashOffset : dict, float, :class:`ExprRef` The pixel offset at which to start drawing with the symbol stroke dash array. - symbolFillColor : str, dict, None, :class:`Color`, :class:`ExprRef`, :class:`HexColor`, :class:`ColorName`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'] + symbolFillColor : str, dict, :class:`Color`, :class:`ExprRef`, :class:`HexColor`, :class:`ColorName`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'], None The color of the legend symbol, symbolLimit : dict, float, :class:`ExprRef` The maximum number of allowed entries for a symbol legend. Additional entries will @@ -9524,7 +9526,7 @@ class Legend(VegaLiteSchema): The size of the legend symbol, in pixels. **Default value:** ``100``. - symbolStrokeColor : str, dict, None, :class:`Color`, :class:`ExprRef`, :class:`HexColor`, :class:`ColorName`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'] + symbolStrokeColor : str, dict, :class:`Color`, :class:`ExprRef`, :class:`HexColor`, :class:`ColorName`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'], None Stroke color for legend symbols. symbolStrokeWidth : dict, float, :class:`ExprRef` The width of the symbol's stroke. @@ -9550,7 +9552,7 @@ class Legend(VegaLiteSchema): necessary, to enforce the minimum step value. **Default value**: ``undefined`` - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -9584,7 +9586,7 @@ class Legend(VegaLiteSchema): alone. **Default value:** ``"top"``. - titleColor : str, dict, None, :class:`Color`, :class:`ExprRef`, :class:`HexColor`, :class:`ColorName`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'] + titleColor : str, dict, :class:`Color`, :class:`ExprRef`, :class:`HexColor`, :class:`ColorName`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'], None The color of the legend title, can be in hex color code or regular color name. titleFont : str, dict, :class:`ExprRef` The font of the legend title. @@ -9636,14 +9638,14 @@ def __init__( description: Optional[str | Parameter | SchemaBase | Map] = Undefined, direction: Optional[SchemaBase | Orientation_T] = Undefined, fillColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, format: Optional[str | SchemaBase | Map] = Undefined, formatType: Optional[str] = Undefined, gradientLength: Optional[float | Parameter | SchemaBase | Map] = Undefined, gradientOpacity: Optional[float | Parameter | SchemaBase | Map] = Undefined, gradientStrokeColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, gradientStrokeWidth: Optional[float | Parameter | SchemaBase | Map] = Undefined, gradientThickness: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -9653,7 +9655,7 @@ def __init__( Parameter | SchemaBase | Map | TextBaseline_T ] = Undefined, labelColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, labelExpr: Optional[str] = Undefined, labelFont: Optional[str | Parameter | SchemaBase | Map] = Undefined, @@ -9677,21 +9679,21 @@ def __init__( padding: Optional[float | Parameter | SchemaBase | Map] = Undefined, rowPadding: Optional[float | Parameter | SchemaBase | Map] = Undefined, strokeColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, symbolDash: Optional[ Parameter | SchemaBase | Sequence[float] | Map ] = Undefined, symbolDashOffset: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolFillColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, symbolLimit: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolOffset: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolOpacity: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolSize: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolStrokeColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, symbolStrokeWidth: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolType: Optional[str | Parameter | SchemaBase | Map] = Undefined, @@ -9699,14 +9701,14 @@ def __init__( float | Parameter | SchemaBase | Map | TimeInterval_T ] = Undefined, tickMinStep: Optional[float | Parameter | SchemaBase | Map] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, titleAlign: Optional[Parameter | SchemaBase | Map | Align_T] = Undefined, titleAnchor: Optional[Parameter | SchemaBase | Map | TitleAnchor_T] = Undefined, titleBaseline: Optional[ Parameter | SchemaBase | Map | TextBaseline_T ] = Undefined, titleColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, titleFont: Optional[str | Parameter | SchemaBase | Map] = Undefined, titleFontSize: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -9726,7 +9728,7 @@ def __init__( | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map ] = Undefined, zindex: Optional[float] = Undefined, @@ -9854,7 +9856,7 @@ class LegendConfig(VegaLiteSchema): legends and ``"vertical"`` for symbol legends. disable : bool Disable legend by default - fillColor : str, dict, None, :class:`Color`, :class:`ExprRef`, :class:`HexColor`, :class:`ColorName`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'] + fillColor : str, dict, :class:`Color`, :class:`ExprRef`, :class:`HexColor`, :class:`ColorName`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'], None Background fill color for the full legend. gradientDirection : dict, :class:`ExprRef`, :class:`Orientation`, Literal['horizontal', 'vertical'] The default direction (``"horizontal"`` or ``"vertical"``) for gradient legends. @@ -9883,7 +9885,7 @@ class LegendConfig(VegaLiteSchema): **Default value:** ``200``. gradientOpacity : dict, float, :class:`ExprRef` Opacity of the color gradient. - gradientStrokeColor : str, dict, None, :class:`Color`, :class:`ExprRef`, :class:`HexColor`, :class:`ColorName`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'] + gradientStrokeColor : str, dict, :class:`Color`, :class:`ExprRef`, :class:`HexColor`, :class:`ColorName`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'], None The color of the gradient stroke, can be in hex color code or regular color name. **Default value:** ``"lightGray"``. @@ -9919,7 +9921,7 @@ class LegendConfig(VegaLiteSchema): ``"bottom"``, or ``"alphabetic"``. **Default value:** ``"middle"``. - labelColor : str, dict, None, :class:`Color`, :class:`ExprRef`, :class:`HexColor`, :class:`ColorName`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'] + labelColor : str, dict, :class:`Color`, :class:`ExprRef`, :class:`HexColor`, :class:`ColorName`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'], None The color of the legend label, can be in hex color code or regular color name. labelFont : str, dict, :class:`ExprRef` The font of the legend label. @@ -9980,18 +9982,18 @@ class LegendConfig(VegaLiteSchema): The vertical padding in pixels between symbol legend entries. **Default value:** ``2``. - strokeColor : str, dict, None, :class:`Color`, :class:`ExprRef`, :class:`HexColor`, :class:`ColorName`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'] + strokeColor : str, dict, :class:`Color`, :class:`ExprRef`, :class:`HexColor`, :class:`ColorName`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'], None Border stroke color for the full legend. strokeDash : dict, Sequence[float], :class:`ExprRef` Border stroke dash pattern for the full legend. strokeWidth : dict, float, :class:`ExprRef` Border stroke width for the full legend. - symbolBaseFillColor : str, dict, None, :class:`Color`, :class:`ExprRef`, :class:`HexColor`, :class:`ColorName`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'] + symbolBaseFillColor : str, dict, :class:`Color`, :class:`ExprRef`, :class:`HexColor`, :class:`ColorName`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'], None Default fill color for legend symbols. Only applied if there is no ``"fill"`` scale color encoding for the legend. **Default value:** ``"transparent"``. - symbolBaseStrokeColor : str, dict, None, :class:`Color`, :class:`ExprRef`, :class:`HexColor`, :class:`ColorName`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'] + symbolBaseStrokeColor : str, dict, :class:`Color`, :class:`ExprRef`, :class:`HexColor`, :class:`ColorName`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'], None Default stroke color for legend symbols. Only applied if there is no ``"fill"`` scale color encoding for the legend. @@ -10004,7 +10006,7 @@ class LegendConfig(VegaLiteSchema): The default direction (``"horizontal"`` or ``"vertical"``) for symbol legends. **Default value:** ``"vertical"``. - symbolFillColor : str, dict, None, :class:`Color`, :class:`ExprRef`, :class:`HexColor`, :class:`ColorName`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'] + symbolFillColor : str, dict, :class:`Color`, :class:`ExprRef`, :class:`HexColor`, :class:`ColorName`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'], None The color of the legend symbol, symbolLimit : dict, float, :class:`ExprRef` The maximum number of allowed entries for a symbol legend. Additional entries will @@ -10019,7 +10021,7 @@ class LegendConfig(VegaLiteSchema): The size of the legend symbol, in pixels. **Default value:** ``100``. - symbolStrokeColor : str, dict, None, :class:`Color`, :class:`ExprRef`, :class:`HexColor`, :class:`ColorName`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'] + symbolStrokeColor : str, dict, :class:`Color`, :class:`ExprRef`, :class:`HexColor`, :class:`ColorName`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'], None Stroke color for legend symbols. symbolStrokeWidth : dict, float, :class:`ExprRef` The width of the symbol's stroke. @@ -10054,7 +10056,7 @@ class LegendConfig(VegaLiteSchema): alone. **Default value:** ``"top"``. - titleColor : str, dict, None, :class:`Color`, :class:`ExprRef`, :class:`HexColor`, :class:`ColorName`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'] + titleColor : str, dict, :class:`Color`, :class:`ExprRef`, :class:`HexColor`, :class:`ColorName`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'], None The color of the legend title, can be in hex color code or regular color name. titleFont : str, dict, :class:`ExprRef` The font of the legend title. @@ -10103,7 +10105,7 @@ def __init__( direction: Optional[SchemaBase | Orientation_T] = Undefined, disable: Optional[bool] = Undefined, fillColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, gradientDirection: Optional[ Parameter | SchemaBase | Map | Orientation_T @@ -10115,7 +10117,7 @@ def __init__( gradientLength: Optional[float | Parameter | SchemaBase | Map] = Undefined, gradientOpacity: Optional[float | Parameter | SchemaBase | Map] = Undefined, gradientStrokeColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, gradientStrokeWidth: Optional[float | Parameter | SchemaBase | Map] = Undefined, gradientThickness: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -10127,7 +10129,7 @@ def __init__( Parameter | SchemaBase | Map | TextBaseline_T ] = Undefined, labelColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, labelFont: Optional[str | Parameter | SchemaBase | Map] = Undefined, labelFontSize: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -10151,17 +10153,17 @@ def __init__( padding: Optional[float | Parameter | SchemaBase | Map] = Undefined, rowPadding: Optional[float | Parameter | SchemaBase | Map] = Undefined, strokeColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, strokeDash: Optional[ Parameter | SchemaBase | Sequence[float] | Map ] = Undefined, strokeWidth: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolBaseFillColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, symbolBaseStrokeColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, symbolDash: Optional[ Parameter | SchemaBase | Sequence[float] | Map @@ -10171,14 +10173,14 @@ def __init__( Parameter | SchemaBase | Map | Orientation_T ] = Undefined, symbolFillColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, symbolLimit: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolOffset: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolOpacity: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolSize: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolStrokeColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, symbolStrokeWidth: Optional[float | Parameter | SchemaBase | Map] = Undefined, symbolType: Optional[str | Parameter | SchemaBase | Map] = Undefined, @@ -10192,7 +10194,7 @@ def __init__( Parameter | SchemaBase | Map | TextBaseline_T ] = Undefined, titleColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, titleFont: Optional[str | Parameter | SchemaBase | Map] = Undefined, titleFontSize: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -10484,7 +10486,7 @@ class LineConfig(AnyMarkConfig): endAngle : dict, float, :class:`ExprRef` The end angle in radians for arc marks. A value of ``0`` indicates up (north), increasing values proceed clockwise. - fill : str, dict, None, :class:`Color`, :class:`ExprRef`, :class:`Gradient`, :class:`HexColor`, :class:`ColorName`, :class:`LinearGradient`, :class:`RadialGradient`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'] + fill : str, dict, :class:`Color`, :class:`ExprRef`, :class:`Gradient`, :class:`HexColor`, :class:`ColorName`, :class:`LinearGradient`, :class:`RadialGradient`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'], None Default fill color. This property has higher precedence than ``config.color``. Set to ``null`` to remove fill. @@ -10545,7 +10547,7 @@ class LineConfig(AnyMarkConfig): * ``"bundle"``: equivalent to basis, except the tension parameter is used to straighten the spline. * ``"monotone"``: cubic interpolation that preserves monotonicity in y. - invalid : None, :class:`MarkInvalidDataMode`, Literal['filter', 'break-paths-filter-domains', 'break-paths-show-domains', 'break-paths-show-path-domains', 'show'] + invalid : :class:`MarkInvalidDataMode`, Literal['filter', 'break-paths-filter-domains', 'break-paths-show-domains', 'break-paths-show-path-domains', 'show'], None Invalid data mode, which defines how the marks and corresponding scales should represent invalid values (``null`` and ``NaN`` in continuous scales *without* defined output for invalid values). @@ -10674,7 +10676,7 @@ class LineConfig(AnyMarkConfig): startAngle : dict, float, :class:`ExprRef` The start angle in radians for arc marks. A value of ``0`` indicates up (north), increasing values proceed clockwise. - stroke : str, dict, None, :class:`Color`, :class:`ExprRef`, :class:`Gradient`, :class:`HexColor`, :class:`ColorName`, :class:`LinearGradient`, :class:`RadialGradient`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'] + stroke : str, dict, :class:`Color`, :class:`ExprRef`, :class:`Gradient`, :class:`HexColor`, :class:`ColorName`, :class:`LinearGradient`, :class:`RadialGradient`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'], None Default stroke color. This property has higher precedence than ``config.color``. Set to ``null`` to remove stroke. @@ -10726,7 +10728,7 @@ class LineConfig(AnyMarkConfig): Default relative band size for a time unit. If set to ``1``, the bandwidth of the marks will be equal to the time unit band step. If set to ``0.5``, bandwidth of the marks will be half of the time unit band step. - tooltip : str, bool, dict, None, float, :class:`ExprRef`, :class:`TooltipContent` + tooltip : str, bool, dict, float, :class:`ExprRef`, :class:`TooltipContent`, None The tooltip text string to show upon mouse hover or an object defining which fields should the tooltip be derived from. @@ -10800,7 +10802,7 @@ def __init__( ellipsis: Optional[str | Parameter | SchemaBase | Map] = Undefined, endAngle: Optional[float | Parameter | SchemaBase | Map] = Undefined, fill: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, fillOpacity: Optional[float | Parameter | SchemaBase | Map] = Undefined, filled: Optional[bool] = Undefined, @@ -10812,7 +10814,7 @@ def __init__( href: Optional[str | Parameter | SchemaBase | Map] = Undefined, innerRadius: Optional[float | Parameter | SchemaBase | Map] = Undefined, interpolate: Optional[Parameter | SchemaBase | Map | Interpolate_T] = Undefined, - invalid: Optional[None | SchemaBase | MarkInvalidDataMode_T] = Undefined, + invalid: Optional[SchemaBase | MarkInvalidDataMode_T | None] = Undefined, limit: Optional[float | Parameter | SchemaBase | Map] = Undefined, lineBreak: Optional[str | Parameter | SchemaBase | Map] = Undefined, lineHeight: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -10829,7 +10831,7 @@ def __init__( smooth: Optional[bool | Parameter | SchemaBase | Map] = Undefined, startAngle: Optional[float | Parameter | SchemaBase | Map] = Undefined, stroke: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, strokeCap: Optional[Parameter | SchemaBase | Map | StrokeCap_T] = Undefined, strokeDash: Optional[ @@ -10848,7 +10850,7 @@ def __init__( timeUnitBandPosition: Optional[float] = Undefined, timeUnitBandSize: Optional[float] = Undefined, tooltip: Optional[ - str | bool | None | float | Parameter | SchemaBase | Map + str | bool | float | Parameter | SchemaBase | Map | None ] = Undefined, url: Optional[str | Parameter | SchemaBase | Map] = Undefined, width: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -11215,7 +11217,7 @@ class MarkConfig(AnyMarkConfig): endAngle : dict, float, :class:`ExprRef` The end angle in radians for arc marks. A value of ``0`` indicates up (north), increasing values proceed clockwise. - fill : str, dict, None, :class:`Color`, :class:`ExprRef`, :class:`Gradient`, :class:`HexColor`, :class:`ColorName`, :class:`LinearGradient`, :class:`RadialGradient`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'] + fill : str, dict, :class:`Color`, :class:`ExprRef`, :class:`Gradient`, :class:`HexColor`, :class:`ColorName`, :class:`LinearGradient`, :class:`RadialGradient`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'], None Default fill color. This property has higher precedence than ``config.color``. Set to ``null`` to remove fill. @@ -11276,7 +11278,7 @@ class MarkConfig(AnyMarkConfig): * ``"bundle"``: equivalent to basis, except the tension parameter is used to straighten the spline. * ``"monotone"``: cubic interpolation that preserves monotonicity in y. - invalid : None, :class:`MarkInvalidDataMode`, Literal['filter', 'break-paths-filter-domains', 'break-paths-show-domains', 'break-paths-show-path-domains', 'show'] + invalid : :class:`MarkInvalidDataMode`, Literal['filter', 'break-paths-filter-domains', 'break-paths-show-domains', 'break-paths-show-path-domains', 'show'], None Invalid data mode, which defines how the marks and corresponding scales should represent invalid values (``null`` and ``NaN`` in continuous scales *without* defined output for invalid values). @@ -11391,7 +11393,7 @@ class MarkConfig(AnyMarkConfig): startAngle : dict, float, :class:`ExprRef` The start angle in radians for arc marks. A value of ``0`` indicates up (north), increasing values proceed clockwise. - stroke : str, dict, None, :class:`Color`, :class:`ExprRef`, :class:`Gradient`, :class:`HexColor`, :class:`ColorName`, :class:`LinearGradient`, :class:`RadialGradient`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'] + stroke : str, dict, :class:`Color`, :class:`ExprRef`, :class:`Gradient`, :class:`HexColor`, :class:`ColorName`, :class:`LinearGradient`, :class:`RadialGradient`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'], None Default stroke color. This property has higher precedence than ``config.color``. Set to ``null`` to remove stroke. @@ -11443,7 +11445,7 @@ class MarkConfig(AnyMarkConfig): Default relative band size for a time unit. If set to ``1``, the bandwidth of the marks will be equal to the time unit band step. If set to ``0.5``, bandwidth of the marks will be half of the time unit band step. - tooltip : str, bool, dict, None, float, :class:`ExprRef`, :class:`TooltipContent` + tooltip : str, bool, dict, float, :class:`ExprRef`, :class:`TooltipContent`, None The tooltip text string to show upon mouse hover or an object defining which fields should the tooltip be derived from. @@ -11517,7 +11519,7 @@ def __init__( ellipsis: Optional[str | Parameter | SchemaBase | Map] = Undefined, endAngle: Optional[float | Parameter | SchemaBase | Map] = Undefined, fill: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, fillOpacity: Optional[float | Parameter | SchemaBase | Map] = Undefined, filled: Optional[bool] = Undefined, @@ -11529,7 +11531,7 @@ def __init__( href: Optional[str | Parameter | SchemaBase | Map] = Undefined, innerRadius: Optional[float | Parameter | SchemaBase | Map] = Undefined, interpolate: Optional[Parameter | SchemaBase | Map | Interpolate_T] = Undefined, - invalid: Optional[None | SchemaBase | MarkInvalidDataMode_T] = Undefined, + invalid: Optional[SchemaBase | MarkInvalidDataMode_T | None] = Undefined, limit: Optional[float | Parameter | SchemaBase | Map] = Undefined, lineBreak: Optional[str | Parameter | SchemaBase | Map] = Undefined, lineHeight: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -11545,7 +11547,7 @@ def __init__( smooth: Optional[bool | Parameter | SchemaBase | Map] = Undefined, startAngle: Optional[float | Parameter | SchemaBase | Map] = Undefined, stroke: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, strokeCap: Optional[Parameter | SchemaBase | Map | StrokeCap_T] = Undefined, strokeDash: Optional[ @@ -11564,7 +11566,7 @@ def __init__( timeUnitBandPosition: Optional[float] = Undefined, timeUnitBandSize: Optional[float] = Undefined, tooltip: Optional[ - str | bool | None | float | Parameter | SchemaBase | Map + str | bool | float | Parameter | SchemaBase | Map | None ] = Undefined, url: Optional[str | Parameter | SchemaBase | Map] = Undefined, width: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -11788,7 +11790,7 @@ class MarkDef(AnyMark): The ellipsis string for text truncated in response to the limit parameter. **Default value:** ``"…"`` - fill : str, dict, None, :class:`Color`, :class:`ExprRef`, :class:`Gradient`, :class:`HexColor`, :class:`ColorName`, :class:`LinearGradient`, :class:`RadialGradient`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'] + fill : str, dict, :class:`Color`, :class:`ExprRef`, :class:`Gradient`, :class:`HexColor`, :class:`ColorName`, :class:`LinearGradient`, :class:`RadialGradient`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'], None Default fill color. This property has higher precedence than ``config.color``. Set to ``null`` to remove fill. @@ -11854,7 +11856,7 @@ class MarkDef(AnyMark): * ``"bundle"``: equivalent to basis, except the tension parameter is used to straighten the spline. * ``"monotone"``: cubic interpolation that preserves monotonicity in y. - invalid : None, :class:`MarkInvalidDataMode`, Literal['filter', 'break-paths-filter-domains', 'break-paths-show-domains', 'break-paths-show-path-domains', 'show'] + invalid : :class:`MarkInvalidDataMode`, Literal['filter', 'break-paths-filter-domains', 'break-paths-show-domains', 'break-paths-show-path-domains', 'show'], None Invalid data mode, which defines how the marks and corresponding scales should represent invalid values (``null`` and ``NaN`` in continuous scales *without* defined output for invalid values). @@ -11996,7 +11998,7 @@ class MarkDef(AnyMark): resized. If false, individual pixels should be scaled directly rather than interpolated with smoothing. For SVG rendering, this option may not work in some browsers due to lack of standardization. - stroke : str, dict, None, :class:`Color`, :class:`ExprRef`, :class:`Gradient`, :class:`HexColor`, :class:`ColorName`, :class:`LinearGradient`, :class:`RadialGradient`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'] + stroke : str, dict, :class:`Color`, :class:`ExprRef`, :class:`Gradient`, :class:`HexColor`, :class:`ColorName`, :class:`LinearGradient`, :class:`RadialGradient`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'], None Default stroke color. This property has higher precedence than ``config.color``. Set to ``null`` to remove stroke. @@ -12070,7 +12072,7 @@ class MarkDef(AnyMark): Default relative band size for a time unit. If set to ``1``, the bandwidth of the marks will be equal to the time unit band step. If set to ``0.5``, bandwidth of the marks will be half of the time unit band step. - tooltip : str, bool, dict, None, float, :class:`ExprRef`, :class:`TooltipContent` + tooltip : str, bool, dict, float, :class:`ExprRef`, :class:`TooltipContent`, None The tooltip text string to show upon mouse hover or an object defining which fields should the tooltip be derived from. @@ -12163,7 +12165,7 @@ def __init__( dy: Optional[float | Parameter | SchemaBase | Map] = Undefined, ellipsis: Optional[str | Parameter | SchemaBase | Map] = Undefined, fill: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, fillOpacity: Optional[float | Parameter | SchemaBase | Map] = Undefined, filled: Optional[bool] = Undefined, @@ -12175,7 +12177,7 @@ def __init__( href: Optional[str | Parameter | SchemaBase | Map] = Undefined, innerRadius: Optional[float | Parameter | SchemaBase | Map] = Undefined, interpolate: Optional[Parameter | SchemaBase | Map | Interpolate_T] = Undefined, - invalid: Optional[None | SchemaBase | MarkInvalidDataMode_T] = Undefined, + invalid: Optional[SchemaBase | MarkInvalidDataMode_T | None] = Undefined, limit: Optional[float | Parameter | SchemaBase | Map] = Undefined, line: Optional[bool | SchemaBase | Map] = Undefined, lineBreak: Optional[str | Parameter | SchemaBase | Map] = Undefined, @@ -12195,7 +12197,7 @@ def __init__( size: Optional[float | Parameter | SchemaBase | Map] = Undefined, smooth: Optional[bool | Parameter | SchemaBase | Map] = Undefined, stroke: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, strokeCap: Optional[Parameter | SchemaBase | Map | StrokeCap_T] = Undefined, strokeDash: Optional[ @@ -12218,7 +12220,7 @@ def __init__( timeUnitBandPosition: Optional[float] = Undefined, timeUnitBandSize: Optional[float] = Undefined, tooltip: Optional[ - str | bool | None | float | Parameter | SchemaBase | Map + str | bool | float | Parameter | SchemaBase | Map | None ] = Undefined, url: Optional[str | Parameter | SchemaBase | Map] = Undefined, width: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -12369,9 +12371,9 @@ class FieldOrDatumDefWithConditionDatumDefGradientstringnull( **Note:** A field definition's ``condition`` property can only contain `conditional value definitions `__ since Vega-Lite only allows at most one encoded field per encoding channel. - datum : str, bool, dict, None, float, :class:`ExprRef`, :class:`DateTime`, :class:`RepeatRef`, :class:`PrimitiveValue` + datum : str, bool, dict, float, :class:`ExprRef`, :class:`DateTime`, :class:`RepeatRef`, :class:`PrimitiveValue`, None A constant value in data domain. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -12468,9 +12470,9 @@ def __init__( bandPosition: Optional[float] = Undefined, condition: Optional[SchemaBase | Sequence[SchemaBase | Map] | Map] = Undefined, datum: Optional[ - str | bool | None | float | Parameter | SchemaBase | Map + Temporal | Parameter | SchemaBase | Map | PrimitiveValue_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | Type_T] = Undefined, **kwds, ): @@ -12506,7 +12508,7 @@ class FieldOrDatumDefWithConditionMarkPropFieldDefGradientstringnull( Relative position on a band of a stacked, binned, time unit, or band scale. For example, the marks will be positioned at the beginning of the band if set to ``0``, and at the middle of the band if set to ``0.5``. - bin : bool, dict, None, :class:`BinParams` + bin : bool, dict, :class:`BinParams`, None A flag for binning a ``quantitative`` field, `an object defining binning parameters `__, or indicating that the data for ``x`` or ``y`` channel are binned before they are imported into @@ -12549,7 +12551,7 @@ class FieldOrDatumDefWithConditionMarkPropFieldDefGradientstringnull( about escaping in the `field documentation `__. 2) ``field`` is not required if ``aggregate`` is ``count``. - legend : dict, None, :class:`Legend` + legend : dict, :class:`Legend`, None An object defining properties of the legend. If ``null``, the legend for the encoding channel will be removed. @@ -12558,7 +12560,7 @@ class FieldOrDatumDefWithConditionMarkPropFieldDefGradientstringnull( **See also:** `legend `__ documentation. - scale : dict, None, :class:`Scale` + scale : dict, :class:`Scale`, None An object defining properties of the channel's scale, which is the function that transforms values in the data domain (numbers, dates, strings, etc) to visual values (pixels, colors, sizes) of the encoding channels. @@ -12571,7 +12573,7 @@ class FieldOrDatumDefWithConditionMarkPropFieldDefGradientstringnull( **See also:** `scale `__ documentation. - sort : dict, None, :class:`Sort`, Sequence[str], Sequence[bool], Sequence[float], :class:`SortArray`, :class:`SortOrder`, :class:`AllSortString`, :class:`SortByChannel`, :class:`SortByEncoding`, :class:`EncodingSortField`, :class:`SortByChannelDesc`, Sequence[dict, :class:`DateTime`], Literal['-x', '-y', '-color', '-fill', '-stroke', '-strokeWidth', '-size', '-shape', '-fillOpacity', '-strokeOpacity', '-opacity', '-text', 'ascending', 'descending', 'x', 'y', 'color', 'fill', 'stroke', 'strokeWidth', 'size', 'shape', 'fillOpacity', 'strokeOpacity', 'opacity', 'text'] + sort : dict, :class:`Sort`, Sequence[str], Sequence[bool], Sequence[float], :class:`SortArray`, :class:`SortOrder`, :class:`AllSortString`, :class:`SortByChannel`, :class:`SortByEncoding`, :class:`EncodingSortField`, :class:`SortByChannelDesc`, Sequence[dict, :class:`DateTime`], Literal['-x', '-y', '-color', '-fill', '-stroke', '-strokeWidth', '-size', '-shape', '-fillOpacity', '-strokeOpacity', '-opacity', '-text', 'ascending', 'descending', 'x', 'y', 'color', 'fill', 'stroke', 'strokeWidth', 'size', 'shape', 'fillOpacity', 'strokeOpacity', 'opacity', 'text'], None Sort order for the encoded field. For continuous fields (quantitative or temporal), ``sort`` can be either @@ -12618,7 +12620,7 @@ class FieldOrDatumDefWithConditionMarkPropFieldDefGradientstringnull( **See also:** `timeUnit `__ documentation. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -12715,25 +12717,25 @@ def __init__( shorthand: Optional[str | SchemaBase | Sequence[str] | Map] = Undefined, aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Map] = Undefined, + bin: Optional[bool | SchemaBase | Map | None] = Undefined, condition: Optional[SchemaBase | Sequence[SchemaBase | Map] | Map] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, sort: Optional[ - None - | SchemaBase + SchemaBase | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map | AllSortString_T + | None ] = Undefined, timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, **kwds, ): @@ -13021,9 +13023,9 @@ class FieldOrDatumDefWithConditionDatumDefnumberArray( **Note:** A field definition's ``condition`` property can only contain `conditional value definitions `__ since Vega-Lite only allows at most one encoded field per encoding channel. - datum : str, bool, dict, None, float, :class:`ExprRef`, :class:`DateTime`, :class:`RepeatRef`, :class:`PrimitiveValue` + datum : str, bool, dict, float, :class:`ExprRef`, :class:`DateTime`, :class:`RepeatRef`, :class:`PrimitiveValue`, None A constant value in data domain. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -13118,9 +13120,9 @@ def __init__( bandPosition: Optional[float] = Undefined, condition: Optional[SchemaBase | Sequence[SchemaBase | Map] | Map] = Undefined, datum: Optional[ - str | bool | None | float | Parameter | SchemaBase | Map + Temporal | Parameter | SchemaBase | Map | PrimitiveValue_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | Type_T] = Undefined, **kwds, ): @@ -13156,7 +13158,7 @@ class FieldOrDatumDefWithConditionMarkPropFieldDefnumberArray( Relative position on a band of a stacked, binned, time unit, or band scale. For example, the marks will be positioned at the beginning of the band if set to ``0``, and at the middle of the band if set to ``0.5``. - bin : bool, dict, None, :class:`BinParams` + bin : bool, dict, :class:`BinParams`, None A flag for binning a ``quantitative`` field, `an object defining binning parameters `__, or indicating that the data for ``x`` or ``y`` channel are binned before they are imported into @@ -13199,7 +13201,7 @@ class FieldOrDatumDefWithConditionMarkPropFieldDefnumberArray( about escaping in the `field documentation `__. 2) ``field`` is not required if ``aggregate`` is ``count``. - legend : dict, None, :class:`Legend` + legend : dict, :class:`Legend`, None An object defining properties of the legend. If ``null``, the legend for the encoding channel will be removed. @@ -13208,7 +13210,7 @@ class FieldOrDatumDefWithConditionMarkPropFieldDefnumberArray( **See also:** `legend `__ documentation. - scale : dict, None, :class:`Scale` + scale : dict, :class:`Scale`, None An object defining properties of the channel's scale, which is the function that transforms values in the data domain (numbers, dates, strings, etc) to visual values (pixels, colors, sizes) of the encoding channels. @@ -13221,7 +13223,7 @@ class FieldOrDatumDefWithConditionMarkPropFieldDefnumberArray( **See also:** `scale `__ documentation. - sort : dict, None, :class:`Sort`, Sequence[str], Sequence[bool], Sequence[float], :class:`SortArray`, :class:`SortOrder`, :class:`AllSortString`, :class:`SortByChannel`, :class:`SortByEncoding`, :class:`EncodingSortField`, :class:`SortByChannelDesc`, Sequence[dict, :class:`DateTime`], Literal['-x', '-y', '-color', '-fill', '-stroke', '-strokeWidth', '-size', '-shape', '-fillOpacity', '-strokeOpacity', '-opacity', '-text', 'ascending', 'descending', 'x', 'y', 'color', 'fill', 'stroke', 'strokeWidth', 'size', 'shape', 'fillOpacity', 'strokeOpacity', 'opacity', 'text'] + sort : dict, :class:`Sort`, Sequence[str], Sequence[bool], Sequence[float], :class:`SortArray`, :class:`SortOrder`, :class:`AllSortString`, :class:`SortByChannel`, :class:`SortByEncoding`, :class:`EncodingSortField`, :class:`SortByChannelDesc`, Sequence[dict, :class:`DateTime`], Literal['-x', '-y', '-color', '-fill', '-stroke', '-strokeWidth', '-size', '-shape', '-fillOpacity', '-strokeOpacity', '-opacity', '-text', 'ascending', 'descending', 'x', 'y', 'color', 'fill', 'stroke', 'strokeWidth', 'size', 'shape', 'fillOpacity', 'strokeOpacity', 'opacity', 'text'], None Sort order for the encoded field. For continuous fields (quantitative or temporal), ``sort`` can be either @@ -13268,7 +13270,7 @@ class FieldOrDatumDefWithConditionMarkPropFieldDefnumberArray( **See also:** `timeUnit `__ documentation. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -13365,25 +13367,25 @@ def __init__( shorthand: Optional[str | SchemaBase | Sequence[str] | Map] = Undefined, aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Map] = Undefined, + bin: Optional[bool | SchemaBase | Map | None] = Undefined, condition: Optional[SchemaBase | Sequence[SchemaBase | Map] | Map] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, sort: Optional[ - None - | SchemaBase + SchemaBase | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map | AllSortString_T + | None ] = Undefined, timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, **kwds, ): @@ -13430,9 +13432,9 @@ class FieldOrDatumDefWithConditionDatumDefnumber(MarkPropDefnumber, NumericMarkP **Note:** A field definition's ``condition`` property can only contain `conditional value definitions `__ since Vega-Lite only allows at most one encoded field per encoding channel. - datum : str, bool, dict, None, float, :class:`ExprRef`, :class:`DateTime`, :class:`RepeatRef`, :class:`PrimitiveValue` + datum : str, bool, dict, float, :class:`ExprRef`, :class:`DateTime`, :class:`RepeatRef`, :class:`PrimitiveValue`, None A constant value in data domain. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -13527,9 +13529,9 @@ def __init__( bandPosition: Optional[float] = Undefined, condition: Optional[SchemaBase | Sequence[SchemaBase | Map] | Map] = Undefined, datum: Optional[ - str | bool | None | float | Parameter | SchemaBase | Map + Temporal | Parameter | SchemaBase | Map | PrimitiveValue_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | Type_T] = Undefined, **kwds, ): @@ -13565,7 +13567,7 @@ class FieldOrDatumDefWithConditionMarkPropFieldDefnumber( Relative position on a band of a stacked, binned, time unit, or band scale. For example, the marks will be positioned at the beginning of the band if set to ``0``, and at the middle of the band if set to ``0.5``. - bin : bool, dict, None, :class:`BinParams` + bin : bool, dict, :class:`BinParams`, None A flag for binning a ``quantitative`` field, `an object defining binning parameters `__, or indicating that the data for ``x`` or ``y`` channel are binned before they are imported into @@ -13608,7 +13610,7 @@ class FieldOrDatumDefWithConditionMarkPropFieldDefnumber( about escaping in the `field documentation `__. 2) ``field`` is not required if ``aggregate`` is ``count``. - legend : dict, None, :class:`Legend` + legend : dict, :class:`Legend`, None An object defining properties of the legend. If ``null``, the legend for the encoding channel will be removed. @@ -13617,7 +13619,7 @@ class FieldOrDatumDefWithConditionMarkPropFieldDefnumber( **See also:** `legend `__ documentation. - scale : dict, None, :class:`Scale` + scale : dict, :class:`Scale`, None An object defining properties of the channel's scale, which is the function that transforms values in the data domain (numbers, dates, strings, etc) to visual values (pixels, colors, sizes) of the encoding channels. @@ -13630,7 +13632,7 @@ class FieldOrDatumDefWithConditionMarkPropFieldDefnumber( **See also:** `scale `__ documentation. - sort : dict, None, :class:`Sort`, Sequence[str], Sequence[bool], Sequence[float], :class:`SortArray`, :class:`SortOrder`, :class:`AllSortString`, :class:`SortByChannel`, :class:`SortByEncoding`, :class:`EncodingSortField`, :class:`SortByChannelDesc`, Sequence[dict, :class:`DateTime`], Literal['-x', '-y', '-color', '-fill', '-stroke', '-strokeWidth', '-size', '-shape', '-fillOpacity', '-strokeOpacity', '-opacity', '-text', 'ascending', 'descending', 'x', 'y', 'color', 'fill', 'stroke', 'strokeWidth', 'size', 'shape', 'fillOpacity', 'strokeOpacity', 'opacity', 'text'] + sort : dict, :class:`Sort`, Sequence[str], Sequence[bool], Sequence[float], :class:`SortArray`, :class:`SortOrder`, :class:`AllSortString`, :class:`SortByChannel`, :class:`SortByEncoding`, :class:`EncodingSortField`, :class:`SortByChannelDesc`, Sequence[dict, :class:`DateTime`], Literal['-x', '-y', '-color', '-fill', '-stroke', '-strokeWidth', '-size', '-shape', '-fillOpacity', '-strokeOpacity', '-opacity', '-text', 'ascending', 'descending', 'x', 'y', 'color', 'fill', 'stroke', 'strokeWidth', 'size', 'shape', 'fillOpacity', 'strokeOpacity', 'opacity', 'text'], None Sort order for the encoded field. For continuous fields (quantitative or temporal), ``sort`` can be either @@ -13677,7 +13679,7 @@ class FieldOrDatumDefWithConditionMarkPropFieldDefnumber( **See also:** `timeUnit `__ documentation. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -13774,25 +13776,25 @@ def __init__( shorthand: Optional[str | SchemaBase | Sequence[str] | Map] = Undefined, aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Map] = Undefined, + bin: Optional[bool | SchemaBase | Map | None] = Undefined, condition: Optional[SchemaBase | Sequence[SchemaBase | Map] | Map] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, sort: Optional[ - None - | SchemaBase + SchemaBase | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map | AllSortString_T + | None ] = Undefined, timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, **kwds, ): @@ -13842,7 +13844,7 @@ class OrderFieldDef(VegaLiteSchema): Relative position on a band of a stacked, binned, time unit, or band scale. For example, the marks will be positioned at the beginning of the band if set to ``0``, and at the middle of the band if set to ``0.5``. - bin : bool, dict, None, Literal['binned'], :class:`BinParams` + bin : bool, dict, Literal['binned'], :class:`BinParams`, None A flag for binning a ``quantitative`` field, `an object defining binning parameters `__, or indicating that the data for ``x`` or ``y`` channel are binned before they are imported into @@ -13889,7 +13891,7 @@ class OrderFieldDef(VegaLiteSchema): **See also:** `timeUnit `__ documentation. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -13984,13 +13986,13 @@ def __init__( shorthand: Optional[str | SchemaBase | Sequence[str] | Map] = Undefined, aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Literal["binned"] | Map] = Undefined, + bin: Optional[bool | SchemaBase | Literal["binned"] | Map | None] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, sort: Optional[SchemaBase | SortOrder_T] = Undefined, timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, **kwds, ): @@ -14181,7 +14183,7 @@ class OverlayMarkDef(VegaLiteSchema): endAngle : dict, float, :class:`ExprRef` The end angle in radians for arc marks. A value of ``0`` indicates up (north), increasing values proceed clockwise. - fill : str, dict, None, :class:`Color`, :class:`ExprRef`, :class:`Gradient`, :class:`HexColor`, :class:`ColorName`, :class:`LinearGradient`, :class:`RadialGradient`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'] + fill : str, dict, :class:`Color`, :class:`ExprRef`, :class:`Gradient`, :class:`HexColor`, :class:`ColorName`, :class:`LinearGradient`, :class:`RadialGradient`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'], None Default fill color. This property has higher precedence than ``config.color``. Set to ``null`` to remove fill. @@ -14242,7 +14244,7 @@ class OverlayMarkDef(VegaLiteSchema): * ``"bundle"``: equivalent to basis, except the tension parameter is used to straighten the spline. * ``"monotone"``: cubic interpolation that preserves monotonicity in y. - invalid : None, :class:`MarkInvalidDataMode`, Literal['filter', 'break-paths-filter-domains', 'break-paths-show-domains', 'break-paths-show-path-domains', 'show'] + invalid : :class:`MarkInvalidDataMode`, Literal['filter', 'break-paths-filter-domains', 'break-paths-show-domains', 'break-paths-show-path-domains', 'show'], None Invalid data mode, which defines how the marks and corresponding scales should represent invalid values (``null`` and ``NaN`` in continuous scales *without* defined output for invalid values). @@ -14361,7 +14363,7 @@ class OverlayMarkDef(VegaLiteSchema): startAngle : dict, float, :class:`ExprRef` The start angle in radians for arc marks. A value of ``0`` indicates up (north), increasing values proceed clockwise. - stroke : str, dict, None, :class:`Color`, :class:`ExprRef`, :class:`Gradient`, :class:`HexColor`, :class:`ColorName`, :class:`LinearGradient`, :class:`RadialGradient`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'] + stroke : str, dict, :class:`Color`, :class:`ExprRef`, :class:`Gradient`, :class:`HexColor`, :class:`ColorName`, :class:`LinearGradient`, :class:`RadialGradient`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'], None Default stroke color. This property has higher precedence than ``config.color``. Set to ``null`` to remove stroke. @@ -14431,7 +14433,7 @@ class OverlayMarkDef(VegaLiteSchema): Default relative band size for a time unit. If set to ``1``, the bandwidth of the marks will be equal to the time unit band step. If set to ``0.5``, bandwidth of the marks will be half of the time unit band step. - tooltip : str, bool, dict, None, float, :class:`ExprRef`, :class:`TooltipContent` + tooltip : str, bool, dict, float, :class:`ExprRef`, :class:`TooltipContent`, None The tooltip text string to show upon mouse hover or an object defining which fields should the tooltip be derived from. @@ -14514,7 +14516,7 @@ def __init__( ellipsis: Optional[str | Parameter | SchemaBase | Map] = Undefined, endAngle: Optional[float | Parameter | SchemaBase | Map] = Undefined, fill: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, fillOpacity: Optional[float | Parameter | SchemaBase | Map] = Undefined, filled: Optional[bool] = Undefined, @@ -14526,7 +14528,7 @@ def __init__( href: Optional[str | Parameter | SchemaBase | Map] = Undefined, innerRadius: Optional[float | Parameter | SchemaBase | Map] = Undefined, interpolate: Optional[Parameter | SchemaBase | Map | Interpolate_T] = Undefined, - invalid: Optional[None | SchemaBase | MarkInvalidDataMode_T] = Undefined, + invalid: Optional[SchemaBase | MarkInvalidDataMode_T | None] = Undefined, limit: Optional[float | Parameter | SchemaBase | Map] = Undefined, lineBreak: Optional[str | Parameter | SchemaBase | Map] = Undefined, lineHeight: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -14544,7 +14546,7 @@ def __init__( smooth: Optional[bool | Parameter | SchemaBase | Map] = Undefined, startAngle: Optional[float | Parameter | SchemaBase | Map] = Undefined, stroke: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, strokeCap: Optional[Parameter | SchemaBase | Map | StrokeCap_T] = Undefined, strokeDash: Optional[ @@ -14566,7 +14568,7 @@ def __init__( timeUnitBandPosition: Optional[float] = Undefined, timeUnitBandSize: Optional[float] = Undefined, tooltip: Optional[ - str | bool | None | float | Parameter | SchemaBase | Map + str | bool | float | Parameter | SchemaBase | Map | None ] = Undefined, url: Optional[str | Parameter | SchemaBase | Map] = Undefined, width: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -15066,9 +15068,9 @@ class DatumDef(LatLongDef, Position2Def): Relative position on a band of a stacked, binned, time unit, or band scale. For example, the marks will be positioned at the beginning of the band if set to ``0``, and at the middle of the band if set to ``0.5``. - datum : str, bool, dict, None, float, :class:`ExprRef`, :class:`DateTime`, :class:`RepeatRef`, :class:`PrimitiveValue` + datum : str, bool, dict, float, :class:`ExprRef`, :class:`DateTime`, :class:`RepeatRef`, :class:`PrimitiveValue`, None A constant value in data domain. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -15162,9 +15164,9 @@ def __init__( self, bandPosition: Optional[float] = Undefined, datum: Optional[ - str | bool | None | float | Parameter | SchemaBase | Map + Temporal | Parameter | SchemaBase | Map | PrimitiveValue_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | Type_T] = Undefined, **kwds, ): @@ -15183,9 +15185,9 @@ class PositionDatumDefBase(PolarDef): Relative position on a band of a stacked, binned, time unit, or band scale. For example, the marks will be positioned at the beginning of the band if set to ``0``, and at the middle of the band if set to ``0.5``. - datum : str, bool, dict, None, float, :class:`ExprRef`, :class:`DateTime`, :class:`RepeatRef`, :class:`PrimitiveValue` + datum : str, bool, dict, float, :class:`ExprRef`, :class:`DateTime`, :class:`RepeatRef`, :class:`PrimitiveValue`, None A constant value in data domain. - scale : dict, None, :class:`Scale` + scale : dict, :class:`Scale`, None An object defining properties of the channel's scale, which is the function that transforms values in the data domain (numbers, dates, strings, etc) to visual values (pixels, colors, sizes) of the encoding channels. @@ -15198,7 +15200,7 @@ class PositionDatumDefBase(PolarDef): **See also:** `scale `__ documentation. - stack : bool, None, :class:`StackOffset`, Literal['zero', 'center', 'normalize'] + stack : bool, :class:`StackOffset`, Literal['zero', 'center', 'normalize'], None Type of stacking offset if the field should be stacked. ``stack`` is only applicable for ``x``, ``y``, ``theta``, and ``radius`` channels with continuous domains. For example, ``stack`` of ``y`` can be used to customize stacking for a vertical bar @@ -15228,7 +15230,7 @@ class PositionDatumDefBase(PolarDef): **See also:** `stack `__ documentation. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -15322,11 +15324,11 @@ def __init__( self, bandPosition: Optional[float] = Undefined, datum: Optional[ - str | bool | None | float | Parameter | SchemaBase | Map + Temporal | Parameter | SchemaBase | Map | PrimitiveValue_T ] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, - stack: Optional[bool | None | SchemaBase | StackOffset_T] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, + stack: Optional[bool | SchemaBase | StackOffset_T | None] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | Type_T] = Undefined, **kwds, ): @@ -15356,7 +15358,7 @@ class PositionDatumDef(PositionDef): Parameters ---------- - axis : dict, None, :class:`Axis` + axis : dict, :class:`Axis`, None An object defining properties of axis's gridlines, ticks and labels. If ``null``, the axis for the encoding channel will be removed. @@ -15369,9 +15371,9 @@ class PositionDatumDef(PositionDef): Relative position on a band of a stacked, binned, time unit, or band scale. For example, the marks will be positioned at the beginning of the band if set to ``0``, and at the middle of the band if set to ``0.5``. - datum : str, bool, dict, None, float, :class:`ExprRef`, :class:`DateTime`, :class:`RepeatRef`, :class:`PrimitiveValue` + datum : str, bool, dict, float, :class:`ExprRef`, :class:`DateTime`, :class:`RepeatRef`, :class:`PrimitiveValue`, None A constant value in data domain. - impute : dict, None, :class:`ImputeParams` + impute : dict, :class:`ImputeParams`, None An object defining the properties of the Impute Operation to be applied. The field value of the other positional channel is taken as ``key`` of the ``Impute`` Operation. The field of the ``color`` channel if specified is used as ``groupby`` of @@ -15379,7 +15381,7 @@ class PositionDatumDef(PositionDef): **See also:** `impute `__ documentation. - scale : dict, None, :class:`Scale` + scale : dict, :class:`Scale`, None An object defining properties of the channel's scale, which is the function that transforms values in the data domain (numbers, dates, strings, etc) to visual values (pixels, colors, sizes) of the encoding channels. @@ -15392,7 +15394,7 @@ class PositionDatumDef(PositionDef): **See also:** `scale `__ documentation. - stack : bool, None, :class:`StackOffset`, Literal['zero', 'center', 'normalize'] + stack : bool, :class:`StackOffset`, Literal['zero', 'center', 'normalize'], None Type of stacking offset if the field should be stacked. ``stack`` is only applicable for ``x``, ``y``, ``theta``, and ``radius`` channels with continuous domains. For example, ``stack`` of ``y`` can be used to customize stacking for a vertical bar @@ -15422,7 +15424,7 @@ class PositionDatumDef(PositionDef): **See also:** `stack `__ documentation. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -15514,15 +15516,15 @@ class PositionDatumDef(PositionDef): def __init__( self, - axis: Optional[None | SchemaBase | Map] = Undefined, + axis: Optional[SchemaBase | Map | None] = Undefined, bandPosition: Optional[float] = Undefined, datum: Optional[ - str | bool | None | float | Parameter | SchemaBase | Map + Temporal | Parameter | SchemaBase | Map | PrimitiveValue_T ] = Undefined, - impute: Optional[None | SchemaBase | Map] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, - stack: Optional[bool | None | SchemaBase | StackOffset_T] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + impute: Optional[SchemaBase | Map | None] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, + stack: Optional[bool | SchemaBase | StackOffset_T | None] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | Type_T] = Undefined, **kwds, ): @@ -15555,7 +15557,7 @@ class PositionFieldDef(PositionDef): **See also:** `aggregate `__ documentation. - axis : dict, None, :class:`Axis` + axis : dict, :class:`Axis`, None An object defining properties of axis's gridlines, ticks and labels. If ``null``, the axis for the encoding channel will be removed. @@ -15568,7 +15570,7 @@ class PositionFieldDef(PositionDef): Relative position on a band of a stacked, binned, time unit, or band scale. For example, the marks will be positioned at the beginning of the band if set to ``0``, and at the middle of the band if set to ``0.5``. - bin : bool, dict, None, Literal['binned'], :class:`BinParams` + bin : bool, dict, Literal['binned'], :class:`BinParams`, None A flag for binning a ``quantitative`` field, `an object defining binning parameters `__, or indicating that the data for ``x`` or ``y`` channel are binned before they are imported into @@ -15604,7 +15606,7 @@ class PositionFieldDef(PositionDef): about escaping in the `field documentation `__. 2) ``field`` is not required if ``aggregate`` is ``count``. - impute : dict, None, :class:`ImputeParams` + impute : dict, :class:`ImputeParams`, None An object defining the properties of the Impute Operation to be applied. The field value of the other positional channel is taken as ``key`` of the ``Impute`` Operation. The field of the ``color`` channel if specified is used as ``groupby`` of @@ -15612,7 +15614,7 @@ class PositionFieldDef(PositionDef): **See also:** `impute `__ documentation. - scale : dict, None, :class:`Scale` + scale : dict, :class:`Scale`, None An object defining properties of the channel's scale, which is the function that transforms values in the data domain (numbers, dates, strings, etc) to visual values (pixels, colors, sizes) of the encoding channels. @@ -15625,7 +15627,7 @@ class PositionFieldDef(PositionDef): **See also:** `scale `__ documentation. - sort : dict, None, :class:`Sort`, Sequence[str], Sequence[bool], Sequence[float], :class:`SortArray`, :class:`SortOrder`, :class:`AllSortString`, :class:`SortByChannel`, :class:`SortByEncoding`, :class:`EncodingSortField`, :class:`SortByChannelDesc`, Sequence[dict, :class:`DateTime`], Literal['-x', '-y', '-color', '-fill', '-stroke', '-strokeWidth', '-size', '-shape', '-fillOpacity', '-strokeOpacity', '-opacity', '-text', 'ascending', 'descending', 'x', 'y', 'color', 'fill', 'stroke', 'strokeWidth', 'size', 'shape', 'fillOpacity', 'strokeOpacity', 'opacity', 'text'] + sort : dict, :class:`Sort`, Sequence[str], Sequence[bool], Sequence[float], :class:`SortArray`, :class:`SortOrder`, :class:`AllSortString`, :class:`SortByChannel`, :class:`SortByEncoding`, :class:`EncodingSortField`, :class:`SortByChannelDesc`, Sequence[dict, :class:`DateTime`], Literal['-x', '-y', '-color', '-fill', '-stroke', '-strokeWidth', '-size', '-shape', '-fillOpacity', '-strokeOpacity', '-opacity', '-text', 'ascending', 'descending', 'x', 'y', 'color', 'fill', 'stroke', 'strokeWidth', 'size', 'shape', 'fillOpacity', 'strokeOpacity', 'opacity', 'text'], None Sort order for the encoded field. For continuous fields (quantitative or temporal), ``sort`` can be either @@ -15663,7 +15665,7 @@ class PositionFieldDef(PositionDef): **See also:** `sort `__ documentation. - stack : bool, None, :class:`StackOffset`, Literal['zero', 'center', 'normalize'] + stack : bool, :class:`StackOffset`, Literal['zero', 'center', 'normalize'], None Type of stacking offset if the field should be stacked. ``stack`` is only applicable for ``x``, ``y``, ``theta``, and ``radius`` channels with continuous domains. For example, ``stack`` of ``y`` can be used to customize stacking for a vertical bar @@ -15702,7 +15704,7 @@ class PositionFieldDef(PositionDef): **See also:** `timeUnit `__ documentation. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -15796,27 +15798,27 @@ def __init__( self, shorthand: Optional[str | SchemaBase | Sequence[str] | Map] = Undefined, aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, - axis: Optional[None | SchemaBase | Map] = Undefined, + axis: Optional[SchemaBase | Map | None] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Literal["binned"] | Map] = Undefined, + bin: Optional[bool | SchemaBase | Literal["binned"] | Map | None] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, - impute: Optional[None | SchemaBase | Map] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, + impute: Optional[SchemaBase | Map | None] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, sort: Optional[ - None - | SchemaBase + SchemaBase | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map | AllSortString_T + | None ] = Undefined, - stack: Optional[bool | None | SchemaBase | StackOffset_T] = Undefined, + stack: Optional[bool | SchemaBase | StackOffset_T | None] = Undefined, timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, **kwds, ): @@ -15858,7 +15860,7 @@ class PositionFieldDefBase(PolarDef): Relative position on a band of a stacked, binned, time unit, or band scale. For example, the marks will be positioned at the beginning of the band if set to ``0``, and at the middle of the band if set to ``0.5``. - bin : bool, dict, None, Literal['binned'], :class:`BinParams` + bin : bool, dict, Literal['binned'], :class:`BinParams`, None A flag for binning a ``quantitative`` field, `an object defining binning parameters `__, or indicating that the data for ``x`` or ``y`` channel are binned before they are imported into @@ -15894,7 +15896,7 @@ class PositionFieldDefBase(PolarDef): about escaping in the `field documentation `__. 2) ``field`` is not required if ``aggregate`` is ``count``. - scale : dict, None, :class:`Scale` + scale : dict, :class:`Scale`, None An object defining properties of the channel's scale, which is the function that transforms values in the data domain (numbers, dates, strings, etc) to visual values (pixels, colors, sizes) of the encoding channels. @@ -15907,7 +15909,7 @@ class PositionFieldDefBase(PolarDef): **See also:** `scale `__ documentation. - sort : dict, None, :class:`Sort`, Sequence[str], Sequence[bool], Sequence[float], :class:`SortArray`, :class:`SortOrder`, :class:`AllSortString`, :class:`SortByChannel`, :class:`SortByEncoding`, :class:`EncodingSortField`, :class:`SortByChannelDesc`, Sequence[dict, :class:`DateTime`], Literal['-x', '-y', '-color', '-fill', '-stroke', '-strokeWidth', '-size', '-shape', '-fillOpacity', '-strokeOpacity', '-opacity', '-text', 'ascending', 'descending', 'x', 'y', 'color', 'fill', 'stroke', 'strokeWidth', 'size', 'shape', 'fillOpacity', 'strokeOpacity', 'opacity', 'text'] + sort : dict, :class:`Sort`, Sequence[str], Sequence[bool], Sequence[float], :class:`SortArray`, :class:`SortOrder`, :class:`AllSortString`, :class:`SortByChannel`, :class:`SortByEncoding`, :class:`EncodingSortField`, :class:`SortByChannelDesc`, Sequence[dict, :class:`DateTime`], Literal['-x', '-y', '-color', '-fill', '-stroke', '-strokeWidth', '-size', '-shape', '-fillOpacity', '-strokeOpacity', '-opacity', '-text', 'ascending', 'descending', 'x', 'y', 'color', 'fill', 'stroke', 'strokeWidth', 'size', 'shape', 'fillOpacity', 'strokeOpacity', 'opacity', 'text'], None Sort order for the encoded field. For continuous fields (quantitative or temporal), ``sort`` can be either @@ -15945,7 +15947,7 @@ class PositionFieldDefBase(PolarDef): **See also:** `sort `__ documentation. - stack : bool, None, :class:`StackOffset`, Literal['zero', 'center', 'normalize'] + stack : bool, :class:`StackOffset`, Literal['zero', 'center', 'normalize'], None Type of stacking offset if the field should be stacked. ``stack`` is only applicable for ``x``, ``y``, ``theta``, and ``radius`` channels with continuous domains. For example, ``stack`` of ``y`` can be used to customize stacking for a vertical bar @@ -15984,7 +15986,7 @@ class PositionFieldDefBase(PolarDef): **See also:** `timeUnit `__ documentation. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -16079,24 +16081,24 @@ def __init__( shorthand: Optional[str | SchemaBase | Sequence[str] | Map] = Undefined, aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Literal["binned"] | Map] = Undefined, + bin: Optional[bool | SchemaBase | Literal["binned"] | Map | None] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, sort: Optional[ - None - | SchemaBase + SchemaBase | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map | AllSortString_T + | None ] = Undefined, - stack: Optional[bool | None | SchemaBase | StackOffset_T] = Undefined, + stack: Optional[bool | SchemaBase | StackOffset_T | None] = Undefined, timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, **kwds, ): @@ -16227,7 +16229,9 @@ class FieldEqualPredicate(Predicate): def __init__( self, - equal: Optional[str | bool | float | Parameter | SchemaBase | Map] = Undefined, + equal: Optional[ + str | bool | float | Temporal | Parameter | SchemaBase | Map + ] = Undefined, field: Optional[str | SchemaBase] = Undefined, timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T @@ -16256,7 +16260,9 @@ class FieldGTEPredicate(Predicate): def __init__( self, field: Optional[str | SchemaBase] = Undefined, - gte: Optional[str | float | Parameter | SchemaBase | Map] = Undefined, + gte: Optional[ + str | float | Temporal | Parameter | SchemaBase | Map + ] = Undefined, timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, @@ -16284,7 +16290,7 @@ class FieldGTPredicate(Predicate): def __init__( self, field: Optional[str | SchemaBase] = Undefined, - gt: Optional[str | float | Parameter | SchemaBase | Map] = Undefined, + gt: Optional[str | float | Temporal | Parameter | SchemaBase | Map] = Undefined, timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, @@ -16312,7 +16318,9 @@ class FieldLTEPredicate(Predicate): def __init__( self, field: Optional[str | SchemaBase] = Undefined, - lte: Optional[str | float | Parameter | SchemaBase | Map] = Undefined, + lte: Optional[ + str | float | Temporal | Parameter | SchemaBase | Map + ] = Undefined, timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, @@ -16340,7 +16348,7 @@ class FieldLTPredicate(Predicate): def __init__( self, field: Optional[str | SchemaBase] = Undefined, - lt: Optional[str | float | Parameter | SchemaBase | Map] = Undefined, + lt: Optional[str | float | Temporal | Parameter | SchemaBase | Map] = Undefined, timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, @@ -16373,7 +16381,7 @@ def __init__( Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] ] = Undefined, timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T @@ -16391,7 +16399,7 @@ class FieldRangePredicate(Predicate): ---------- field : str, :class:`FieldName` Field to be tested. - range : dict, :class:`ExprRef`, Sequence[dict, None, float, :class:`ExprRef`, :class:`DateTime`] + range : dict, :class:`ExprRef`, Sequence[dict, float, :class:`ExprRef`, :class:`DateTime`, None] An array of inclusive minimum and maximum values for a field value of a data item to be included in the filtered data. timeUnit : dict, :class:`TimeUnit`, :class:`MultiTimeUnit`, :class:`BinnedTimeUnit`, :class:`SingleTimeUnit`, :class:`TimeUnitParams`, :class:`UtcMultiTimeUnit`, :class:`UtcSingleTimeUnit`, :class:`LocalMultiTimeUnit`, :class:`LocalSingleTimeUnit`, Literal['binnedutcyear', 'binnedutcyearquarter', 'binnedutcyearquartermonth', 'binnedutcyearmonth', 'binnedutcyearmonthdate', 'binnedutcyearmonthdatehours', 'binnedutcyearmonthdatehoursminutes', 'binnedutcyearmonthdatehoursminutesseconds', 'binnedutcyearweek', 'binnedutcyearweekday', 'binnedutcyearweekdayhours', 'binnedutcyearweekdayhoursminutes', 'binnedutcyearweekdayhoursminutesseconds', 'binnedutcyeardayofyear', 'binnedyear', 'binnedyearquarter', 'binnedyearquartermonth', 'binnedyearmonth', 'binnedyearmonthdate', 'binnedyearmonthdatehours', 'binnedyearmonthdatehoursminutes', 'binnedyearmonthdatehoursminutesseconds', 'binnedyearweek', 'binnedyearweekday', 'binnedyearweekdayhours', 'binnedyearweekdayhoursminutes', 'binnedyearweekdayhoursminutesseconds', 'binnedyeardayofyear', 'utcyear', 'utcquarter', 'utcmonth', 'utcweek', 'utcday', 'utcdayofyear', 'utcdate', 'utchours', 'utcminutes', 'utcseconds', 'utcmilliseconds', 'year', 'quarter', 'month', 'week', 'day', 'dayofyear', 'date', 'hours', 'minutes', 'seconds', 'milliseconds', 'utcyearquarter', 'utcyearquartermonth', 'utcyearmonth', 'utcyearmonthdate', 'utcyearmonthdatehours', 'utcyearmonthdatehoursminutes', 'utcyearmonthdatehoursminutesseconds', 'utcyearweek', 'utcyearweekday', 'utcyearweekdayhours', 'utcyearweekdayhoursminutes', 'utcyearweekdayhoursminutesseconds', 'utcyeardayofyear', 'utcquartermonth', 'utcmonthdate', 'utcmonthdatehours', 'utcmonthdatehoursminutes', 'utcmonthdatehoursminutesseconds', 'utcweekday', 'utcweekdayhours', 'utcweekdayhoursminutes', 'utcweekdayhoursminutesseconds', 'utcdayhours', 'utcdayhoursminutes', 'utcdayhoursminutesseconds', 'utchoursminutes', 'utchoursminutesseconds', 'utcminutesseconds', 'utcsecondsmilliseconds', 'yearquarter', 'yearquartermonth', 'yearmonth', 'yearmonthdate', 'yearmonthdatehours', 'yearmonthdatehoursminutes', 'yearmonthdatehoursminutesseconds', 'yearweek', 'yearweekday', 'yearweekdayhours', 'yearweekdayhoursminutes', 'yearweekdayhoursminutesseconds', 'yeardayofyear', 'quartermonth', 'monthdate', 'monthdatehours', 'monthdatehoursminutes', 'monthdatehoursminutesseconds', 'weekday', 'weekdayhours', 'weekdayhoursminutes', 'weekdayhoursminutesseconds', 'dayhours', 'dayhoursminutes', 'dayhoursminutesseconds', 'hoursminutes', 'hoursminutesseconds', 'minutesseconds', 'secondsmilliseconds'] @@ -16406,7 +16414,7 @@ def __init__( range: Optional[ Parameter | SchemaBase - | Sequence[None | float | Parameter | SchemaBase | Map] + | Sequence[float | Temporal | Parameter | SchemaBase | Map | None] | Map ] = Undefined, timeUnit: Optional[ @@ -16913,19 +16921,19 @@ class RangeConfig(VegaLiteSchema): Parameters ---------- - category : dict, :class:`RangeRaw`, :class:`RangeEnum`, :class:`RangeScheme`, Sequence[str, bool, None, float, Sequence[float], :class:`RangeRawArray`], Literal['width', 'height', 'symbol', 'category', 'ordinal', 'ramp', 'diverging', 'heatmap'], Sequence[str, :class:`Color`, :class:`HexColor`, :class:`ColorName`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple']] + category : dict, :class:`RangeRaw`, :class:`RangeEnum`, :class:`RangeScheme`, Sequence[str, bool, float, Sequence[float], :class:`RangeRawArray`, None], Literal['width', 'height', 'symbol', 'category', 'ordinal', 'ramp', 'diverging', 'heatmap'], Sequence[str, :class:`Color`, :class:`HexColor`, :class:`ColorName`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple']] Default `color scheme `__ for categorical data. - diverging : dict, :class:`RangeRaw`, :class:`RangeEnum`, :class:`RangeScheme`, Sequence[str, bool, None, float, Sequence[float], :class:`RangeRawArray`], Literal['width', 'height', 'symbol', 'category', 'ordinal', 'ramp', 'diverging', 'heatmap'], Sequence[str, :class:`Color`, :class:`HexColor`, :class:`ColorName`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple']] + diverging : dict, :class:`RangeRaw`, :class:`RangeEnum`, :class:`RangeScheme`, Sequence[str, bool, float, Sequence[float], :class:`RangeRawArray`, None], Literal['width', 'height', 'symbol', 'category', 'ordinal', 'ramp', 'diverging', 'heatmap'], Sequence[str, :class:`Color`, :class:`HexColor`, :class:`ColorName`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple']] Default `color scheme `__ for diverging quantitative ramps. - heatmap : dict, :class:`RangeRaw`, :class:`RangeEnum`, :class:`RangeScheme`, Sequence[str, bool, None, float, Sequence[float], :class:`RangeRawArray`], Literal['width', 'height', 'symbol', 'category', 'ordinal', 'ramp', 'diverging', 'heatmap'], Sequence[str, :class:`Color`, :class:`HexColor`, :class:`ColorName`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple']] + heatmap : dict, :class:`RangeRaw`, :class:`RangeEnum`, :class:`RangeScheme`, Sequence[str, bool, float, Sequence[float], :class:`RangeRawArray`, None], Literal['width', 'height', 'symbol', 'category', 'ordinal', 'ramp', 'diverging', 'heatmap'], Sequence[str, :class:`Color`, :class:`HexColor`, :class:`ColorName`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple']] Default `color scheme `__ for quantitative heatmaps. - ordinal : dict, :class:`RangeRaw`, :class:`RangeEnum`, :class:`RangeScheme`, Sequence[str, bool, None, float, Sequence[float], :class:`RangeRawArray`], Literal['width', 'height', 'symbol', 'category', 'ordinal', 'ramp', 'diverging', 'heatmap'], Sequence[str, :class:`Color`, :class:`HexColor`, :class:`ColorName`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple']] + ordinal : dict, :class:`RangeRaw`, :class:`RangeEnum`, :class:`RangeScheme`, Sequence[str, bool, float, Sequence[float], :class:`RangeRawArray`, None], Literal['width', 'height', 'symbol', 'category', 'ordinal', 'ramp', 'diverging', 'heatmap'], Sequence[str, :class:`Color`, :class:`HexColor`, :class:`ColorName`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple']] Default `color scheme `__ for rank-ordered data. - ramp : dict, :class:`RangeRaw`, :class:`RangeEnum`, :class:`RangeScheme`, Sequence[str, bool, None, float, Sequence[float], :class:`RangeRawArray`], Literal['width', 'height', 'symbol', 'category', 'ordinal', 'ramp', 'diverging', 'heatmap'], Sequence[str, :class:`Color`, :class:`HexColor`, :class:`ColorName`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple']] + ramp : dict, :class:`RangeRaw`, :class:`RangeEnum`, :class:`RangeScheme`, Sequence[str, bool, float, Sequence[float], :class:`RangeRawArray`, None], Literal['width', 'height', 'symbol', 'category', 'ordinal', 'ramp', 'diverging', 'heatmap'], Sequence[str, :class:`Color`, :class:`HexColor`, :class:`ColorName`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple']] Default `color scheme `__ for sequential quantitative ramps. symbol : Sequence[str, :class:`SymbolShape`] @@ -16940,35 +16948,35 @@ def __init__( category: Optional[ SchemaBase | Sequence[str | SchemaBase | ColorName_T] - | Sequence[str | bool | None | float | SchemaBase | Sequence[float]] + | Sequence[str | bool | float | SchemaBase | Sequence[float] | None] | Map | RangeEnum_T ] = Undefined, diverging: Optional[ SchemaBase | Sequence[str | SchemaBase | ColorName_T] - | Sequence[str | bool | None | float | SchemaBase | Sequence[float]] + | Sequence[str | bool | float | SchemaBase | Sequence[float] | None] | Map | RangeEnum_T ] = Undefined, heatmap: Optional[ SchemaBase | Sequence[str | SchemaBase | ColorName_T] - | Sequence[str | bool | None | float | SchemaBase | Sequence[float]] + | Sequence[str | bool | float | SchemaBase | Sequence[float] | None] | Map | RangeEnum_T ] = Undefined, ordinal: Optional[ SchemaBase | Sequence[str | SchemaBase | ColorName_T] - | Sequence[str | bool | None | float | SchemaBase | Sequence[float]] + | Sequence[str | bool | float | SchemaBase | Sequence[float] | None] | Map | RangeEnum_T ] = Undefined, ramp: Optional[ SchemaBase | Sequence[str | SchemaBase | ColorName_T] - | Sequence[str | bool | None | float | SchemaBase | Sequence[float]] + | Sequence[str | bool | float | SchemaBase | Sequence[float] | None] | Map | RangeEnum_T ] = Undefined, @@ -17141,7 +17149,7 @@ class RectConfig(AnyMarkConfig): endAngle : dict, float, :class:`ExprRef` The end angle in radians for arc marks. A value of ``0`` indicates up (north), increasing values proceed clockwise. - fill : str, dict, None, :class:`Color`, :class:`ExprRef`, :class:`Gradient`, :class:`HexColor`, :class:`ColorName`, :class:`LinearGradient`, :class:`RadialGradient`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'] + fill : str, dict, :class:`Color`, :class:`ExprRef`, :class:`Gradient`, :class:`HexColor`, :class:`ColorName`, :class:`LinearGradient`, :class:`RadialGradient`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'], None Default fill color. This property has higher precedence than ``config.color``. Set to ``null`` to remove fill. @@ -17202,7 +17210,7 @@ class RectConfig(AnyMarkConfig): * ``"bundle"``: equivalent to basis, except the tension parameter is used to straighten the spline. * ``"monotone"``: cubic interpolation that preserves monotonicity in y. - invalid : None, :class:`MarkInvalidDataMode`, Literal['filter', 'break-paths-filter-domains', 'break-paths-show-domains', 'break-paths-show-path-domains', 'show'] + invalid : :class:`MarkInvalidDataMode`, Literal['filter', 'break-paths-filter-domains', 'break-paths-show-domains', 'break-paths-show-path-domains', 'show'], None Invalid data mode, which defines how the marks and corresponding scales should represent invalid values (``null`` and ``NaN`` in continuous scales *without* defined output for invalid values). @@ -17319,7 +17327,7 @@ class RectConfig(AnyMarkConfig): startAngle : dict, float, :class:`ExprRef` The start angle in radians for arc marks. A value of ``0`` indicates up (north), increasing values proceed clockwise. - stroke : str, dict, None, :class:`Color`, :class:`ExprRef`, :class:`Gradient`, :class:`HexColor`, :class:`ColorName`, :class:`LinearGradient`, :class:`RadialGradient`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'] + stroke : str, dict, :class:`Color`, :class:`ExprRef`, :class:`Gradient`, :class:`HexColor`, :class:`ColorName`, :class:`LinearGradient`, :class:`RadialGradient`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'], None Default stroke color. This property has higher precedence than ``config.color``. Set to ``null`` to remove stroke. @@ -17371,7 +17379,7 @@ class RectConfig(AnyMarkConfig): Default relative band size for a time unit. If set to ``1``, the bandwidth of the marks will be equal to the time unit band step. If set to ``0.5``, bandwidth of the marks will be half of the time unit band step. - tooltip : str, bool, dict, None, float, :class:`ExprRef`, :class:`TooltipContent` + tooltip : str, bool, dict, float, :class:`ExprRef`, :class:`TooltipContent`, None The tooltip text string to show upon mouse hover or an object defining which fields should the tooltip be derived from. @@ -17448,7 +17456,7 @@ def __init__( ellipsis: Optional[str | Parameter | SchemaBase | Map] = Undefined, endAngle: Optional[float | Parameter | SchemaBase | Map] = Undefined, fill: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, fillOpacity: Optional[float | Parameter | SchemaBase | Map] = Undefined, filled: Optional[bool] = Undefined, @@ -17460,7 +17468,7 @@ def __init__( href: Optional[str | Parameter | SchemaBase | Map] = Undefined, innerRadius: Optional[float | Parameter | SchemaBase | Map] = Undefined, interpolate: Optional[Parameter | SchemaBase | Map | Interpolate_T] = Undefined, - invalid: Optional[None | SchemaBase | MarkInvalidDataMode_T] = Undefined, + invalid: Optional[SchemaBase | MarkInvalidDataMode_T | None] = Undefined, limit: Optional[float | Parameter | SchemaBase | Map] = Undefined, lineBreak: Optional[str | Parameter | SchemaBase | Map] = Undefined, lineHeight: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -17477,7 +17485,7 @@ def __init__( smooth: Optional[bool | Parameter | SchemaBase | Map] = Undefined, startAngle: Optional[float | Parameter | SchemaBase | Map] = Undefined, stroke: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, strokeCap: Optional[Parameter | SchemaBase | Map | StrokeCap_T] = Undefined, strokeDash: Optional[ @@ -17496,7 +17504,7 @@ def __init__( timeUnitBandPosition: Optional[float] = Undefined, timeUnitBandSize: Optional[float] = Undefined, tooltip: Optional[ - str | bool | None | float | Parameter | SchemaBase | Map + str | bool | float | Parameter | SchemaBase | Map | None ] = Undefined, url: Optional[str | Parameter | SchemaBase | Map] = Undefined, width: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -17795,7 +17803,7 @@ class RowColumnEncodingFieldDef(VegaLiteSchema): Relative position on a band of a stacked, binned, time unit, or band scale. For example, the marks will be positioned at the beginning of the band if set to ``0``, and at the middle of the band if set to ``0.5``. - bin : bool, dict, None, :class:`BinParams` + bin : bool, dict, :class:`BinParams`, None A flag for binning a ``quantitative`` field, `an object defining binning parameters `__, or indicating that the data for ``x`` or ``y`` channel are binned before they are imported into @@ -17836,9 +17844,9 @@ class RowColumnEncodingFieldDef(VegaLiteSchema): about escaping in the `field documentation `__. 2) ``field`` is not required if ``aggregate`` is ``count``. - header : dict, None, :class:`Header` + header : dict, :class:`Header`, None An object defining properties of a facet's header. - sort : dict, None, Sequence[str], Sequence[bool], Sequence[float], :class:`SortArray`, :class:`SortOrder`, :class:`EncodingSortField`, Sequence[dict, :class:`DateTime`], Literal['ascending', 'descending'] + sort : dict, Sequence[str], Sequence[bool], Sequence[float], :class:`SortArray`, :class:`SortOrder`, :class:`EncodingSortField`, Sequence[dict, :class:`DateTime`], Literal['ascending', 'descending'], None Sort order for the encoded field. For continuous fields (quantitative or temporal), ``sort`` can be either @@ -17879,7 +17887,7 @@ class RowColumnEncodingFieldDef(VegaLiteSchema): **See also:** `timeUnit `__ documentation. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -17975,25 +17983,25 @@ def __init__( aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, align: Optional[SchemaBase | LayoutAlign_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Map] = Undefined, + bin: Optional[bool | SchemaBase | Map | None] = Undefined, center: Optional[bool] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, - header: Optional[None | SchemaBase | Map] = Undefined, + header: Optional[SchemaBase | Map | None] = Undefined, sort: Optional[ - None - | SchemaBase + SchemaBase | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map | SortOrder_T + | None ] = Undefined, spacing: Optional[float] = Undefined, timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, **kwds, ): @@ -18057,7 +18065,7 @@ class Scale(VegaLiteSchema): ``symlog`` scales. **Default value:** ``1`` - domain : dict, :class:`ExprRef`, Literal['unaggregated'], :class:`DomainUnionWith`, :class:`ParameterExtent`, Sequence[str, bool, dict, None, float, :class:`ExprRef`, :class:`DateTime`] + domain : dict, :class:`ExprRef`, Literal['unaggregated'], :class:`DomainUnionWith`, :class:`ParameterExtent`, Sequence[str, bool, dict, float, :class:`ExprRef`, :class:`DateTime`, None] Customized domain values in the form of constant values or dynamic values driven by a parameter. @@ -18288,12 +18296,18 @@ def __init__( Parameter | SchemaBase | Literal["unaggregated"] - | Sequence[str | bool | None | float | Parameter | SchemaBase | Map] + | Sequence[ + str | bool | float | Temporal | Parameter | SchemaBase | Map | None + ] | Map ] = Undefined, - domainMax: Optional[float | Parameter | SchemaBase | Map] = Undefined, + domainMax: Optional[ + float | Temporal | Parameter | SchemaBase | Map + ] = Undefined, domainMid: Optional[float | Parameter | SchemaBase | Map] = Undefined, - domainMin: Optional[float | Parameter | SchemaBase | Map] = Undefined, + domainMin: Optional[ + float | Temporal | Parameter | SchemaBase | Map + ] = Undefined, domainRaw: Optional[Parameter | SchemaBase | Map] = Undefined, exponent: Optional[float | Parameter | SchemaBase | Map] = Undefined, interpolate: Optional[ @@ -18631,9 +18645,9 @@ class ScaleDatumDef(OffsetDef): Relative position on a band of a stacked, binned, time unit, or band scale. For example, the marks will be positioned at the beginning of the band if set to ``0``, and at the middle of the band if set to ``0.5``. - datum : str, bool, dict, None, float, :class:`ExprRef`, :class:`DateTime`, :class:`RepeatRef`, :class:`PrimitiveValue` + datum : str, bool, dict, float, :class:`ExprRef`, :class:`DateTime`, :class:`RepeatRef`, :class:`PrimitiveValue`, None A constant value in data domain. - scale : dict, None, :class:`Scale` + scale : dict, :class:`Scale`, None An object defining properties of the channel's scale, which is the function that transforms values in the data domain (numbers, dates, strings, etc) to visual values (pixels, colors, sizes) of the encoding channels. @@ -18646,7 +18660,7 @@ class ScaleDatumDef(OffsetDef): **See also:** `scale `__ documentation. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -18740,10 +18754,10 @@ def __init__( self, bandPosition: Optional[float] = Undefined, datum: Optional[ - str | bool | None | float | Parameter | SchemaBase | Map + Temporal | Parameter | SchemaBase | Map | PrimitiveValue_T ] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | Type_T] = Undefined, **kwds, ): @@ -18777,7 +18791,7 @@ class ScaleFieldDef(OffsetDef): Relative position on a band of a stacked, binned, time unit, or band scale. For example, the marks will be positioned at the beginning of the band if set to ``0``, and at the middle of the band if set to ``0.5``. - bin : bool, dict, None, :class:`BinParams` + bin : bool, dict, :class:`BinParams`, None A flag for binning a ``quantitative`` field, `an object defining binning parameters `__, or indicating that the data for ``x`` or ``y`` channel are binned before they are imported into @@ -18813,7 +18827,7 @@ class ScaleFieldDef(OffsetDef): about escaping in the `field documentation `__. 2) ``field`` is not required if ``aggregate`` is ``count``. - scale : dict, None, :class:`Scale` + scale : dict, :class:`Scale`, None An object defining properties of the channel's scale, which is the function that transforms values in the data domain (numbers, dates, strings, etc) to visual values (pixels, colors, sizes) of the encoding channels. @@ -18826,7 +18840,7 @@ class ScaleFieldDef(OffsetDef): **See also:** `scale `__ documentation. - sort : dict, None, :class:`Sort`, Sequence[str], Sequence[bool], Sequence[float], :class:`SortArray`, :class:`SortOrder`, :class:`AllSortString`, :class:`SortByChannel`, :class:`SortByEncoding`, :class:`EncodingSortField`, :class:`SortByChannelDesc`, Sequence[dict, :class:`DateTime`], Literal['-x', '-y', '-color', '-fill', '-stroke', '-strokeWidth', '-size', '-shape', '-fillOpacity', '-strokeOpacity', '-opacity', '-text', 'ascending', 'descending', 'x', 'y', 'color', 'fill', 'stroke', 'strokeWidth', 'size', 'shape', 'fillOpacity', 'strokeOpacity', 'opacity', 'text'] + sort : dict, :class:`Sort`, Sequence[str], Sequence[bool], Sequence[float], :class:`SortArray`, :class:`SortOrder`, :class:`AllSortString`, :class:`SortByChannel`, :class:`SortByEncoding`, :class:`EncodingSortField`, :class:`SortByChannelDesc`, Sequence[dict, :class:`DateTime`], Literal['-x', '-y', '-color', '-fill', '-stroke', '-strokeWidth', '-size', '-shape', '-fillOpacity', '-strokeOpacity', '-opacity', '-text', 'ascending', 'descending', 'x', 'y', 'color', 'fill', 'stroke', 'strokeWidth', 'size', 'shape', 'fillOpacity', 'strokeOpacity', 'opacity', 'text'], None Sort order for the encoded field. For continuous fields (quantitative or temporal), ``sort`` can be either @@ -18873,7 +18887,7 @@ class ScaleFieldDef(OffsetDef): **See also:** `timeUnit `__ documentation. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -18968,23 +18982,23 @@ def __init__( shorthand: Optional[str | SchemaBase | Sequence[str] | Map] = Undefined, aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Map] = Undefined, + bin: Optional[bool | SchemaBase | Map | None] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, sort: Optional[ - None - | SchemaBase + SchemaBase | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map | AllSortString_T + | None ] = Undefined, timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, **kwds, ): @@ -19199,7 +19213,7 @@ class ScaleInvalidDataShowAsValuefill(ScaleInvalidDataShowAsfill): Parameters ---------- - value : str, dict, None, :class:`Color`, :class:`Gradient`, :class:`HexColor`, :class:`ColorName`, :class:`LinearGradient`, :class:`RadialGradient`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'] + value : str, dict, :class:`Color`, :class:`Gradient`, :class:`HexColor`, :class:`ColorName`, :class:`LinearGradient`, :class:`RadialGradient`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'], None Default fill color. This property has higher precedence than ``config.color``. Set to ``null`` to remove fill. @@ -19210,7 +19224,7 @@ class ScaleInvalidDataShowAsValuefill(ScaleInvalidDataShowAsfill): def __init__( self, - value: Optional[str | None | SchemaBase | Map | ColorName_T] = Undefined, + value: Optional[str | SchemaBase | Map | ColorName_T | None] = Undefined, **kwds, ): super().__init__(value=value, **kwds) @@ -19391,7 +19405,7 @@ class ScaleInvalidDataShowAsValuestroke(ScaleInvalidDataShowAsstroke): Parameters ---------- - value : str, dict, None, :class:`Color`, :class:`Gradient`, :class:`HexColor`, :class:`ColorName`, :class:`LinearGradient`, :class:`RadialGradient`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'] + value : str, dict, :class:`Color`, :class:`Gradient`, :class:`HexColor`, :class:`ColorName`, :class:`LinearGradient`, :class:`RadialGradient`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'], None Default stroke color. This property has higher precedence than ``config.color``. Set to ``null`` to remove stroke. @@ -19402,7 +19416,7 @@ class ScaleInvalidDataShowAsValuestroke(ScaleInvalidDataShowAsstroke): def __init__( self, - value: Optional[str | None | SchemaBase | Map | ColorName_T] = Undefined, + value: Optional[str | SchemaBase | Map | ColorName_T | None] = Undefined, **kwds, ): super().__init__(value=value, **kwds) @@ -19819,7 +19833,7 @@ class SecondaryFieldDef(Position2Def): **See also:** `timeUnit `__ documentation. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -19853,7 +19867,7 @@ def __init__( timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, **kwds, ): super().__init__( @@ -20053,7 +20067,7 @@ class SelectionParameter(VegaLiteSchema): **See also:** `bind `__ documentation. - value : str, bool, dict, None, float, :class:`DateTime`, :class:`SelectionInit`, :class:`PrimitiveValue`, :class:`SelectionInitIntervalMapping`, Sequence[dict, :class:`SelectionInitMapping`] + value : str, bool, dict, float, :class:`DateTime`, :class:`SelectionInit`, :class:`PrimitiveValue`, :class:`SelectionInitIntervalMapping`, Sequence[dict, :class:`SelectionInitMapping`], None Initialize the selection with a mapping between `projected channels or field names `__ and initial values. @@ -20070,7 +20084,7 @@ def __init__( select: Optional[SchemaBase | Map | SelectionType_T] = Undefined, bind: Optional[SchemaBase | Literal["legend", "scales"] | Map] = Undefined, value: Optional[ - str | bool | None | float | SchemaBase | Sequence[SchemaBase | Map] | Map + Temporal | SchemaBase | Sequence[SchemaBase | Map] | Map | PrimitiveValue_T ] = Undefined, **kwds, ): @@ -20196,9 +20210,9 @@ class FieldOrDatumDefWithConditionDatumDefstringnull( **Note:** A field definition's ``condition`` property can only contain `conditional value definitions `__ since Vega-Lite only allows at most one encoded field per encoding channel. - datum : str, bool, dict, None, float, :class:`ExprRef`, :class:`DateTime`, :class:`RepeatRef`, :class:`PrimitiveValue` + datum : str, bool, dict, float, :class:`ExprRef`, :class:`DateTime`, :class:`RepeatRef`, :class:`PrimitiveValue`, None A constant value in data domain. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -20295,9 +20309,9 @@ def __init__( bandPosition: Optional[float] = Undefined, condition: Optional[SchemaBase | Sequence[SchemaBase | Map] | Map] = Undefined, datum: Optional[ - str | bool | None | float | Parameter | SchemaBase | Map + Temporal | Parameter | SchemaBase | Map | PrimitiveValue_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | Type_T] = Undefined, **kwds, ): @@ -20333,7 +20347,7 @@ class FieldOrDatumDefWithConditionMarkPropFieldDefTypeForShapestringnull( Relative position on a band of a stacked, binned, time unit, or band scale. For example, the marks will be positioned at the beginning of the band if set to ``0``, and at the middle of the band if set to ``0.5``. - bin : bool, dict, None, :class:`BinParams` + bin : bool, dict, :class:`BinParams`, None A flag for binning a ``quantitative`` field, `an object defining binning parameters `__, or indicating that the data for ``x`` or ``y`` channel are binned before they are imported into @@ -20376,7 +20390,7 @@ class FieldOrDatumDefWithConditionMarkPropFieldDefTypeForShapestringnull( about escaping in the `field documentation `__. 2) ``field`` is not required if ``aggregate`` is ``count``. - legend : dict, None, :class:`Legend` + legend : dict, :class:`Legend`, None An object defining properties of the legend. If ``null``, the legend for the encoding channel will be removed. @@ -20385,7 +20399,7 @@ class FieldOrDatumDefWithConditionMarkPropFieldDefTypeForShapestringnull( **See also:** `legend `__ documentation. - scale : dict, None, :class:`Scale` + scale : dict, :class:`Scale`, None An object defining properties of the channel's scale, which is the function that transforms values in the data domain (numbers, dates, strings, etc) to visual values (pixels, colors, sizes) of the encoding channels. @@ -20398,7 +20412,7 @@ class FieldOrDatumDefWithConditionMarkPropFieldDefTypeForShapestringnull( **See also:** `scale `__ documentation. - sort : dict, None, :class:`Sort`, Sequence[str], Sequence[bool], Sequence[float], :class:`SortArray`, :class:`SortOrder`, :class:`AllSortString`, :class:`SortByChannel`, :class:`SortByEncoding`, :class:`EncodingSortField`, :class:`SortByChannelDesc`, Sequence[dict, :class:`DateTime`], Literal['-x', '-y', '-color', '-fill', '-stroke', '-strokeWidth', '-size', '-shape', '-fillOpacity', '-strokeOpacity', '-opacity', '-text', 'ascending', 'descending', 'x', 'y', 'color', 'fill', 'stroke', 'strokeWidth', 'size', 'shape', 'fillOpacity', 'strokeOpacity', 'opacity', 'text'] + sort : dict, :class:`Sort`, Sequence[str], Sequence[bool], Sequence[float], :class:`SortArray`, :class:`SortOrder`, :class:`AllSortString`, :class:`SortByChannel`, :class:`SortByEncoding`, :class:`EncodingSortField`, :class:`SortByChannelDesc`, Sequence[dict, :class:`DateTime`], Literal['-x', '-y', '-color', '-fill', '-stroke', '-strokeWidth', '-size', '-shape', '-fillOpacity', '-strokeOpacity', '-opacity', '-text', 'ascending', 'descending', 'x', 'y', 'color', 'fill', 'stroke', 'strokeWidth', 'size', 'shape', 'fillOpacity', 'strokeOpacity', 'opacity', 'text'], None Sort order for the encoded field. For continuous fields (quantitative or temporal), ``sort`` can be either @@ -20445,7 +20459,7 @@ class FieldOrDatumDefWithConditionMarkPropFieldDefTypeForShapestringnull( **See also:** `timeUnit `__ documentation. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -20542,25 +20556,25 @@ def __init__( shorthand: Optional[str | SchemaBase | Sequence[str] | Map] = Undefined, aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Map] = Undefined, + bin: Optional[bool | SchemaBase | Map | None] = Undefined, condition: Optional[SchemaBase | Sequence[SchemaBase | Map] | Map] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, - legend: Optional[None | SchemaBase | Map] = Undefined, - scale: Optional[None | SchemaBase | Map] = Undefined, + legend: Optional[SchemaBase | Map | None] = Undefined, + scale: Optional[SchemaBase | Map | None] = Undefined, sort: Optional[ - None - | SchemaBase + SchemaBase | Sequence[str] | Sequence[bool] | Sequence[float] - | Sequence[SchemaBase | Map] + | Sequence[Temporal | SchemaBase | Map] | Map | AllSortString_T + | None ] = Undefined, timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | TypeForShape_T] = Undefined, **kwds, ): @@ -20650,7 +20664,7 @@ class SharedEncoding(VegaLiteSchema): theta2 : dict - tooltip : dict, None, :class:`StringFieldDefWithCondition`, :class:`StringValueDefWithCondition`, Sequence[dict, :class:`StringFieldDef`] + tooltip : dict, :class:`StringFieldDefWithCondition`, :class:`StringValueDefWithCondition`, Sequence[dict, :class:`StringFieldDef`], None The tooltip text to show upon mouse hover. Specifying ``tooltip`` encoding overrides `the tooltip property in the mark definition `__. @@ -20711,7 +20725,7 @@ def __init__( theta: Optional[Map] = Undefined, theta2: Optional[Map] = Undefined, tooltip: Optional[ - None | SchemaBase | Sequence[SchemaBase | Map] | Map + SchemaBase | Sequence[SchemaBase | Map] | Map | None ] = Undefined, url: Optional[Map] = Undefined, x: Optional[Map] = Undefined, @@ -20820,7 +20834,7 @@ class EncodingSortField(Sort): `__. **Default value:** ``"sum"`` for stacked plots. Otherwise, ``"min"``. - order : None, :class:`SortOrder`, Literal['ascending', 'descending'] + order : :class:`SortOrder`, Literal['ascending', 'descending'], None The sort order. One of ``"ascending"`` (default), ``"descending"``, or ``null`` (no not sort). """ @@ -20831,7 +20845,7 @@ def __init__( self, field: Optional[str | SchemaBase | Map] = Undefined, op: Optional[SchemaBase | NonArgAggregateOp_T] = Undefined, - order: Optional[None | SchemaBase | SortOrder_T] = Undefined, + order: Optional[SchemaBase | SortOrder_T | None] = Undefined, **kwds, ): super().__init__(field=field, op=op, order=order, **kwds) @@ -20874,7 +20888,7 @@ class SortByEncoding(Sort): The `encoding channel `__ to sort by (e.g., ``"x"``, ``"y"``) - order : None, :class:`SortOrder`, Literal['ascending', 'descending'] + order : :class:`SortOrder`, Literal['ascending', 'descending'], None The sort order. One of ``"ascending"`` (default), ``"descending"``, or ``null`` (no not sort). """ @@ -20884,7 +20898,7 @@ class SortByEncoding(Sort): def __init__( self, encoding: Optional[SchemaBase | SortByChannel_T] = Undefined, - order: Optional[None | SchemaBase | SortOrder_T] = Undefined, + order: Optional[SchemaBase | SortOrder_T | None] = Undefined, **kwds, ): super().__init__(encoding=encoding, order=order, **kwds) @@ -20900,7 +20914,7 @@ class SortField(VegaLiteSchema): ---------- field : str, :class:`FieldName` The name of the field to sort. - order : None, :class:`SortOrder`, Literal['ascending', 'descending'] + order : :class:`SortOrder`, Literal['ascending', 'descending'], None Whether to sort the field in ascending or descending order. One of ``"ascending"`` (default), ``"descending"``, or ``null`` (no not sort). """ @@ -20910,7 +20924,7 @@ class SortField(VegaLiteSchema): def __init__( self, field: Optional[str | SchemaBase] = Undefined, - order: Optional[None | SchemaBase | SortOrder_T] = Undefined, + order: Optional[SchemaBase | SortOrder_T | None] = Undefined, **kwds, ): super().__init__(field=field, order=order, **kwds) @@ -21000,7 +21014,7 @@ class ConcatSpecGenericSpec(Spec, NonNormalizedSpec): 2) Setting the ``columns`` to ``1`` is equivalent to ``vconcat`` (for ``concat``) and to using the ``row`` channel (for ``facet`` and ``repeat``). - data : dict, None, :class:`Data`, :class:`UrlData`, :class:`Generator`, :class:`NamedData`, :class:`DataSource`, :class:`InlineData`, :class:`SphereGenerator`, :class:`SequenceGenerator`, :class:`GraticuleGenerator` + data : dict, :class:`Data`, :class:`UrlData`, :class:`Generator`, :class:`NamedData`, :class:`DataSource`, :class:`InlineData`, :class:`SphereGenerator`, :class:`SequenceGenerator`, :class:`GraticuleGenerator`, None An object describing the data source. Set to ``null`` to ignore the parent's data source. If no data is set, it is derived from the parent. description : str @@ -21032,7 +21046,7 @@ def __init__( bounds: Optional[Literal["full", "flush"]] = Undefined, center: Optional[bool | SchemaBase | Map] = Undefined, columns: Optional[float] = Undefined, - data: Optional[None | SchemaBase | Map] = Undefined, + data: Optional[SchemaBase | Map | None] = Undefined, description: Optional[str] = Undefined, name: Optional[str] = Undefined, resolve: Optional[SchemaBase | Map] = Undefined, @@ -21126,7 +21140,7 @@ class FacetSpec(Spec, NonNormalizedSpec): 2) Setting the ``columns`` to ``1`` is equivalent to ``vconcat`` (for ``concat``) and to using the ``row`` channel (for ``facet`` and ``repeat``). - data : dict, None, :class:`Data`, :class:`UrlData`, :class:`Generator`, :class:`NamedData`, :class:`DataSource`, :class:`InlineData`, :class:`SphereGenerator`, :class:`SequenceGenerator`, :class:`GraticuleGenerator` + data : dict, :class:`Data`, :class:`UrlData`, :class:`Generator`, :class:`NamedData`, :class:`DataSource`, :class:`InlineData`, :class:`SphereGenerator`, :class:`SequenceGenerator`, :class:`GraticuleGenerator`, None An object describing the data source. Set to ``null`` to ignore the parent's data source. If no data is set, it is derived from the parent. description : str @@ -21159,7 +21173,7 @@ def __init__( bounds: Optional[Literal["full", "flush"]] = Undefined, center: Optional[bool | SchemaBase | Map] = Undefined, columns: Optional[float] = Undefined, - data: Optional[None | SchemaBase | Map] = Undefined, + data: Optional[SchemaBase | Map | None] = Undefined, description: Optional[str] = Undefined, name: Optional[str] = Undefined, resolve: Optional[SchemaBase | Map] = Undefined, @@ -21235,7 +21249,7 @@ class FacetedUnitSpec(Spec, NonNormalizedSpec): supply different centering values for rows and columns. **Default value:** ``false`` - data : dict, None, :class:`Data`, :class:`UrlData`, :class:`Generator`, :class:`NamedData`, :class:`DataSource`, :class:`InlineData`, :class:`SphereGenerator`, :class:`SequenceGenerator`, :class:`GraticuleGenerator` + data : dict, :class:`Data`, :class:`UrlData`, :class:`Generator`, :class:`NamedData`, :class:`DataSource`, :class:`InlineData`, :class:`SphereGenerator`, :class:`SequenceGenerator`, :class:`GraticuleGenerator`, None An object describing the data source. Set to ``null`` to ignore the parent's data source. If no data is set, it is derived from the parent. description : str @@ -21317,7 +21331,7 @@ def __init__( align: Optional[SchemaBase | Map | LayoutAlign_T] = Undefined, bounds: Optional[Literal["full", "flush"]] = Undefined, center: Optional[bool | SchemaBase | Map] = Undefined, - data: Optional[None | SchemaBase | Map] = Undefined, + data: Optional[SchemaBase | Map | None] = Undefined, description: Optional[str] = Undefined, encoding: Optional[SchemaBase | Map] = Undefined, height: Optional[float | SchemaBase | Literal["container"] | Map] = Undefined, @@ -21380,7 +21394,7 @@ class HConcatSpecGenericSpec(Spec, NonNormalizedSpec): rows or columns. **Default value:** ``false`` - data : dict, None, :class:`Data`, :class:`UrlData`, :class:`Generator`, :class:`NamedData`, :class:`DataSource`, :class:`InlineData`, :class:`SphereGenerator`, :class:`SequenceGenerator`, :class:`GraticuleGenerator` + data : dict, :class:`Data`, :class:`UrlData`, :class:`Generator`, :class:`NamedData`, :class:`DataSource`, :class:`InlineData`, :class:`SphereGenerator`, :class:`SequenceGenerator`, :class:`GraticuleGenerator`, None An object describing the data source. Set to ``null`` to ignore the parent's data source. If no data is set, it is derived from the parent. description : str @@ -21406,7 +21420,7 @@ def __init__( hconcat: Optional[Sequence[SchemaBase | Map]] = Undefined, bounds: Optional[Literal["full", "flush"]] = Undefined, center: Optional[bool] = Undefined, - data: Optional[None | SchemaBase | Map] = Undefined, + data: Optional[SchemaBase | Map | None] = Undefined, description: Optional[str] = Undefined, name: Optional[str] = Undefined, resolve: Optional[SchemaBase | Map] = Undefined, @@ -21446,7 +21460,7 @@ class LayerSpec(Spec, NonNormalizedSpec): as layering facet specifications is not allowed. Instead, use the `facet operator `__ and place a layer inside a facet. - data : dict, None, :class:`Data`, :class:`UrlData`, :class:`Generator`, :class:`NamedData`, :class:`DataSource`, :class:`InlineData`, :class:`SphereGenerator`, :class:`SequenceGenerator`, :class:`GraticuleGenerator` + data : dict, :class:`Data`, :class:`UrlData`, :class:`Generator`, :class:`NamedData`, :class:`DataSource`, :class:`InlineData`, :class:`SphereGenerator`, :class:`SequenceGenerator`, :class:`GraticuleGenerator`, None An object describing the data source. Set to ``null`` to ignore the parent's data source. If no data is set, it is derived from the parent. description : str @@ -21514,7 +21528,7 @@ class LayerSpec(Spec, NonNormalizedSpec): def __init__( self, layer: Optional[Sequence[SchemaBase | Map]] = Undefined, - data: Optional[None | SchemaBase | Map] = Undefined, + data: Optional[SchemaBase | Map | None] = Undefined, description: Optional[str] = Undefined, encoding: Optional[SchemaBase | Map] = Undefined, height: Optional[float | SchemaBase | Literal["container"] | Map] = Undefined, @@ -21621,7 +21635,7 @@ class LayerRepeatSpec(RepeatSpec): 2) Setting the ``columns`` to ``1`` is equivalent to ``vconcat`` (for ``concat``) and to using the ``row`` channel (for ``facet`` and ``repeat``). - data : dict, None, :class:`Data`, :class:`UrlData`, :class:`Generator`, :class:`NamedData`, :class:`DataSource`, :class:`InlineData`, :class:`SphereGenerator`, :class:`SequenceGenerator`, :class:`GraticuleGenerator` + data : dict, :class:`Data`, :class:`UrlData`, :class:`Generator`, :class:`NamedData`, :class:`DataSource`, :class:`InlineData`, :class:`SphereGenerator`, :class:`SequenceGenerator`, :class:`GraticuleGenerator`, None An object describing the data source. Set to ``null`` to ignore the parent's data source. If no data is set, it is derived from the parent. description : str @@ -21654,7 +21668,7 @@ def __init__( bounds: Optional[Literal["full", "flush"]] = Undefined, center: Optional[bool | SchemaBase | Map] = Undefined, columns: Optional[float] = Undefined, - data: Optional[None | SchemaBase | Map] = Undefined, + data: Optional[SchemaBase | Map | None] = Undefined, description: Optional[str] = Undefined, name: Optional[str] = Undefined, resolve: Optional[SchemaBase | Map] = Undefined, @@ -21751,7 +21765,7 @@ class NonLayerRepeatSpec(RepeatSpec): 2) Setting the ``columns`` to ``1`` is equivalent to ``vconcat`` (for ``concat``) and to using the ``row`` channel (for ``facet`` and ``repeat``). - data : dict, None, :class:`Data`, :class:`UrlData`, :class:`Generator`, :class:`NamedData`, :class:`DataSource`, :class:`InlineData`, :class:`SphereGenerator`, :class:`SequenceGenerator`, :class:`GraticuleGenerator` + data : dict, :class:`Data`, :class:`UrlData`, :class:`Generator`, :class:`NamedData`, :class:`DataSource`, :class:`InlineData`, :class:`SphereGenerator`, :class:`SequenceGenerator`, :class:`GraticuleGenerator`, None An object describing the data source. Set to ``null`` to ignore the parent's data source. If no data is set, it is derived from the parent. description : str @@ -21784,7 +21798,7 @@ def __init__( bounds: Optional[Literal["full", "flush"]] = Undefined, center: Optional[bool | SchemaBase | Map] = Undefined, columns: Optional[float] = Undefined, - data: Optional[None | SchemaBase | Map] = Undefined, + data: Optional[SchemaBase | Map | None] = Undefined, description: Optional[str] = Undefined, name: Optional[str] = Undefined, resolve: Optional[SchemaBase | Map] = Undefined, @@ -22018,7 +22032,7 @@ class StringFieldDef(VegaLiteSchema): Relative position on a band of a stacked, binned, time unit, or band scale. For example, the marks will be positioned at the beginning of the band if set to ``0``, and at the middle of the band if set to ``0.5``. - bin : bool, dict, None, Literal['binned'], :class:`BinParams` + bin : bool, dict, Literal['binned'], :class:`BinParams`, None A flag for binning a ``quantitative`` field, `an object defining binning parameters `__, or indicating that the data for ``x`` or ``y`` channel are binned before they are imported into @@ -22095,7 +22109,7 @@ class StringFieldDef(VegaLiteSchema): **See also:** `timeUnit `__ documentation. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -22189,14 +22203,14 @@ def __init__( self, aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Literal["binned"] | Map] = Undefined, + bin: Optional[bool | SchemaBase | Literal["binned"] | Map | None] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, format: Optional[str | SchemaBase | Map] = Undefined, formatType: Optional[str] = Undefined, timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, **kwds, ): @@ -22234,7 +22248,7 @@ class StringFieldDefWithCondition(VegaLiteSchema): Relative position on a band of a stacked, binned, time unit, or band scale. For example, the marks will be positioned at the beginning of the band if set to ``0``, and at the middle of the band if set to ``0.5``. - bin : bool, dict, None, Literal['binned'], :class:`BinParams` + bin : bool, dict, Literal['binned'], :class:`BinParams`, None A flag for binning a ``quantitative`` field, `an object defining binning parameters `__, or indicating that the data for ``x`` or ``y`` channel are binned before they are imported into @@ -22318,7 +22332,7 @@ class StringFieldDefWithCondition(VegaLiteSchema): **See also:** `timeUnit `__ documentation. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -22413,7 +22427,7 @@ def __init__( shorthand: Optional[str | SchemaBase | Sequence[str] | Map] = Undefined, aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Literal["binned"] | Map] = Undefined, + bin: Optional[bool | SchemaBase | Literal["binned"] | Map | None] = Undefined, condition: Optional[SchemaBase | Sequence[SchemaBase | Map] | Map] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, format: Optional[str | SchemaBase | Map] = Undefined, @@ -22421,7 +22435,7 @@ def __init__( timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, **kwds, ): @@ -22449,7 +22463,7 @@ class StringValueDefWithCondition(VegaLiteSchema): ---------- condition : dict, :class:`ConditionalMarkPropFieldOrDatumDef`, :class:`ConditionalValueDefstringnullExprRef`, :class:`ConditionalParameterMarkPropFieldOrDatumDef`, :class:`ConditionalPredicateMarkPropFieldOrDatumDef`, :class:`ConditionalParameterValueDefstringnullExprRef`, :class:`ConditionalPredicateValueDefstringnullExprRef`, Sequence[dict, :class:`ConditionalValueDefstringnullExprRef`, :class:`ConditionalParameterValueDefstringnullExprRef`, :class:`ConditionalPredicateValueDefstringnullExprRef`] A field definition or one or more value definition(s) with a parameter predicate. - value : str, dict, None, :class:`ExprRef` + value : str, dict, :class:`ExprRef`, None A constant value in visual domain (e.g., ``"red"`` / ``"#0099ff"`` / `gradient definition `__ for color, values between ``0`` to ``1`` for opacity). @@ -22460,7 +22474,7 @@ class StringValueDefWithCondition(VegaLiteSchema): def __init__( self, condition: Optional[SchemaBase | Sequence[SchemaBase | Map] | Map] = Undefined, - value: Optional[str | None | Parameter | SchemaBase | Map] = Undefined, + value: Optional[str | Parameter | SchemaBase | Map | None] = Undefined, **kwds, ): super().__init__(condition=condition, value=value, **kwds) @@ -22633,7 +22647,7 @@ class FieldOrDatumDefWithConditionStringDatumDefText(TextDef): **Note:** A field definition's ``condition`` property can only contain `conditional value definitions `__ since Vega-Lite only allows at most one encoded field per encoding channel. - datum : str, bool, dict, None, float, :class:`ExprRef`, :class:`DateTime`, :class:`RepeatRef`, :class:`PrimitiveValue` + datum : str, bool, dict, float, :class:`ExprRef`, :class:`DateTime`, :class:`RepeatRef`, :class:`PrimitiveValue`, None A constant value in data domain. format : str, dict, :class:`Dict` When used with the default ``"number"`` and ``"time"`` format type, the text @@ -22667,7 +22681,7 @@ class FieldOrDatumDefWithConditionStringDatumDefText(TextDef): * ``"time"`` for temporal fields and ordinal and nominal fields with ``timeUnit``. * ``"number"`` for quantitative fields as well as ordinal and nominal fields without ``timeUnit``. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -22764,11 +22778,11 @@ def __init__( bandPosition: Optional[float] = Undefined, condition: Optional[SchemaBase | Sequence[SchemaBase | Map] | Map] = Undefined, datum: Optional[ - str | bool | None | float | Parameter | SchemaBase | Map + Temporal | Parameter | SchemaBase | Map | PrimitiveValue_T ] = Undefined, format: Optional[str | SchemaBase | Map] = Undefined, formatType: Optional[str] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | Type_T] = Undefined, **kwds, ): @@ -22804,7 +22818,7 @@ class FieldOrDatumDefWithConditionStringFieldDefText(TextDef): Relative position on a band of a stacked, binned, time unit, or band scale. For example, the marks will be positioned at the beginning of the band if set to ``0``, and at the middle of the band if set to ``0.5``. - bin : bool, dict, None, Literal['binned'], :class:`BinParams` + bin : bool, dict, Literal['binned'], :class:`BinParams`, None A flag for binning a ``quantitative`` field, `an object defining binning parameters `__, or indicating that the data for ``x`` or ``y`` channel are binned before they are imported into @@ -22888,7 +22902,7 @@ class FieldOrDatumDefWithConditionStringFieldDefText(TextDef): **See also:** `timeUnit `__ documentation. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -22985,7 +22999,7 @@ def __init__( shorthand: Optional[str | SchemaBase | Sequence[str] | Map] = Undefined, aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Literal["binned"] | Map] = Undefined, + bin: Optional[bool | SchemaBase | Literal["binned"] | Map | None] = Undefined, condition: Optional[SchemaBase | Sequence[SchemaBase | Map] | Map] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, format: Optional[str | SchemaBase | Map] = Undefined, @@ -22993,7 +23007,7 @@ def __init__( timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, **kwds, ): @@ -23134,7 +23148,7 @@ class TickConfig(AnyMarkConfig): endAngle : dict, float, :class:`ExprRef` The end angle in radians for arc marks. A value of ``0`` indicates up (north), increasing values proceed clockwise. - fill : str, dict, None, :class:`Color`, :class:`ExprRef`, :class:`Gradient`, :class:`HexColor`, :class:`ColorName`, :class:`LinearGradient`, :class:`RadialGradient`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'] + fill : str, dict, :class:`Color`, :class:`ExprRef`, :class:`Gradient`, :class:`HexColor`, :class:`ColorName`, :class:`LinearGradient`, :class:`RadialGradient`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'], None Default fill color. This property has higher precedence than ``config.color``. Set to ``null`` to remove fill. @@ -23195,7 +23209,7 @@ class TickConfig(AnyMarkConfig): * ``"bundle"``: equivalent to basis, except the tension parameter is used to straighten the spline. * ``"monotone"``: cubic interpolation that preserves monotonicity in y. - invalid : None, :class:`MarkInvalidDataMode`, Literal['filter', 'break-paths-filter-domains', 'break-paths-show-domains', 'break-paths-show-path-domains', 'show'] + invalid : :class:`MarkInvalidDataMode`, Literal['filter', 'break-paths-filter-domains', 'break-paths-show-domains', 'break-paths-show-path-domains', 'show'], None Invalid data mode, which defines how the marks and corresponding scales should represent invalid values (``null`` and ``NaN`` in continuous scales *without* defined output for invalid values). @@ -23310,7 +23324,7 @@ class TickConfig(AnyMarkConfig): startAngle : dict, float, :class:`ExprRef` The start angle in radians for arc marks. A value of ``0`` indicates up (north), increasing values proceed clockwise. - stroke : str, dict, None, :class:`Color`, :class:`ExprRef`, :class:`Gradient`, :class:`HexColor`, :class:`ColorName`, :class:`LinearGradient`, :class:`RadialGradient`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'] + stroke : str, dict, :class:`Color`, :class:`ExprRef`, :class:`Gradient`, :class:`HexColor`, :class:`ColorName`, :class:`LinearGradient`, :class:`RadialGradient`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'], None Default stroke color. This property has higher precedence than ``config.color``. Set to ``null`` to remove stroke. @@ -23366,7 +23380,7 @@ class TickConfig(AnyMarkConfig): Default relative band size for a time unit. If set to ``1``, the bandwidth of the marks will be equal to the time unit band step. If set to ``0.5``, bandwidth of the marks will be half of the time unit band step. - tooltip : str, bool, dict, None, float, :class:`ExprRef`, :class:`TooltipContent` + tooltip : str, bool, dict, float, :class:`ExprRef`, :class:`TooltipContent`, None The tooltip text string to show upon mouse hover or an object defining which fields should the tooltip be derived from. @@ -23441,7 +23455,7 @@ def __init__( ellipsis: Optional[str | Parameter | SchemaBase | Map] = Undefined, endAngle: Optional[float | Parameter | SchemaBase | Map] = Undefined, fill: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, fillOpacity: Optional[float | Parameter | SchemaBase | Map] = Undefined, filled: Optional[bool] = Undefined, @@ -23453,7 +23467,7 @@ def __init__( href: Optional[str | Parameter | SchemaBase | Map] = Undefined, innerRadius: Optional[float | Parameter | SchemaBase | Map] = Undefined, interpolate: Optional[Parameter | SchemaBase | Map | Interpolate_T] = Undefined, - invalid: Optional[None | SchemaBase | MarkInvalidDataMode_T] = Undefined, + invalid: Optional[SchemaBase | MarkInvalidDataMode_T | None] = Undefined, limit: Optional[float | Parameter | SchemaBase | Map] = Undefined, lineBreak: Optional[str | Parameter | SchemaBase | Map] = Undefined, lineHeight: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -23469,7 +23483,7 @@ def __init__( smooth: Optional[bool | Parameter | SchemaBase | Map] = Undefined, startAngle: Optional[float | Parameter | SchemaBase | Map] = Undefined, stroke: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, strokeCap: Optional[Parameter | SchemaBase | Map | StrokeCap_T] = Undefined, strokeDash: Optional[ @@ -23489,7 +23503,7 @@ def __init__( timeUnitBandPosition: Optional[float] = Undefined, timeUnitBandSize: Optional[float] = Undefined, tooltip: Optional[ - str | bool | None | float | Parameter | SchemaBase | Map + str | bool | float | Parameter | SchemaBase | Map | None ] = Undefined, url: Optional[str | Parameter | SchemaBase | Map] = Undefined, width: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -23827,7 +23841,7 @@ class TitleConfig(VegaLiteSchema): ``"line-bottom"``. The ``"line-top"`` and ``"line-bottom"`` values operate similarly to ``"top"`` and ``"bottom"``, but are calculated relative to the *lineHeight* rather than *fontSize* alone. - color : str, dict, None, :class:`Color`, :class:`ExprRef`, :class:`HexColor`, :class:`ColorName`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'] + color : str, dict, :class:`Color`, :class:`ExprRef`, :class:`HexColor`, :class:`ColorName`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'], None Text color for title text. dx : dict, float, :class:`ExprRef` Delta offset for title and subtitle text x-coordinate. @@ -23857,7 +23871,7 @@ class TitleConfig(VegaLiteSchema): position along the edge of the chart. orient : dict, :class:`ExprRef`, :class:`TitleOrient`, Literal['none', 'left', 'right', 'top', 'bottom'] Default title orientation (``"top"``, ``"bottom"``, ``"left"``, or ``"right"``) - subtitleColor : str, dict, None, :class:`Color`, :class:`ExprRef`, :class:`HexColor`, :class:`ColorName`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'] + subtitleColor : str, dict, :class:`Color`, :class:`ExprRef`, :class:`HexColor`, :class:`ColorName`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'], None Text color for subtitle text. subtitleFont : str, dict, :class:`ExprRef` Font name for subtitle text. @@ -23890,7 +23904,7 @@ def __init__( aria: Optional[bool | Parameter | SchemaBase | Map] = Undefined, baseline: Optional[SchemaBase | TextBaseline_T] = Undefined, color: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, dx: Optional[float | Parameter | SchemaBase | Map] = Undefined, dy: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -23904,7 +23918,7 @@ def __init__( offset: Optional[float | Parameter | SchemaBase | Map] = Undefined, orient: Optional[Parameter | SchemaBase | Map | TitleOrient_T] = Undefined, subtitleColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, subtitleFont: Optional[str | Parameter | SchemaBase | Map] = Undefined, subtitleFontSize: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -24006,7 +24020,7 @@ class TitleParams(VegaLiteSchema): ``"line-bottom"``. The ``"line-top"`` and ``"line-bottom"`` values operate similarly to ``"top"`` and ``"bottom"``, but are calculated relative to the *lineHeight* rather than *fontSize* alone. - color : str, dict, None, :class:`Color`, :class:`ExprRef`, :class:`HexColor`, :class:`ColorName`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'] + color : str, dict, :class:`Color`, :class:`ExprRef`, :class:`HexColor`, :class:`ColorName`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'], None Text color for title text. dx : dict, float, :class:`ExprRef` Delta offset for title and subtitle text x-coordinate. @@ -24043,7 +24057,7 @@ class TitleParams(VegaLiteSchema): **Default value:** ``"group-title"``. subtitle : str, :class:`Text`, Sequence[str] The subtitle Text. - subtitleColor : str, dict, None, :class:`Color`, :class:`ExprRef`, :class:`HexColor`, :class:`ColorName`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'] + subtitleColor : str, dict, :class:`Color`, :class:`ExprRef`, :class:`HexColor`, :class:`ColorName`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'], None Text color for subtitle text. subtitleFont : str, dict, :class:`ExprRef` Font name for subtitle text. @@ -24077,7 +24091,7 @@ def __init__( aria: Optional[bool | Parameter | SchemaBase | Map] = Undefined, baseline: Optional[SchemaBase | TextBaseline_T] = Undefined, color: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, dx: Optional[float | Parameter | SchemaBase | Map] = Undefined, dy: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -24093,7 +24107,7 @@ def __init__( style: Optional[str | Sequence[str]] = Undefined, subtitle: Optional[str | SchemaBase | Sequence[str]] = Undefined, subtitleColor: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, subtitleFont: Optional[str | Parameter | SchemaBase | Map] = Undefined, subtitleFontSize: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -24200,7 +24214,7 @@ class TopLevelSelectionParameter(TopLevelParameter): **See also:** `bind `__ documentation. - value : str, bool, dict, None, float, :class:`DateTime`, :class:`SelectionInit`, :class:`PrimitiveValue`, :class:`SelectionInitIntervalMapping`, Sequence[dict, :class:`SelectionInitMapping`] + value : str, bool, dict, float, :class:`DateTime`, :class:`SelectionInit`, :class:`PrimitiveValue`, :class:`SelectionInitIntervalMapping`, Sequence[dict, :class:`SelectionInitMapping`], None Initialize the selection with a mapping between `projected channels or field names `__ and initial values. @@ -24221,7 +24235,7 @@ def __init__( select: Optional[SchemaBase | Map | SelectionType_T] = Undefined, bind: Optional[SchemaBase | Literal["legend", "scales"] | Map] = Undefined, value: Optional[ - str | bool | None | float | SchemaBase | Sequence[SchemaBase | Map] | Map + Temporal | SchemaBase | Sequence[SchemaBase | Map] | Map | PrimitiveValue_T ] = Undefined, views: Optional[Sequence[str]] = Undefined, **kwds, @@ -24318,7 +24332,7 @@ class TopLevelConcatSpec(TopLevelSpec): config : dict, :class:`Config` Vega-Lite configuration object. This property can only be defined at the top-level of a specification. - data : dict, None, :class:`Data`, :class:`UrlData`, :class:`Generator`, :class:`NamedData`, :class:`DataSource`, :class:`InlineData`, :class:`SphereGenerator`, :class:`SequenceGenerator`, :class:`GraticuleGenerator` + data : dict, :class:`Data`, :class:`UrlData`, :class:`Generator`, :class:`NamedData`, :class:`DataSource`, :class:`InlineData`, :class:`SphereGenerator`, :class:`SequenceGenerator`, :class:`GraticuleGenerator`, None An object describing the data source. Set to ``null`` to ignore the parent's data source. If no data is set, it is derived from the parent. datasets : dict, :class:`Datasets` @@ -24377,7 +24391,7 @@ def __init__( center: Optional[bool | SchemaBase | Map] = Undefined, columns: Optional[float] = Undefined, config: Optional[SchemaBase | Map] = Undefined, - data: Optional[None | SchemaBase | Map] = Undefined, + data: Optional[SchemaBase | Map | None] = Undefined, datasets: Optional[SchemaBase | Map] = Undefined, description: Optional[str] = Undefined, name: Optional[str] = Undefined, @@ -24420,7 +24434,7 @@ class TopLevelFacetSpec(TopLevelSpec): Parameters ---------- - data : dict, None, :class:`Data`, :class:`UrlData`, :class:`Generator`, :class:`NamedData`, :class:`DataSource`, :class:`InlineData`, :class:`SphereGenerator`, :class:`SequenceGenerator`, :class:`GraticuleGenerator` + data : dict, :class:`Data`, :class:`UrlData`, :class:`Generator`, :class:`NamedData`, :class:`DataSource`, :class:`InlineData`, :class:`SphereGenerator`, :class:`SequenceGenerator`, :class:`GraticuleGenerator`, None An object describing the data source. Set to ``null`` to ignore the parent's data source. If no data is set, it is derived from the parent. facet : dict, :class:`FacetMapping`, :class:`FacetFieldDef` @@ -24542,7 +24556,7 @@ class TopLevelFacetSpec(TopLevelSpec): def __init__( self, - data: Optional[None | SchemaBase | Map] = Undefined, + data: Optional[SchemaBase | Map | None] = Undefined, facet: Optional[SchemaBase | Map] = Undefined, spec: Optional[SchemaBase | Map] = Undefined, align: Optional[SchemaBase | Map | LayoutAlign_T] = Undefined, @@ -24628,7 +24642,7 @@ class TopLevelHConcatSpec(TopLevelSpec): config : dict, :class:`Config` Vega-Lite configuration object. This property can only be defined at the top-level of a specification. - data : dict, None, :class:`Data`, :class:`UrlData`, :class:`Generator`, :class:`NamedData`, :class:`DataSource`, :class:`InlineData`, :class:`SphereGenerator`, :class:`SequenceGenerator`, :class:`GraticuleGenerator` + data : dict, :class:`Data`, :class:`UrlData`, :class:`Generator`, :class:`NamedData`, :class:`DataSource`, :class:`InlineData`, :class:`SphereGenerator`, :class:`SequenceGenerator`, :class:`GraticuleGenerator`, None An object describing the data source. Set to ``null`` to ignore the parent's data source. If no data is set, it is derived from the parent. datasets : dict, :class:`Datasets` @@ -24681,7 +24695,7 @@ def __init__( bounds: Optional[Literal["full", "flush"]] = Undefined, center: Optional[bool] = Undefined, config: Optional[SchemaBase | Map] = Undefined, - data: Optional[None | SchemaBase | Map] = Undefined, + data: Optional[SchemaBase | Map | None] = Undefined, datasets: Optional[SchemaBase | Map] = Undefined, description: Optional[str] = Undefined, name: Optional[str] = Undefined, @@ -24742,7 +24756,7 @@ class TopLevelLayerSpec(TopLevelSpec): config : dict, :class:`Config` Vega-Lite configuration object. This property can only be defined at the top-level of a specification. - data : dict, None, :class:`Data`, :class:`UrlData`, :class:`Generator`, :class:`NamedData`, :class:`DataSource`, :class:`InlineData`, :class:`SphereGenerator`, :class:`SequenceGenerator`, :class:`GraticuleGenerator` + data : dict, :class:`Data`, :class:`UrlData`, :class:`Generator`, :class:`NamedData`, :class:`DataSource`, :class:`InlineData`, :class:`SphereGenerator`, :class:`SequenceGenerator`, :class:`GraticuleGenerator`, None An object describing the data source. Set to ``null`` to ignore the parent's data source. If no data is set, it is derived from the parent. datasets : dict, :class:`Datasets` @@ -24837,7 +24851,7 @@ def __init__( str | Parameter | SchemaBase | Map | ColorName_T ] = Undefined, config: Optional[SchemaBase | Map] = Undefined, - data: Optional[None | SchemaBase | Map] = Undefined, + data: Optional[SchemaBase | Map | None] = Undefined, datasets: Optional[SchemaBase | Map] = Undefined, description: Optional[str] = Undefined, encoding: Optional[SchemaBase | Map] = Undefined, @@ -24893,7 +24907,7 @@ class TopLevelUnitSpec(TopLevelSpec): Parameters ---------- - data : dict, None, :class:`Data`, :class:`UrlData`, :class:`Generator`, :class:`NamedData`, :class:`DataSource`, :class:`InlineData`, :class:`SphereGenerator`, :class:`SequenceGenerator`, :class:`GraticuleGenerator` + data : dict, :class:`Data`, :class:`UrlData`, :class:`Generator`, :class:`NamedData`, :class:`DataSource`, :class:`InlineData`, :class:`SphereGenerator`, :class:`SequenceGenerator`, :class:`GraticuleGenerator`, None An object describing the data source. Set to ``null`` to ignore the parent's data source. If no data is set, it is derived from the parent. mark : dict, :class:`Mark`, :class:`AnyMark`, :class:`BoxPlot`, :class:`MarkDef`, :class:`ErrorBar`, :class:`ErrorBand`, :class:`BoxPlotDef`, :class:`ErrorBarDef`, :class:`ErrorBandDef`, :class:`CompositeMark`, :class:`CompositeMarkDef`, Literal['arc', 'area', 'bar', 'image', 'line', 'point', 'rect', 'rule', 'text', 'tick', 'trail', 'circle', 'square', 'geoshape', 'boxplot', 'errorband', 'errorbar'] @@ -25044,7 +25058,7 @@ class TopLevelUnitSpec(TopLevelSpec): def __init__( self, - data: Optional[None | SchemaBase | Map] = Undefined, + data: Optional[SchemaBase | Map | None] = Undefined, mark: Optional[SchemaBase | Map | Mark_T | CompositeMark_T] = Undefined, align: Optional[SchemaBase | Map | LayoutAlign_T] = Undefined, autosize: Optional[SchemaBase | Map | AutosizeType_T] = Undefined, @@ -25136,7 +25150,7 @@ class TopLevelVConcatSpec(TopLevelSpec): config : dict, :class:`Config` Vega-Lite configuration object. This property can only be defined at the top-level of a specification. - data : dict, None, :class:`Data`, :class:`UrlData`, :class:`Generator`, :class:`NamedData`, :class:`DataSource`, :class:`InlineData`, :class:`SphereGenerator`, :class:`SequenceGenerator`, :class:`GraticuleGenerator` + data : dict, :class:`Data`, :class:`UrlData`, :class:`Generator`, :class:`NamedData`, :class:`DataSource`, :class:`InlineData`, :class:`SphereGenerator`, :class:`SequenceGenerator`, :class:`GraticuleGenerator`, None An object describing the data source. Set to ``null`` to ignore the parent's data source. If no data is set, it is derived from the parent. datasets : dict, :class:`Datasets` @@ -25189,7 +25203,7 @@ def __init__( bounds: Optional[Literal["full", "flush"]] = Undefined, center: Optional[bool] = Undefined, config: Optional[SchemaBase | Map] = Undefined, - data: Optional[None | SchemaBase | Map] = Undefined, + data: Optional[SchemaBase | Map | None] = Undefined, datasets: Optional[SchemaBase | Map] = Undefined, description: Optional[str] = Undefined, name: Optional[str] = Undefined, @@ -25242,7 +25256,7 @@ class TopoDataFormat(DataFormat): not as individual GeoJSON features. Extracting a mesh is useful for more efficiently drawing borders or other geographic elements that you do not need to associate with specific regions such as individual countries, states or counties. - parse : dict, None, :class:`Parse` + parse : dict, :class:`Parse`, None If set to ``null``, disable type inference based on the spec and only use type inference based on the data. Alternatively, a parsing directive object can be provided for explicit data types. Each property of the object corresponds to a field @@ -25271,7 +25285,7 @@ def __init__( self, feature: Optional[str] = Undefined, mesh: Optional[str] = Undefined, - parse: Optional[None | SchemaBase | Map] = Undefined, + parse: Optional[SchemaBase | Map | None] = Undefined, type: Optional[Literal["topojson"]] = Undefined, **kwds, ): @@ -25567,7 +25581,7 @@ class ImputeTransform(Transform): key : str, :class:`FieldName` A key field that uniquely identifies data objects within a group. Missing key values (those occurring in the data but not in the current group) will be imputed. - frame : Sequence[None, float] + frame : Sequence[float, None] A frame specification as a two-element array used to control the window over which the specified method is applied. The array entries should either be a number indicating the offset from the current data object, or null to indicate unbounded @@ -25606,7 +25620,7 @@ def __init__( self, impute: Optional[str | SchemaBase] = Undefined, key: Optional[str | SchemaBase] = Undefined, - frame: Optional[Sequence[None | float]] = Undefined, + frame: Optional[Sequence[float | None]] = Undefined, groupby: Optional[Sequence[str | SchemaBase]] = Undefined, keyvals: Optional[SchemaBase | Sequence[Any] | Map] = Undefined, method: Optional[SchemaBase | ImputeMethod_T] = Undefined, @@ -25997,7 +26011,7 @@ class TypedFieldDef(VegaLiteSchema): Relative position on a band of a stacked, binned, time unit, or band scale. For example, the marks will be positioned at the beginning of the band if set to ``0``, and at the middle of the band if set to ``0.5``. - bin : bool, dict, None, Literal['binned'], :class:`BinParams` + bin : bool, dict, Literal['binned'], :class:`BinParams`, None A flag for binning a ``quantitative`` field, `an object defining binning parameters `__, or indicating that the data for ``x`` or ``y`` channel are binned before they are imported into @@ -26042,7 +26056,7 @@ class TypedFieldDef(VegaLiteSchema): **See also:** `timeUnit `__ documentation. - title : str, None, :class:`Text`, Sequence[str] + title : str, :class:`Text`, Sequence[str], None A title for the field. If ``null``, the title will be removed. **Default value:** derived from the field's name and transformation function @@ -26136,12 +26150,12 @@ def __init__( self, aggregate: Optional[SchemaBase | Map | NonArgAggregateOp_T] = Undefined, bandPosition: Optional[float] = Undefined, - bin: Optional[bool | None | SchemaBase | Literal["binned"] | Map] = Undefined, + bin: Optional[bool | SchemaBase | Literal["binned"] | Map | None] = Undefined, field: Optional[str | SchemaBase | Map] = Undefined, timeUnit: Optional[ SchemaBase | Map | MultiTimeUnit_T | BinnedTimeUnit_T | SingleTimeUnit_T ] = Undefined, - title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined, + title: Optional[str | SchemaBase | Sequence[str] | None] = Undefined, type: Optional[SchemaBase | StandardType_T] = Undefined, **kwds, ): @@ -26179,7 +26193,7 @@ class UnitSpec(VegaLiteSchema): ``"tick"``, ``"line"``, ``"area"``, ``"point"``, ``"rule"``, ``"geoshape"``, and ``"text"``) or a `mark definition object `__. - data : dict, None, :class:`Data`, :class:`UrlData`, :class:`Generator`, :class:`NamedData`, :class:`DataSource`, :class:`InlineData`, :class:`SphereGenerator`, :class:`SequenceGenerator`, :class:`GraticuleGenerator` + data : dict, :class:`Data`, :class:`UrlData`, :class:`Generator`, :class:`NamedData`, :class:`DataSource`, :class:`InlineData`, :class:`SphereGenerator`, :class:`SequenceGenerator`, :class:`GraticuleGenerator`, None An object describing the data source. Set to ``null`` to ignore the parent's data source. If no data is set, it is derived from the parent. description : str @@ -26206,7 +26220,7 @@ class UnitSpec(VegaLiteSchema): def __init__( self, mark: Optional[SchemaBase | Map | Mark_T | CompositeMark_T] = Undefined, - data: Optional[None | SchemaBase | Map] = Undefined, + data: Optional[SchemaBase | Map | None] = Undefined, description: Optional[str] = Undefined, encoding: Optional[SchemaBase | Map] = Undefined, name: Optional[str] = Undefined, @@ -26241,7 +26255,7 @@ class UnitSpecWithFrame(VegaLiteSchema): ``"tick"``, ``"line"``, ``"area"``, ``"point"``, ``"rule"``, ``"geoshape"``, and ``"text"``) or a `mark definition object `__. - data : dict, None, :class:`Data`, :class:`UrlData`, :class:`Generator`, :class:`NamedData`, :class:`DataSource`, :class:`InlineData`, :class:`SphereGenerator`, :class:`SequenceGenerator`, :class:`GraticuleGenerator` + data : dict, :class:`Data`, :class:`UrlData`, :class:`Generator`, :class:`NamedData`, :class:`DataSource`, :class:`InlineData`, :class:`SphereGenerator`, :class:`SequenceGenerator`, :class:`GraticuleGenerator`, None An object describing the data source. Set to ``null`` to ignore the parent's data source. If no data is set, it is derived from the parent. description : str @@ -26310,7 +26324,7 @@ class UnitSpecWithFrame(VegaLiteSchema): def __init__( self, mark: Optional[SchemaBase | Map | Mark_T | CompositeMark_T] = Undefined, - data: Optional[None | SchemaBase | Map] = Undefined, + data: Optional[SchemaBase | Map | None] = Undefined, description: Optional[str] = Undefined, encoding: Optional[SchemaBase | Map] = Undefined, height: Optional[float | SchemaBase | Literal["container"] | Map] = Undefined, @@ -26411,7 +26425,7 @@ class VConcatSpecGenericSpec(Spec, NonNormalizedSpec): rows or columns. **Default value:** ``false`` - data : dict, None, :class:`Data`, :class:`UrlData`, :class:`Generator`, :class:`NamedData`, :class:`DataSource`, :class:`InlineData`, :class:`SphereGenerator`, :class:`SequenceGenerator`, :class:`GraticuleGenerator` + data : dict, :class:`Data`, :class:`UrlData`, :class:`Generator`, :class:`NamedData`, :class:`DataSource`, :class:`InlineData`, :class:`SphereGenerator`, :class:`SequenceGenerator`, :class:`GraticuleGenerator`, None An object describing the data source. Set to ``null`` to ignore the parent's data source. If no data is set, it is derived from the parent. description : str @@ -26437,7 +26451,7 @@ def __init__( vconcat: Optional[Sequence[SchemaBase | Map]] = Undefined, bounds: Optional[Literal["full", "flush"]] = Undefined, center: Optional[bool] = Undefined, - data: Optional[None | SchemaBase | Map] = Undefined, + data: Optional[SchemaBase | Map | None] = Undefined, description: Optional[str] = Undefined, name: Optional[str] = Undefined, resolve: Optional[SchemaBase | Map] = Undefined, @@ -26471,7 +26485,7 @@ class ValueDefWithConditionMarkPropFieldOrDatumDefGradientstringnull( ---------- condition : dict, :class:`ConditionalMarkPropFieldOrDatumDef`, :class:`ConditionalParameterMarkPropFieldOrDatumDef`, :class:`ConditionalPredicateMarkPropFieldOrDatumDef`, :class:`ConditionalValueDefGradientstringnullExprRef`, :class:`ConditionalParameterValueDefGradientstringnullExprRef`, :class:`ConditionalPredicateValueDefGradientstringnullExprRef`, Sequence[dict, :class:`ConditionalValueDefGradientstringnullExprRef`, :class:`ConditionalParameterValueDefGradientstringnullExprRef`, :class:`ConditionalPredicateValueDefGradientstringnullExprRef`] A field definition or one or more value definition(s) with a parameter predicate. - value : str, dict, None, :class:`ExprRef`, :class:`Gradient`, :class:`LinearGradient`, :class:`RadialGradient` + value : str, dict, :class:`ExprRef`, :class:`Gradient`, :class:`LinearGradient`, :class:`RadialGradient`, None A constant value in visual domain (e.g., ``"red"`` / ``"#0099ff"`` / `gradient definition `__ for color, values between ``0`` to ``1`` for opacity). @@ -26484,7 +26498,7 @@ class ValueDefWithConditionMarkPropFieldOrDatumDefGradientstringnull( def __init__( self, condition: Optional[SchemaBase | Sequence[SchemaBase | Map] | Map] = Undefined, - value: Optional[str | None | Parameter | SchemaBase | Map] = Undefined, + value: Optional[str | Parameter | SchemaBase | Map | None] = Undefined, **kwds, ): super().__init__(condition=condition, value=value, **kwds) @@ -26500,7 +26514,7 @@ class ValueDefWithConditionMarkPropFieldOrDatumDefTypeForShapestringnull( ---------- condition : dict, :class:`ConditionalValueDefstringnullExprRef`, :class:`ConditionalParameterValueDefstringnullExprRef`, :class:`ConditionalPredicateValueDefstringnullExprRef`, :class:`ConditionalMarkPropFieldOrDatumDefTypeForShape`, :class:`ConditionalParameterMarkPropFieldOrDatumDefTypeForShape`, :class:`ConditionalPredicateMarkPropFieldOrDatumDefTypeForShape`, Sequence[dict, :class:`ConditionalValueDefstringnullExprRef`, :class:`ConditionalParameterValueDefstringnullExprRef`, :class:`ConditionalPredicateValueDefstringnullExprRef`] A field definition or one or more value definition(s) with a parameter predicate. - value : str, dict, None, :class:`ExprRef` + value : str, dict, :class:`ExprRef`, None A constant value in visual domain (e.g., ``"red"`` / ``"#0099ff"`` / `gradient definition `__ for color, values between ``0`` to ``1`` for opacity). @@ -26513,7 +26527,7 @@ class ValueDefWithConditionMarkPropFieldOrDatumDefTypeForShapestringnull( def __init__( self, condition: Optional[SchemaBase | Sequence[SchemaBase | Map] | Map] = Undefined, - value: Optional[str | None | Parameter | SchemaBase | Map] = Undefined, + value: Optional[str | Parameter | SchemaBase | Map | None] = Undefined, **kwds, ): super().__init__(condition=condition, value=value, **kwds) @@ -26585,7 +26599,7 @@ class ValueDefWithConditionMarkPropFieldOrDatumDefstringnull(VegaLiteSchema): ---------- condition : dict, :class:`ConditionalMarkPropFieldOrDatumDef`, :class:`ConditionalValueDefstringnullExprRef`, :class:`ConditionalParameterMarkPropFieldOrDatumDef`, :class:`ConditionalPredicateMarkPropFieldOrDatumDef`, :class:`ConditionalParameterValueDefstringnullExprRef`, :class:`ConditionalPredicateValueDefstringnullExprRef`, Sequence[dict, :class:`ConditionalValueDefstringnullExprRef`, :class:`ConditionalParameterValueDefstringnullExprRef`, :class:`ConditionalPredicateValueDefstringnullExprRef`] A field definition or one or more value definition(s) with a parameter predicate. - value : str, dict, None, :class:`ExprRef` + value : str, dict, :class:`ExprRef`, None A constant value in visual domain (e.g., ``"red"`` / ``"#0099ff"`` / `gradient definition `__ for color, values between ``0`` to ``1`` for opacity). @@ -26598,7 +26612,7 @@ class ValueDefWithConditionMarkPropFieldOrDatumDefstringnull(VegaLiteSchema): def __init__( self, condition: Optional[SchemaBase | Sequence[SchemaBase | Map] | Map] = Undefined, - value: Optional[str | None | Parameter | SchemaBase | Map] = Undefined, + value: Optional[str | Parameter | SchemaBase | Map | None] = Undefined, **kwds, ): super().__init__(condition=condition, value=value, **kwds) @@ -26819,7 +26833,7 @@ class ViewBackground(VegaLiteSchema): cursor : :class:`Cursor`, Literal['auto', 'default', 'none', 'context-menu', 'help', 'pointer', 'progress', 'wait', 'cell', 'crosshair', 'text', 'vertical-text', 'alias', 'copy', 'move', 'no-drop', 'not-allowed', 'e-resize', 'n-resize', 'ne-resize', 'nw-resize', 's-resize', 'se-resize', 'sw-resize', 'w-resize', 'ew-resize', 'ns-resize', 'nesw-resize', 'nwse-resize', 'col-resize', 'row-resize', 'all-scroll', 'zoom-in', 'zoom-out', 'grab', 'grabbing'] The mouse cursor used over the view. Any valid `CSS cursor type `__ can be used. - fill : str, dict, None, :class:`Color`, :class:`ExprRef`, :class:`HexColor`, :class:`ColorName`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'] + fill : str, dict, :class:`Color`, :class:`ExprRef`, :class:`HexColor`, :class:`ColorName`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'], None The fill color. **Default value:** ``undefined`` @@ -26832,7 +26846,7 @@ class ViewBackground(VegaLiteSchema): **Default value:** ``0.7`` for non-aggregate plots with ``point``, ``tick``, ``circle``, or ``square`` marks or layered ``bar`` charts and ``1`` otherwise. - stroke : str, dict, None, :class:`Color`, :class:`ExprRef`, :class:`HexColor`, :class:`ColorName`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'] + stroke : str, dict, :class:`Color`, :class:`ExprRef`, :class:`HexColor`, :class:`ColorName`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'], None The stroke color. **Default value:** ``"#ddd"`` @@ -26875,12 +26889,12 @@ def __init__( cornerRadius: Optional[float | Parameter | SchemaBase | Map] = Undefined, cursor: Optional[SchemaBase | Cursor_T] = Undefined, fill: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, fillOpacity: Optional[float | Parameter | SchemaBase | Map] = Undefined, opacity: Optional[float | Parameter | SchemaBase | Map] = Undefined, stroke: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, strokeCap: Optional[Parameter | SchemaBase | Map | StrokeCap_T] = Undefined, strokeDash: Optional[ @@ -26950,7 +26964,7 @@ class ViewConfig(VegaLiteSchema): in the form of ``{step: number}`` defining the width per discrete step. **Default value:** a step size based on ``config.view.step``. - fill : str, dict, None, :class:`Color`, :class:`ExprRef`, :class:`HexColor`, :class:`ColorName`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'] + fill : str, dict, :class:`Color`, :class:`ExprRef`, :class:`HexColor`, :class:`ColorName`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'], None The fill color. **Default value:** ``undefined`` @@ -26965,7 +26979,7 @@ class ViewConfig(VegaLiteSchema): ``circle``, or ``square`` marks or layered ``bar`` charts and ``1`` otherwise. step : float Default step size for x-/y- discrete fields. - stroke : str, dict, None, :class:`Color`, :class:`ExprRef`, :class:`HexColor`, :class:`ColorName`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'] + stroke : str, dict, :class:`Color`, :class:`ExprRef`, :class:`HexColor`, :class:`ColorName`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'], None The stroke color. **Default value:** ``"#ddd"`` @@ -27004,13 +27018,13 @@ def __init__( discreteHeight: Optional[float | Map] = Undefined, discreteWidth: Optional[float | Map] = Undefined, fill: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, fillOpacity: Optional[float | Parameter | SchemaBase | Map] = Undefined, opacity: Optional[float | Parameter | SchemaBase | Map] = Undefined, step: Optional[float] = Undefined, stroke: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, strokeCap: Optional[Parameter | SchemaBase | Map | StrokeCap_T] = Undefined, strokeDash: Optional[ @@ -27118,7 +27132,7 @@ class WindowTransform(Transform): ---------- window : Sequence[dict, :class:`WindowFieldDef`] The definition of the fields in the window, and what calculations to use. - frame : Sequence[None, float] + frame : Sequence[float, None] A frame specification as a two-element array indicating how the sliding window should proceed. The array entries should either be a number indicating the offset from the current data object, or null to indicate unbounded rows preceding or @@ -27160,7 +27174,7 @@ class WindowTransform(Transform): def __init__( self, window: Optional[Sequence[SchemaBase | Map]] = Undefined, - frame: Optional[Sequence[None | float]] = Undefined, + frame: Optional[Sequence[float | None]] = Undefined, groupby: Optional[Sequence[str | SchemaBase]] = Undefined, ignorePeers: Optional[bool] = Undefined, sort: Optional[Sequence[SchemaBase | Map]] = Undefined, diff --git a/altair/vegalite/v5/schema/mixins.py b/altair/vegalite/v5/schema/mixins.py index 572014afa..990e193d5 100644 --- a/altair/vegalite/v5/schema/mixins.py +++ b/altair/vegalite/v5/schema/mixins.py @@ -3,14 +3,14 @@ from __future__ import annotations -from typing import TYPE_CHECKING, Literal, Sequence +from typing import TYPE_CHECKING, Literal from altair.utils import Undefined, use_signature from . import core if TYPE_CHECKING: - from altair import Parameter, SchemaBase + from collections.abc import Sequence if TYPE_CHECKING: # ruff: noqa: F405 @@ -20,6 +20,7 @@ from typing import Self else: from typing_extensions import Self + from altair import Parameter, SchemaBase from altair.typing import Optional from ._typing import * # noqa: F403 @@ -63,7 +64,7 @@ def mark_arc( dy: Optional[float | Parameter | SchemaBase | Map] = Undefined, ellipsis: Optional[str | Parameter | SchemaBase | Map] = Undefined, fill: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, fillOpacity: Optional[float | Parameter | SchemaBase | Map] = Undefined, filled: Optional[bool] = Undefined, @@ -75,7 +76,7 @@ def mark_arc( href: Optional[str | Parameter | SchemaBase | Map] = Undefined, innerRadius: Optional[float | Parameter | SchemaBase | Map] = Undefined, interpolate: Optional[Parameter | SchemaBase | Map | Interpolate_T] = Undefined, - invalid: Optional[None | SchemaBase | MarkInvalidDataMode_T] = Undefined, + invalid: Optional[SchemaBase | MarkInvalidDataMode_T | None] = Undefined, limit: Optional[float | Parameter | SchemaBase | Map] = Undefined, line: Optional[bool | SchemaBase | Map] = Undefined, lineBreak: Optional[str | Parameter | SchemaBase | Map] = Undefined, @@ -95,7 +96,7 @@ def mark_arc( size: Optional[float | Parameter | SchemaBase | Map] = Undefined, smooth: Optional[bool | Parameter | SchemaBase | Map] = Undefined, stroke: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, strokeCap: Optional[Parameter | SchemaBase | Map | StrokeCap_T] = Undefined, strokeDash: Optional[ @@ -118,7 +119,7 @@ def mark_arc( timeUnitBandPosition: Optional[float] = Undefined, timeUnitBandSize: Optional[float] = Undefined, tooltip: Optional[ - str | bool | None | float | Parameter | SchemaBase | Map + str | bool | float | Parameter | SchemaBase | Map | None ] = Undefined, url: Optional[str | Parameter | SchemaBase | Map] = Undefined, width: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -272,7 +273,7 @@ def mark_area( dy: Optional[float | Parameter | SchemaBase | Map] = Undefined, ellipsis: Optional[str | Parameter | SchemaBase | Map] = Undefined, fill: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, fillOpacity: Optional[float | Parameter | SchemaBase | Map] = Undefined, filled: Optional[bool] = Undefined, @@ -284,7 +285,7 @@ def mark_area( href: Optional[str | Parameter | SchemaBase | Map] = Undefined, innerRadius: Optional[float | Parameter | SchemaBase | Map] = Undefined, interpolate: Optional[Parameter | SchemaBase | Map | Interpolate_T] = Undefined, - invalid: Optional[None | SchemaBase | MarkInvalidDataMode_T] = Undefined, + invalid: Optional[SchemaBase | MarkInvalidDataMode_T | None] = Undefined, limit: Optional[float | Parameter | SchemaBase | Map] = Undefined, line: Optional[bool | SchemaBase | Map] = Undefined, lineBreak: Optional[str | Parameter | SchemaBase | Map] = Undefined, @@ -304,7 +305,7 @@ def mark_area( size: Optional[float | Parameter | SchemaBase | Map] = Undefined, smooth: Optional[bool | Parameter | SchemaBase | Map] = Undefined, stroke: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, strokeCap: Optional[Parameter | SchemaBase | Map | StrokeCap_T] = Undefined, strokeDash: Optional[ @@ -327,7 +328,7 @@ def mark_area( timeUnitBandPosition: Optional[float] = Undefined, timeUnitBandSize: Optional[float] = Undefined, tooltip: Optional[ - str | bool | None | float | Parameter | SchemaBase | Map + str | bool | float | Parameter | SchemaBase | Map | None ] = Undefined, url: Optional[str | Parameter | SchemaBase | Map] = Undefined, width: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -481,7 +482,7 @@ def mark_bar( dy: Optional[float | Parameter | SchemaBase | Map] = Undefined, ellipsis: Optional[str | Parameter | SchemaBase | Map] = Undefined, fill: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, fillOpacity: Optional[float | Parameter | SchemaBase | Map] = Undefined, filled: Optional[bool] = Undefined, @@ -493,7 +494,7 @@ def mark_bar( href: Optional[str | Parameter | SchemaBase | Map] = Undefined, innerRadius: Optional[float | Parameter | SchemaBase | Map] = Undefined, interpolate: Optional[Parameter | SchemaBase | Map | Interpolate_T] = Undefined, - invalid: Optional[None | SchemaBase | MarkInvalidDataMode_T] = Undefined, + invalid: Optional[SchemaBase | MarkInvalidDataMode_T | None] = Undefined, limit: Optional[float | Parameter | SchemaBase | Map] = Undefined, line: Optional[bool | SchemaBase | Map] = Undefined, lineBreak: Optional[str | Parameter | SchemaBase | Map] = Undefined, @@ -513,7 +514,7 @@ def mark_bar( size: Optional[float | Parameter | SchemaBase | Map] = Undefined, smooth: Optional[bool | Parameter | SchemaBase | Map] = Undefined, stroke: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, strokeCap: Optional[Parameter | SchemaBase | Map | StrokeCap_T] = Undefined, strokeDash: Optional[ @@ -536,7 +537,7 @@ def mark_bar( timeUnitBandPosition: Optional[float] = Undefined, timeUnitBandSize: Optional[float] = Undefined, tooltip: Optional[ - str | bool | None | float | Parameter | SchemaBase | Map + str | bool | float | Parameter | SchemaBase | Map | None ] = Undefined, url: Optional[str | Parameter | SchemaBase | Map] = Undefined, width: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -690,7 +691,7 @@ def mark_image( dy: Optional[float | Parameter | SchemaBase | Map] = Undefined, ellipsis: Optional[str | Parameter | SchemaBase | Map] = Undefined, fill: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, fillOpacity: Optional[float | Parameter | SchemaBase | Map] = Undefined, filled: Optional[bool] = Undefined, @@ -702,7 +703,7 @@ def mark_image( href: Optional[str | Parameter | SchemaBase | Map] = Undefined, innerRadius: Optional[float | Parameter | SchemaBase | Map] = Undefined, interpolate: Optional[Parameter | SchemaBase | Map | Interpolate_T] = Undefined, - invalid: Optional[None | SchemaBase | MarkInvalidDataMode_T] = Undefined, + invalid: Optional[SchemaBase | MarkInvalidDataMode_T | None] = Undefined, limit: Optional[float | Parameter | SchemaBase | Map] = Undefined, line: Optional[bool | SchemaBase | Map] = Undefined, lineBreak: Optional[str | Parameter | SchemaBase | Map] = Undefined, @@ -722,7 +723,7 @@ def mark_image( size: Optional[float | Parameter | SchemaBase | Map] = Undefined, smooth: Optional[bool | Parameter | SchemaBase | Map] = Undefined, stroke: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, strokeCap: Optional[Parameter | SchemaBase | Map | StrokeCap_T] = Undefined, strokeDash: Optional[ @@ -745,7 +746,7 @@ def mark_image( timeUnitBandPosition: Optional[float] = Undefined, timeUnitBandSize: Optional[float] = Undefined, tooltip: Optional[ - str | bool | None | float | Parameter | SchemaBase | Map + str | bool | float | Parameter | SchemaBase | Map | None ] = Undefined, url: Optional[str | Parameter | SchemaBase | Map] = Undefined, width: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -899,7 +900,7 @@ def mark_line( dy: Optional[float | Parameter | SchemaBase | Map] = Undefined, ellipsis: Optional[str | Parameter | SchemaBase | Map] = Undefined, fill: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, fillOpacity: Optional[float | Parameter | SchemaBase | Map] = Undefined, filled: Optional[bool] = Undefined, @@ -911,7 +912,7 @@ def mark_line( href: Optional[str | Parameter | SchemaBase | Map] = Undefined, innerRadius: Optional[float | Parameter | SchemaBase | Map] = Undefined, interpolate: Optional[Parameter | SchemaBase | Map | Interpolate_T] = Undefined, - invalid: Optional[None | SchemaBase | MarkInvalidDataMode_T] = Undefined, + invalid: Optional[SchemaBase | MarkInvalidDataMode_T | None] = Undefined, limit: Optional[float | Parameter | SchemaBase | Map] = Undefined, line: Optional[bool | SchemaBase | Map] = Undefined, lineBreak: Optional[str | Parameter | SchemaBase | Map] = Undefined, @@ -931,7 +932,7 @@ def mark_line( size: Optional[float | Parameter | SchemaBase | Map] = Undefined, smooth: Optional[bool | Parameter | SchemaBase | Map] = Undefined, stroke: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, strokeCap: Optional[Parameter | SchemaBase | Map | StrokeCap_T] = Undefined, strokeDash: Optional[ @@ -954,7 +955,7 @@ def mark_line( timeUnitBandPosition: Optional[float] = Undefined, timeUnitBandSize: Optional[float] = Undefined, tooltip: Optional[ - str | bool | None | float | Parameter | SchemaBase | Map + str | bool | float | Parameter | SchemaBase | Map | None ] = Undefined, url: Optional[str | Parameter | SchemaBase | Map] = Undefined, width: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -1108,7 +1109,7 @@ def mark_point( dy: Optional[float | Parameter | SchemaBase | Map] = Undefined, ellipsis: Optional[str | Parameter | SchemaBase | Map] = Undefined, fill: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, fillOpacity: Optional[float | Parameter | SchemaBase | Map] = Undefined, filled: Optional[bool] = Undefined, @@ -1120,7 +1121,7 @@ def mark_point( href: Optional[str | Parameter | SchemaBase | Map] = Undefined, innerRadius: Optional[float | Parameter | SchemaBase | Map] = Undefined, interpolate: Optional[Parameter | SchemaBase | Map | Interpolate_T] = Undefined, - invalid: Optional[None | SchemaBase | MarkInvalidDataMode_T] = Undefined, + invalid: Optional[SchemaBase | MarkInvalidDataMode_T | None] = Undefined, limit: Optional[float | Parameter | SchemaBase | Map] = Undefined, line: Optional[bool | SchemaBase | Map] = Undefined, lineBreak: Optional[str | Parameter | SchemaBase | Map] = Undefined, @@ -1140,7 +1141,7 @@ def mark_point( size: Optional[float | Parameter | SchemaBase | Map] = Undefined, smooth: Optional[bool | Parameter | SchemaBase | Map] = Undefined, stroke: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, strokeCap: Optional[Parameter | SchemaBase | Map | StrokeCap_T] = Undefined, strokeDash: Optional[ @@ -1163,7 +1164,7 @@ def mark_point( timeUnitBandPosition: Optional[float] = Undefined, timeUnitBandSize: Optional[float] = Undefined, tooltip: Optional[ - str | bool | None | float | Parameter | SchemaBase | Map + str | bool | float | Parameter | SchemaBase | Map | None ] = Undefined, url: Optional[str | Parameter | SchemaBase | Map] = Undefined, width: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -1317,7 +1318,7 @@ def mark_rect( dy: Optional[float | Parameter | SchemaBase | Map] = Undefined, ellipsis: Optional[str | Parameter | SchemaBase | Map] = Undefined, fill: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, fillOpacity: Optional[float | Parameter | SchemaBase | Map] = Undefined, filled: Optional[bool] = Undefined, @@ -1329,7 +1330,7 @@ def mark_rect( href: Optional[str | Parameter | SchemaBase | Map] = Undefined, innerRadius: Optional[float | Parameter | SchemaBase | Map] = Undefined, interpolate: Optional[Parameter | SchemaBase | Map | Interpolate_T] = Undefined, - invalid: Optional[None | SchemaBase | MarkInvalidDataMode_T] = Undefined, + invalid: Optional[SchemaBase | MarkInvalidDataMode_T | None] = Undefined, limit: Optional[float | Parameter | SchemaBase | Map] = Undefined, line: Optional[bool | SchemaBase | Map] = Undefined, lineBreak: Optional[str | Parameter | SchemaBase | Map] = Undefined, @@ -1349,7 +1350,7 @@ def mark_rect( size: Optional[float | Parameter | SchemaBase | Map] = Undefined, smooth: Optional[bool | Parameter | SchemaBase | Map] = Undefined, stroke: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, strokeCap: Optional[Parameter | SchemaBase | Map | StrokeCap_T] = Undefined, strokeDash: Optional[ @@ -1372,7 +1373,7 @@ def mark_rect( timeUnitBandPosition: Optional[float] = Undefined, timeUnitBandSize: Optional[float] = Undefined, tooltip: Optional[ - str | bool | None | float | Parameter | SchemaBase | Map + str | bool | float | Parameter | SchemaBase | Map | None ] = Undefined, url: Optional[str | Parameter | SchemaBase | Map] = Undefined, width: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -1526,7 +1527,7 @@ def mark_rule( dy: Optional[float | Parameter | SchemaBase | Map] = Undefined, ellipsis: Optional[str | Parameter | SchemaBase | Map] = Undefined, fill: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, fillOpacity: Optional[float | Parameter | SchemaBase | Map] = Undefined, filled: Optional[bool] = Undefined, @@ -1538,7 +1539,7 @@ def mark_rule( href: Optional[str | Parameter | SchemaBase | Map] = Undefined, innerRadius: Optional[float | Parameter | SchemaBase | Map] = Undefined, interpolate: Optional[Parameter | SchemaBase | Map | Interpolate_T] = Undefined, - invalid: Optional[None | SchemaBase | MarkInvalidDataMode_T] = Undefined, + invalid: Optional[SchemaBase | MarkInvalidDataMode_T | None] = Undefined, limit: Optional[float | Parameter | SchemaBase | Map] = Undefined, line: Optional[bool | SchemaBase | Map] = Undefined, lineBreak: Optional[str | Parameter | SchemaBase | Map] = Undefined, @@ -1558,7 +1559,7 @@ def mark_rule( size: Optional[float | Parameter | SchemaBase | Map] = Undefined, smooth: Optional[bool | Parameter | SchemaBase | Map] = Undefined, stroke: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, strokeCap: Optional[Parameter | SchemaBase | Map | StrokeCap_T] = Undefined, strokeDash: Optional[ @@ -1581,7 +1582,7 @@ def mark_rule( timeUnitBandPosition: Optional[float] = Undefined, timeUnitBandSize: Optional[float] = Undefined, tooltip: Optional[ - str | bool | None | float | Parameter | SchemaBase | Map + str | bool | float | Parameter | SchemaBase | Map | None ] = Undefined, url: Optional[str | Parameter | SchemaBase | Map] = Undefined, width: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -1735,7 +1736,7 @@ def mark_text( dy: Optional[float | Parameter | SchemaBase | Map] = Undefined, ellipsis: Optional[str | Parameter | SchemaBase | Map] = Undefined, fill: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, fillOpacity: Optional[float | Parameter | SchemaBase | Map] = Undefined, filled: Optional[bool] = Undefined, @@ -1747,7 +1748,7 @@ def mark_text( href: Optional[str | Parameter | SchemaBase | Map] = Undefined, innerRadius: Optional[float | Parameter | SchemaBase | Map] = Undefined, interpolate: Optional[Parameter | SchemaBase | Map | Interpolate_T] = Undefined, - invalid: Optional[None | SchemaBase | MarkInvalidDataMode_T] = Undefined, + invalid: Optional[SchemaBase | MarkInvalidDataMode_T | None] = Undefined, limit: Optional[float | Parameter | SchemaBase | Map] = Undefined, line: Optional[bool | SchemaBase | Map] = Undefined, lineBreak: Optional[str | Parameter | SchemaBase | Map] = Undefined, @@ -1767,7 +1768,7 @@ def mark_text( size: Optional[float | Parameter | SchemaBase | Map] = Undefined, smooth: Optional[bool | Parameter | SchemaBase | Map] = Undefined, stroke: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, strokeCap: Optional[Parameter | SchemaBase | Map | StrokeCap_T] = Undefined, strokeDash: Optional[ @@ -1790,7 +1791,7 @@ def mark_text( timeUnitBandPosition: Optional[float] = Undefined, timeUnitBandSize: Optional[float] = Undefined, tooltip: Optional[ - str | bool | None | float | Parameter | SchemaBase | Map + str | bool | float | Parameter | SchemaBase | Map | None ] = Undefined, url: Optional[str | Parameter | SchemaBase | Map] = Undefined, width: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -1944,7 +1945,7 @@ def mark_tick( dy: Optional[float | Parameter | SchemaBase | Map] = Undefined, ellipsis: Optional[str | Parameter | SchemaBase | Map] = Undefined, fill: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, fillOpacity: Optional[float | Parameter | SchemaBase | Map] = Undefined, filled: Optional[bool] = Undefined, @@ -1956,7 +1957,7 @@ def mark_tick( href: Optional[str | Parameter | SchemaBase | Map] = Undefined, innerRadius: Optional[float | Parameter | SchemaBase | Map] = Undefined, interpolate: Optional[Parameter | SchemaBase | Map | Interpolate_T] = Undefined, - invalid: Optional[None | SchemaBase | MarkInvalidDataMode_T] = Undefined, + invalid: Optional[SchemaBase | MarkInvalidDataMode_T | None] = Undefined, limit: Optional[float | Parameter | SchemaBase | Map] = Undefined, line: Optional[bool | SchemaBase | Map] = Undefined, lineBreak: Optional[str | Parameter | SchemaBase | Map] = Undefined, @@ -1976,7 +1977,7 @@ def mark_tick( size: Optional[float | Parameter | SchemaBase | Map] = Undefined, smooth: Optional[bool | Parameter | SchemaBase | Map] = Undefined, stroke: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, strokeCap: Optional[Parameter | SchemaBase | Map | StrokeCap_T] = Undefined, strokeDash: Optional[ @@ -1999,7 +2000,7 @@ def mark_tick( timeUnitBandPosition: Optional[float] = Undefined, timeUnitBandSize: Optional[float] = Undefined, tooltip: Optional[ - str | bool | None | float | Parameter | SchemaBase | Map + str | bool | float | Parameter | SchemaBase | Map | None ] = Undefined, url: Optional[str | Parameter | SchemaBase | Map] = Undefined, width: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -2153,7 +2154,7 @@ def mark_trail( dy: Optional[float | Parameter | SchemaBase | Map] = Undefined, ellipsis: Optional[str | Parameter | SchemaBase | Map] = Undefined, fill: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, fillOpacity: Optional[float | Parameter | SchemaBase | Map] = Undefined, filled: Optional[bool] = Undefined, @@ -2165,7 +2166,7 @@ def mark_trail( href: Optional[str | Parameter | SchemaBase | Map] = Undefined, innerRadius: Optional[float | Parameter | SchemaBase | Map] = Undefined, interpolate: Optional[Parameter | SchemaBase | Map | Interpolate_T] = Undefined, - invalid: Optional[None | SchemaBase | MarkInvalidDataMode_T] = Undefined, + invalid: Optional[SchemaBase | MarkInvalidDataMode_T | None] = Undefined, limit: Optional[float | Parameter | SchemaBase | Map] = Undefined, line: Optional[bool | SchemaBase | Map] = Undefined, lineBreak: Optional[str | Parameter | SchemaBase | Map] = Undefined, @@ -2185,7 +2186,7 @@ def mark_trail( size: Optional[float | Parameter | SchemaBase | Map] = Undefined, smooth: Optional[bool | Parameter | SchemaBase | Map] = Undefined, stroke: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, strokeCap: Optional[Parameter | SchemaBase | Map | StrokeCap_T] = Undefined, strokeDash: Optional[ @@ -2208,7 +2209,7 @@ def mark_trail( timeUnitBandPosition: Optional[float] = Undefined, timeUnitBandSize: Optional[float] = Undefined, tooltip: Optional[ - str | bool | None | float | Parameter | SchemaBase | Map + str | bool | float | Parameter | SchemaBase | Map | None ] = Undefined, url: Optional[str | Parameter | SchemaBase | Map] = Undefined, width: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -2362,7 +2363,7 @@ def mark_circle( dy: Optional[float | Parameter | SchemaBase | Map] = Undefined, ellipsis: Optional[str | Parameter | SchemaBase | Map] = Undefined, fill: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, fillOpacity: Optional[float | Parameter | SchemaBase | Map] = Undefined, filled: Optional[bool] = Undefined, @@ -2374,7 +2375,7 @@ def mark_circle( href: Optional[str | Parameter | SchemaBase | Map] = Undefined, innerRadius: Optional[float | Parameter | SchemaBase | Map] = Undefined, interpolate: Optional[Parameter | SchemaBase | Map | Interpolate_T] = Undefined, - invalid: Optional[None | SchemaBase | MarkInvalidDataMode_T] = Undefined, + invalid: Optional[SchemaBase | MarkInvalidDataMode_T | None] = Undefined, limit: Optional[float | Parameter | SchemaBase | Map] = Undefined, line: Optional[bool | SchemaBase | Map] = Undefined, lineBreak: Optional[str | Parameter | SchemaBase | Map] = Undefined, @@ -2394,7 +2395,7 @@ def mark_circle( size: Optional[float | Parameter | SchemaBase | Map] = Undefined, smooth: Optional[bool | Parameter | SchemaBase | Map] = Undefined, stroke: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, strokeCap: Optional[Parameter | SchemaBase | Map | StrokeCap_T] = Undefined, strokeDash: Optional[ @@ -2417,7 +2418,7 @@ def mark_circle( timeUnitBandPosition: Optional[float] = Undefined, timeUnitBandSize: Optional[float] = Undefined, tooltip: Optional[ - str | bool | None | float | Parameter | SchemaBase | Map + str | bool | float | Parameter | SchemaBase | Map | None ] = Undefined, url: Optional[str | Parameter | SchemaBase | Map] = Undefined, width: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -2571,7 +2572,7 @@ def mark_square( dy: Optional[float | Parameter | SchemaBase | Map] = Undefined, ellipsis: Optional[str | Parameter | SchemaBase | Map] = Undefined, fill: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, fillOpacity: Optional[float | Parameter | SchemaBase | Map] = Undefined, filled: Optional[bool] = Undefined, @@ -2583,7 +2584,7 @@ def mark_square( href: Optional[str | Parameter | SchemaBase | Map] = Undefined, innerRadius: Optional[float | Parameter | SchemaBase | Map] = Undefined, interpolate: Optional[Parameter | SchemaBase | Map | Interpolate_T] = Undefined, - invalid: Optional[None | SchemaBase | MarkInvalidDataMode_T] = Undefined, + invalid: Optional[SchemaBase | MarkInvalidDataMode_T | None] = Undefined, limit: Optional[float | Parameter | SchemaBase | Map] = Undefined, line: Optional[bool | SchemaBase | Map] = Undefined, lineBreak: Optional[str | Parameter | SchemaBase | Map] = Undefined, @@ -2603,7 +2604,7 @@ def mark_square( size: Optional[float | Parameter | SchemaBase | Map] = Undefined, smooth: Optional[bool | Parameter | SchemaBase | Map] = Undefined, stroke: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, strokeCap: Optional[Parameter | SchemaBase | Map | StrokeCap_T] = Undefined, strokeDash: Optional[ @@ -2626,7 +2627,7 @@ def mark_square( timeUnitBandPosition: Optional[float] = Undefined, timeUnitBandSize: Optional[float] = Undefined, tooltip: Optional[ - str | bool | None | float | Parameter | SchemaBase | Map + str | bool | float | Parameter | SchemaBase | Map | None ] = Undefined, url: Optional[str | Parameter | SchemaBase | Map] = Undefined, width: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -2780,7 +2781,7 @@ def mark_geoshape( dy: Optional[float | Parameter | SchemaBase | Map] = Undefined, ellipsis: Optional[str | Parameter | SchemaBase | Map] = Undefined, fill: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, fillOpacity: Optional[float | Parameter | SchemaBase | Map] = Undefined, filled: Optional[bool] = Undefined, @@ -2792,7 +2793,7 @@ def mark_geoshape( href: Optional[str | Parameter | SchemaBase | Map] = Undefined, innerRadius: Optional[float | Parameter | SchemaBase | Map] = Undefined, interpolate: Optional[Parameter | SchemaBase | Map | Interpolate_T] = Undefined, - invalid: Optional[None | SchemaBase | MarkInvalidDataMode_T] = Undefined, + invalid: Optional[SchemaBase | MarkInvalidDataMode_T | None] = Undefined, limit: Optional[float | Parameter | SchemaBase | Map] = Undefined, line: Optional[bool | SchemaBase | Map] = Undefined, lineBreak: Optional[str | Parameter | SchemaBase | Map] = Undefined, @@ -2812,7 +2813,7 @@ def mark_geoshape( size: Optional[float | Parameter | SchemaBase | Map] = Undefined, smooth: Optional[bool | Parameter | SchemaBase | Map] = Undefined, stroke: Optional[ - str | None | Parameter | SchemaBase | Map | ColorName_T + str | Parameter | SchemaBase | Map | ColorName_T | None ] = Undefined, strokeCap: Optional[Parameter | SchemaBase | Map | StrokeCap_T] = Undefined, strokeDash: Optional[ @@ -2835,7 +2836,7 @@ def mark_geoshape( timeUnitBandPosition: Optional[float] = Undefined, timeUnitBandSize: Optional[float] = Undefined, tooltip: Optional[ - str | bool | None | float | Parameter | SchemaBase | Map + str | bool | float | Parameter | SchemaBase | Map | None ] = Undefined, url: Optional[str | Parameter | SchemaBase | Map] = Undefined, width: Optional[float | Parameter | SchemaBase | Map] = Undefined, @@ -2960,7 +2961,7 @@ def mark_boxplot( clip: Optional[bool] = Undefined, color: Optional[str | Parameter | SchemaBase | Map | ColorName_T] = Undefined, extent: Optional[float | Literal["min-max"]] = Undefined, - invalid: Optional[None | SchemaBase | MarkInvalidDataMode_T] = Undefined, + invalid: Optional[SchemaBase | MarkInvalidDataMode_T | None] = Undefined, median: Optional[bool | SchemaBase | Map] = Undefined, opacity: Optional[float] = Undefined, orient: Optional[SchemaBase | Orientation_T] = Undefined, diff --git a/doc/conf.py b/doc/conf.py index 3e210a3fa..a01b6b85d 100644 --- a/doc/conf.py +++ b/doc/conf.py @@ -39,6 +39,7 @@ "sphinxext_altair.altairplot", "sphinxext.altairgallery", "sphinxext.schematable", + "sphinxext.code_ref", "sphinx_copybutton", "sphinx_design", ] diff --git a/doc/getting_started/installation.rst b/doc/getting_started/installation.rst index 27a5220b9..3d9b30e31 100644 --- a/doc/getting_started/installation.rst +++ b/doc/getting_started/installation.rst @@ -24,6 +24,12 @@ and non-notebook IDEs, see :ref:`displaying-charts`. If you wish to install Altair with only the required dependencies, you can omit the ``[all]``/``-all`` suffix. +Altair can also be installed with just the dependencies necessary for saving charts to offline HTML files or PNG/SVG/PDF formats, using: + +.. code-block:: bash + + pip install "altair[save]" + Development Installation ======================== diff --git a/doc/user_guide/customization.rst b/doc/user_guide/customization.rst index c068d62e3..b95ac1c35 100644 --- a/doc/user_guide/customization.rst +++ b/doc/user_guide/customization.rst @@ -624,32 +624,7 @@ But since ``mark_bar(size=10)`` only controls the width of the bars, it might be y='value:Q' ) -The width of the chart containing the bar plot can be controlled through setting the ``width`` -property of the chart, either to a pixel value for any chart, or to a step value -in the case of discrete scales. - -Here is an example of setting the width to a single value for the whole chart: - -.. altair-plot:: - - alt.Chart(data).mark_bar(size=30).encode( - x='name:O', - y='value:Q' - ).properties(width=200) - -The width of the bars are set using ``mark_bar(size=30)`` and the width of the chart is set using ``properties(width=100)`` - -Here is an example of setting the step width for a discrete scale: - -.. altair-plot:: - - alt.Chart(data).mark_bar(size=30).encode( - x='name:N', - y='value:Q' - ).properties(width=alt.Step(100)) - -The width of the bars are set using ``mark_bar(size=30)`` and the width that is allocated for each bar bar in the chart is set using ``width=alt.Step(100)`` - +Therefore, it is often preferred to set the width of the entire chart relative to the number of distinct categories using :class:`Step`, which you can can see an example of a few charts down. .. _customization-chart-size: @@ -662,9 +637,9 @@ For example: import altair as alt from vega_datasets import data - + cars = data.cars() - + alt.Chart(cars).mark_bar().encode( x='Origin', y='count()' @@ -685,8 +660,26 @@ the subchart rather than to the overall chart: ).properties( width=100, height=100 + ).resolve_scale( + x='independent' ) +To change the chart size relative to the number of distinct categories, you can use the :class:`Step` class to specify the width/height for each category rather than for the entire chart: + +.. altair-plot:: + + alt.Chart(cars).mark_bar().encode( + x='Origin', + y='count()', + column='Cylinders:Q' + ).properties( + width=alt.Step(35), + height=100 + ).resolve_scale( + x='independent' + ) + + If you want your chart size to respond to the width of the HTML page or container in which it is rendered, you can set ``width`` or ``height`` to the string ``"container"``: @@ -787,10 +780,16 @@ If you would like to use any theme just for a single chart, you can use the with alt.themes.enable('default'): spec = chart.to_json() +Built-in Themes +~~~~~~~~~~~~~~~ Currently Altair does not offer many built-in themes, but we plan to add more options in the future. -See `Vega Theme Test`_ for an interactive demo of themes inherited from `Vega Themes`_. +You can get a feel for the themes inherited from `Vega Themes`_ via *Vega-Altair Theme Test* below: + +.. altair-theme:: tests.altair_theme_test.alt_theme_test + :fold: + :summary: Show Vega-Altair Theme Test Defining a Custom Theme ~~~~~~~~~~~~~~~~~~~~~~~ @@ -843,6 +842,13 @@ If you want to restore the default theme, use: alt.themes.enable('default') +When experimenting with your theme, you can use the code below to see how +it translates across a range of charts/marks: + +.. altair-code-ref:: tests.altair_theme_test.alt_theme_test + :fold: + :summary: Show Vega-Altair Theme Test code + For more ideas on themes, see the `Vega Themes`_ repository. @@ -890,4 +896,3 @@ The configured localization settings persist upon saving. .. _Vega Themes: https://github.com/vega/vega-themes/ .. _`D3's localization support`: https://d3-wiki.readthedocs.io/zh-cn/master/Localization/ -.. _Vega Theme Test: https://vega.github.io/vega-themes/?renderer=canvas \ No newline at end of file diff --git a/doc/user_guide/saving_charts.rst b/doc/user_guide/saving_charts.rst index d0b5798b8..b9c6b18ae 100644 --- a/doc/user_guide/saving_charts.rst +++ b/doc/user_guide/saving_charts.rst @@ -157,7 +157,7 @@ As an alternative, the ``inline=True`` keyword argument may be provided to ``cha .. note:: - Calling ``chart.save`` with ``inline=True`` requires the :ref:`install-vl-convert` package. + Calling ``chart.save`` with ``inline=True`` requires :ref:`additional-dependencies`. .. _saving-png: @@ -172,25 +172,11 @@ To save an Altair chart object as a PNG, SVG, or PDF image, you can use chart.save('chart.svg') chart.save('chart.pdf') -Saving these images requires an additional extension vl-convert_ to run the -javascript code necessary to interpret the Vega-Lite specification and output -it in the form of an image. - -.. _install-vl-convert: - -vl-convert -^^^^^^^^^^ -The vl-convert_ package can be installed with:: - - conda install -c conda-forge vl-convert-python - -or:: +.. note:: - pip install vl-convert-python + :ref:`additional-dependencies` are required to save charts as images by running the javascript + code necessary to interpret the Vega-Lite specification and output it in the form of an image. -vl-convert_ does not require any external dependencies. -See the vl-convert documentation for information and for known -`limitations `_. altair_saver ^^^^^^^^^^^^ @@ -216,6 +202,22 @@ size at the default resolution of 72 ppi:: chart.save('chart.png', scale_factor=2) +.. _additional-dependencies: + +Additional Dependencies +~~~~~~~~~~~~~~~~~~~~~~~ +Saving charts to images or offline HTML files requires the vl-convert_ package:: + + conda install -c conda-forge vl-convert-python + +or:: + + pip install vl-convert-python + +vl-convert_ does not require any external dependencies. +See the vl-convert documentation for information and for known +`limitations `_. + Sharable URL ~~~~~~~~~~~~ The :meth:`Chart.to_url` method can be used to build a sharable URL that opens the chart @@ -237,4 +239,4 @@ specification in the online Vega editor_. .. _vl-convert: https://github.com/vega/vl-convert .. _vegaEmbed: https://github.com/vega/vega-embed -.. _editor: https://vega.github.io/editor/ \ No newline at end of file +.. _editor: https://vega.github.io/editor/ diff --git a/pyproject.toml b/pyproject.toml index f01a562bd..21c1a1342 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -32,7 +32,7 @@ keywords = [ "json", "vega-lite", ] -requires-python = ">=3.8" +requires-python = ">=3.9" dynamic = ["version"] license-files = { paths = ["LICENSE"] } classifiers = [ @@ -41,7 +41,6 @@ classifiers = [ "Intended Audience :: Science/Research", "License :: OSI Approved :: BSD License", "Natural Language :: English", - "Programming Language :: Python :: 3.8", "Programming Language :: Python :: 3.9", "Programming Language :: Python :: 3.10", "Programming Language :: Python :: 3.11", @@ -54,13 +53,16 @@ Documentation = "https://altair-viz.github.io" Source = "https://github.com/vega/altair" [project.optional-dependencies] +save = [ + "vl-convert-python>=1.7.0", +] all = [ + "altair[save]", "vega_datasets>=0.9.0", - "vl-convert-python>=1.7.0", - "pandas>=0.25.3", + "pandas>=1.1.3", "numpy", "pyarrow>=11", - "vegafusion[embed]>=1.6.6", + "vegafusion[embed]>=1.6.6,<2", "anywidget>=0.9.0", "altair_tiles>=0.3.0" ] @@ -69,7 +71,7 @@ dev = [ "ruff>=0.6.0", "ibis-framework[polars]", "ipython[kernel]", - "pandas>=0.25.3", + "pandas>=1.1.3", "pytest", "pytest-cov", "pytest-xdist[psutil]~=3.5", @@ -120,7 +122,7 @@ test = [ "ruff check .", "ruff format --diff --check .", "mypy altair tests", - "python -m pytest --pyargs --numprocesses=logical --doctest-modules tests altair", + "python -m pytest --pyargs --numprocesses=logical --doctest-modules tests altair tools", ] test-coverage = "python -m pytest --pyargs --doctest-modules --cov=altair --cov-report term altair" test-coverage-html = "python -m pytest --pyargs --doctest-modules --cov=altair --cov-report html altair" @@ -131,21 +133,21 @@ update-init-file = [ ] test-fast = [ "ruff check .", "ruff format .", - "pytest -p no:randomly -n logical --numprocesses=logical --doctest-modules tests altair -m \"not slow\" {args}" + "pytest -p no:randomly -n logical --numprocesses=logical --doctest-modules tests altair tools -m \"not slow\" {args}" ] test-slow = [ "ruff check .", "ruff format .", - "pytest -p no:randomly -n logical --numprocesses=logical --doctest-modules tests altair -m \"slow\" {args}" + "pytest -p no:randomly -n logical --numprocesses=logical --doctest-modules tests altair tools -m \"slow\" {args}" ] [tool.hatch.envs.hatch-test] # https://hatch.pypa.io/latest/tutorials/testing/overview/ features = ["all", "dev", "doc"] # https://pytest-xdist.readthedocs.io/en/latest/distribution.html#running-tests-across-multiple-cpus -default-args = ["--numprocesses=logical","--doctest-modules", "tests", "altair"] +default-args = ["--numprocesses=logical","--doctest-modules", "tests", "altair", "tools"] parallel = true [[tool.hatch.envs.hatch-test.matrix]] -python = ["3.8", "3.9", "3.10", "3.11", "3.12"] +python = ["3.9", "3.10", "3.11", "3.12"] [tool.hatch.envs.hatch-test.scripts] run = [ "ruff check .", @@ -192,7 +194,7 @@ publish-clean-build = [ ] [tool.ruff] -target-version = "py38" +target-version = "py39" line-length = 88 indent-width = 4 exclude = [ @@ -436,9 +438,7 @@ module = [ "nbformat.*", "ipykernel.*", "ibis.*", - # This refers to schemapi in the tools folder which is imported - # by the tools scripts such as generate_schema_wrapper.py - # "schemapi.*" + "vegafusion.*", ] ignore_missing_imports = true @@ -446,7 +446,7 @@ ignore_missing_imports = true enableExperimentalFeatures=true extraPaths=["./tools"] pythonPlatform="All" -pythonVersion="3.8" +pythonVersion="3.9" reportTypedDictNotRequiredAccess="none" reportIncompatibleMethodOverride="none" reportUnusedExpression="none" diff --git a/sphinxext/code_ref.py b/sphinxext/code_ref.py new file mode 100644 index 000000000..8f5f4da0e --- /dev/null +++ b/sphinxext/code_ref.py @@ -0,0 +1,321 @@ +"""Sphinx extension providing formatted code blocks, referencing some function.""" + +from __future__ import annotations + +from typing import TYPE_CHECKING, Literal, get_args + +from docutils import nodes +from docutils.parsers.rst import directives +from sphinx.util.docutils import SphinxDirective +from sphinx.util.parsing import nested_parse_to_nodes + +from altair.vegalite.v5.schema._typing import VegaThemes +from tools.codemod import extract_func_def, extract_func_def_embed + +if TYPE_CHECKING: + import sys + from collections.abc import Iterable, Iterator, Mapping, Sequence + from typing import Any, Callable, ClassVar, TypeVar, Union + + from docutils.parsers.rst.states import RSTState, RSTStateMachine + from docutils.statemachine import StringList + from sphinx.application import Sphinx + + if sys.version_info >= (3, 12): + from typing import TypeAliasType + else: + from typing_extensions import TypeAliasType + if sys.version_info >= (3, 10): + from typing import TypeAlias + else: + from typing_extensions import TypeAlias + + T = TypeVar("T") + OneOrIter = TypeAliasType("OneOrIter", Union[T, Iterable[T]], type_params=(T,)) + +_OutputShort: TypeAlias = Literal["code", "plot"] +_OutputLong: TypeAlias = Literal["code-block", "altair-plot"] +_OUTPUT_REMAP: Mapping[_OutputShort, _OutputLong] = { + "code": "code-block", + "plot": "altair-plot", +} +_Option: TypeAlias = Literal["output", "fold", "summary"] + +_PYSCRIPT_URL_FMT = "https://pyscript.net/releases/{0}/core.js" +_PYSCRIPT_VERSION = "2024.10.1" +_PYSCRIPT_URL = _PYSCRIPT_URL_FMT.format(_PYSCRIPT_VERSION) + + +def validate_output(output: Any) -> _OutputLong: + output = output.strip().lower() + if output not in {"plot", "code"}: + msg = f":output: option must be one of {get_args(_OutputShort)!r}" + raise TypeError(msg) + else: + short: _OutputShort = output + return _OUTPUT_REMAP[short] + + +def validate_packages(packages: Any) -> str: + if packages is None: + return '["altair"]' + else: + split = [pkg.strip() for pkg in packages.split(",")] + if len(split) == 1: + return f'["{split[0]}"]' + else: + return f'[{",".join(split)}]' + + +def raw_html(text: str, /) -> nodes.raw: + return nodes.raw("", text, format="html") + + +def maybe_details( + parsed: Iterable[nodes.Node], options: dict[_Option, Any], *, default_summary: str +) -> Sequence[nodes.Node]: + """ + Wrap ``parsed`` in a folding `details`_ block if requested. + + Parameters + ---------- + parsed + Target nodes that have been processed. + options + Optional arguments provided to ``.. altair-code-ref::``. + + .. note:: + If no relevant options are specified, + ``parsed`` is returned unchanged. + + default_summary + Label text used when **only** specifying ``:fold:``. + + .. _details: + https://developer.mozilla.org/en-US/docs/Web/HTML/Element/details + """ + + def gen() -> Iterator[nodes.Node]: + if {"fold", "summary"}.isdisjoint(options.keys()): + yield from parsed + else: + summary = options.get("summary", default_summary) + yield raw_html(f"

{summary}") + yield from parsed + yield raw_html("

") + + return list(gen()) + + +def theme_names() -> tuple[Sequence[str], Sequence[str]]: + names: set[VegaThemes] = set(get_args(VegaThemes)) + carbon = {nm for nm in names if nm.startswith("carbon")} + return ["default", *sorted(names - carbon)], sorted(carbon) + + +def option(label: str, value: str | None = None, /) -> nodes.raw: + s = f"\n") + + +def optgroup(label: str, *options: OneOrIter[nodes.raw]) -> Iterator[nodes.raw]: + yield raw_html(f"\n") + for opt in options: + if isinstance(opt, nodes.raw): + yield opt + else: + yield from opt + yield raw_html("\n") + + +def dropdown( + id: str, label: str | None, extra_select: str, *options: OneOrIter[nodes.raw] +) -> Iterator[nodes.raw]: + if label: + yield raw_html(f"\n") + select_text = f"\n") + + +def pyscript( + packages: str, target_div_id: str, loading_label: str, py_code: str +) -> Iterator[nodes.raw]: + PY = "py" + LB, RB = "{", "}" + packages = f""""packages":{packages}""" + yield raw_html(f"
{loading_label}
\n") + yield raw_html(f"\n") + + +def _before_code(refresh_name: str, select_id: str, target_div_id: str) -> str: + INDENT = " " * 4 + return ( + f"from js import document\n" + f"from pyscript import display\n" + f"import altair as alt\n\n" + f"def {refresh_name}(*args):\n" + f"{INDENT}selected = document.getElementById({select_id!r}).value\n" + f"{INDENT}alt.renderers.set_embed_options(theme=selected)\n" + f"{INDENT}display(chart, append=False, target={target_div_id!r})\n" + ) + + +class ThemeDirective(SphinxDirective): + """ + Theme preview directive. + + Similar to ``CodeRefDirective``, but uses `PyScript`_ to access the browser. + + .. _PyScript: + https://pyscript.net/ + """ + + has_content: ClassVar[Literal[False]] = False + required_arguments: ClassVar[Literal[1]] = 1 + option_spec = { + "packages": validate_packages, + "dropdown-label": directives.unchanged, + "loading-label": directives.unchanged, + "fold": directives.flag, + "summary": directives.unchanged_required, + } + + def run(self) -> Sequence[nodes.Node]: + results: list[nodes.Node] = [] + SELECT_ID = "embed_theme" + REFRESH_NAME = "apply_embed_input" + TARGET_DIV_ID = "render_altair" + standard_names, carbon_names = theme_names() + + qual_name = self.arguments[0] + module_name, func_name = qual_name.rsplit(".", 1) + dropdown_label = self.options.get("dropdown-label", "Select theme:") + loading_label = self.options.get("loading-label", "loading...") + packages: str = self.options.get("packages", validate_packages(None)) + + results.append(raw_html("

\n")) + results.extend( + dropdown( + SELECT_ID, + dropdown_label, + f"py-input={REFRESH_NAME!r}", + (option(nm) for nm in standard_names), + optgroup("Carbon", (option(nm) for nm in carbon_names)), + ) + ) + py_code = extract_func_def_embed( + module_name, + func_name, + before=_before_code(REFRESH_NAME, SELECT_ID, TARGET_DIV_ID), + after=f"{REFRESH_NAME}()", + assign_to="chart", + indent=4, + ) + results.extend( + pyscript(packages, TARGET_DIV_ID, loading_label, py_code=py_code) + ) + results.append(raw_html("

\n")) + return maybe_details( + results, self.options, default_summary="Show Vega-Altair Theme Test" + ) + + +class PyScriptDirective(SphinxDirective): + """Placeholder for non-theme related directive.""" + + has_content: ClassVar[Literal[False]] = False + option_spec = {"packages": directives.unchanged} + + def run(self) -> Sequence[nodes.Node]: + raise NotImplementedError + + +class CodeRefDirective(SphinxDirective): + """ + Formatted code block, referencing the contents of a function definition. + + Options: + + .. altair-code-ref:: + :output: [code, plot] + :fold: flag + :summary: str + + Examples + -------- + Reference a function, generating a code block: + + .. altair-code-ref:: package.module.function + + Wrap the code block in a collapsible `details`_ tag: + + .. altair-code-ref:: package.module.function + :fold: + + Override default ``"Show code"`` `details`_ summary: + + .. altair-code-ref:: package.module.function + :fold: + :summary: Look here! + + Use `altair-plot`_ instead of a code block: + + .. altair-code-ref:: package.module.function + :output: plot + + .. note:: + Using `altair-plot`_ currently ignores the other options. + + .. _details: + https://developer.mozilla.org/en-US/docs/Web/HTML/Element/details + .. _altair-plot: + https://github.com/vega/sphinxext-altair + """ + + has_content: ClassVar[Literal[False]] = False + required_arguments: ClassVar[Literal[1]] = 1 + option_spec: ClassVar[dict[_Option, Callable[[str], Any]]] = { + "output": validate_output, + "fold": directives.flag, + "summary": directives.unchanged_required, + } + + def __init__( + self, + name: str, + arguments: list[str], + options: dict[_Option, Any], + content: StringList, + lineno: int, + content_offset: int, + block_text: str, + state: RSTState, + state_machine: RSTStateMachine, + ) -> None: + super().__init__(name, arguments, options, content, lineno, content_offset, block_text, state, state_machine) # fmt: skip + self.options: dict[_Option, Any] + + def run(self) -> Sequence[nodes.Node]: + qual_name = self.arguments[0] + module_name, func_name = qual_name.rsplit(".", 1) + output: _OutputLong = self.options.get("output", "code-block") + content = extract_func_def(module_name, func_name, output=output) + parsed = nested_parse_to_nodes(self.state, content) + return maybe_details(parsed, self.options, default_summary="Show code") + + +def setup(app: Sphinx) -> None: + app.add_directive_to_domain("py", "altair-code-ref", CodeRefDirective) + app.add_js_file(_PYSCRIPT_URL, loading_method="defer", type="module") + # app.add_directive("altair-pyscript", PyScriptDirective) + app.add_directive("altair-theme", ThemeDirective) diff --git a/sphinxext/schematable.py b/sphinxext/schematable.py index f27622fb8..5daaba4c5 100644 --- a/sphinxext/schematable.py +++ b/sphinxext/schematable.py @@ -3,7 +3,7 @@ import importlib import re import warnings -from typing import Any, Iterator, Sequence +from typing import TYPE_CHECKING, Any from docutils import frontend, nodes, utils from docutils.parsers.rst import Directive @@ -13,6 +13,9 @@ from tools.schemapi.utils import SchemaInfo, fix_docstring_issues +if TYPE_CHECKING: + from collections.abc import Iterator, Sequence + def type_description(schema: dict[str, Any]) -> str: """Return a concise type description for the given schema.""" diff --git a/tests/__init__.py b/tests/__init__.py index e3cd9b6c1..de79de20b 100644 --- a/tests/__init__.py +++ b/tests/__init__.py @@ -11,8 +11,8 @@ if TYPE_CHECKING: import sys + from collections.abc import Collection, Iterator, Mapping from re import Pattern - from typing import Collection, Iterator, Mapping if sys.version_info >= (3, 11): from typing import TypeAlias diff --git a/tests/altair_theme_test.py b/tests/altair_theme_test.py new file mode 100644 index 000000000..b9114baec --- /dev/null +++ b/tests/altair_theme_test.py @@ -0,0 +1,141 @@ +# ruff: noqa: E711 +from __future__ import annotations + +from typing import TYPE_CHECKING + +if TYPE_CHECKING: + from altair.typing import ChartType + + +def alt_theme_test() -> ChartType: + import altair as alt + + VEGA_DATASETS = "https://cdn.jsdelivr.net/npm/vega-datasets@v1.29.0/data/" + us_10m = f"{VEGA_DATASETS}us-10m.json" + unemployment = f"{VEGA_DATASETS}unemployment.tsv" + movies = f"{VEGA_DATASETS}movies.json" + barley = f"{VEGA_DATASETS}barley.json" + iowa_electricity = f"{VEGA_DATASETS}iowa-electricity.csv" + common_data = alt.InlineData( + [ + {"Index": 1, "Value": 28, "Position": 1, "Category": "A"}, + {"Index": 2, "Value": 55, "Position": 2, "Category": "A"}, + {"Index": 3, "Value": 43, "Position": 3, "Category": "A"}, + {"Index": 4, "Value": 91, "Position": 4, "Category": "A"}, + {"Index": 5, "Value": 81, "Position": 5, "Category": "A"}, + {"Index": 6, "Value": 53, "Position": 6, "Category": "A"}, + {"Index": 7, "Value": 19, "Position": 1, "Category": "B"}, + {"Index": 8, "Value": 87, "Position": 2, "Category": "B"}, + {"Index": 9, "Value": 52, "Position": 3, "Category": "B"}, + {"Index": 10, "Value": 48, "Position": 4, "Category": "B"}, + {"Index": 11, "Value": 24, "Position": 5, "Category": "B"}, + {"Index": 12, "Value": 49, "Position": 6, "Category": "B"}, + {"Index": 13, "Value": 87, "Position": 1, "Category": "C"}, + {"Index": 14, "Value": 66, "Position": 2, "Category": "C"}, + {"Index": 15, "Value": 17, "Position": 3, "Category": "C"}, + {"Index": 16, "Value": 27, "Position": 4, "Category": "C"}, + {"Index": 17, "Value": 68, "Position": 5, "Category": "C"}, + {"Index": 18, "Value": 16, "Position": 6, "Category": "C"}, + ] + ) + + HEIGHT_SMALL = 140 + STANDARD = 180 + WIDTH_GEO = int(STANDARD * 1.667) + + bar = ( + alt.Chart(common_data, height=HEIGHT_SMALL, width=STANDARD, title="Bar") + .mark_bar() + .encode( + x=alt.X("Index:O").axis(offset=1), y=alt.Y("Value:Q"), tooltip="Value:Q" + ) + .transform_filter(alt.datum["Index"] <= 9) + ) + line = ( + alt.Chart(common_data, height=HEIGHT_SMALL, width=STANDARD, title="Line") + .mark_line() + .encode( + x=alt.X("Position:O").axis(grid=False), + y=alt.Y("Value:Q").axis(grid=False), + color=alt.Color("Category:N").legend(None), + tooltip=["Index:O", "Value:Q", "Position:O", "Category:N"], + ) + ) + point_shape = ( + alt.Chart( + common_data, height=HEIGHT_SMALL, width=STANDARD, title="Point (Shape)" + ) + .mark_point() + .encode( + x=alt.X("Position:O").axis(grid=False), + y=alt.Y("Value:Q").axis(grid=False), + shape=alt.Shape("Category:N").legend(None), + color=alt.Color("Category:N").legend(None), + tooltip=["Index:O", "Value:Q", "Position:O", "Category:N"], + ) + ) + point = ( + alt.Chart(movies, height=STANDARD, width=STANDARD, title="Point") + .mark_point(tooltip=True) + .transform_filter(alt.datum["IMDB_Rating"] != None) + .transform_filter( + alt.FieldRangePredicate("Release_Date", [None, 2019], timeUnit="year") + ) + .transform_joinaggregate(Average_Rating="mean(IMDB_Rating)") + .transform_calculate( + Rating_Delta=alt.datum["IMDB_Rating"] - alt.datum.Average_Rating + ) + .encode( + x=alt.X("Release_Date:T").title("Release Date"), + y=alt.Y("Rating_Delta:Q").title("Rating Delta"), + color=alt.Color("Rating_Delta:Q").title("Rating Delta").scale(domainMid=0), + ) + ) + bar_stack = ( + alt.Chart(barley, height=STANDARD, width=STANDARD, title="Bar (Stacked)") + .mark_bar(tooltip=True) + .encode( + x="sum(yield):Q", + y=alt.Y("variety:N"), + color=alt.Color("site:N").legend(orient="bottom", columns=2), + ) + ) + area = ( + alt.Chart(iowa_electricity, height=STANDARD, width=STANDARD, title="Area") + .mark_area(tooltip=True) + .encode( + x=alt.X("year:T").title("Year"), + y=alt.Y("net_generation:Q") + .title("Share of net generation") + .stack("normalize") + .axis(format=".0%"), + color=alt.Color("source:N") + .title("Electricity source") + .legend(orient="bottom", columns=2), + ) + ) + geoshape = ( + alt.Chart( + alt.topo_feature(us_10m, "counties"), + height=STANDARD, + width=WIDTH_GEO, + title=alt.Title("Geoshape", subtitle="Unemployment rate per county"), + ) + .mark_geoshape(tooltip=True) + .encode(color="rate:Q") + .transform_lookup( + "id", alt.LookupData(alt.UrlData(unemployment), "id", ["rate"]) + ) + .project(type="albersUsa") + ) + + compound_chart = ( + (bar | line | point_shape) & (point | bar_stack) & (area | geoshape) + ).properties( + title=alt.Title( + "Vega-Altair Theme Test", + fontSize=20, + subtitle="Adapted from https://vega.github.io/vega-themes/", + ) + ) + return compound_chart diff --git a/tests/examples_methods_syntax/layered_chart_with_dual_axis.py b/tests/examples_methods_syntax/layered_chart_with_dual_axis.py index 6f6cd86d6..3947380a2 100644 --- a/tests/examples_methods_syntax/layered_chart_with_dual_axis.py +++ b/tests/examples_methods_syntax/layered_chart_with_dual_axis.py @@ -15,12 +15,12 @@ ) area = base.mark_area(opacity=0.3, color='#57A44C').encode( - alt.Y('average(temp_max)').title('Avg. Temperature (°C)', titleColor='#57A44C'), + alt.Y('average(temp_max)').axis(title='Avg. Temperature (°C)', titleColor='#57A44C'), alt.Y2('average(temp_min)') ) line = base.mark_line(stroke='#5276A7', interpolate='monotone').encode( - alt.Y('average(precipitation)').title('Precipitation (inches)', titleColor='#5276A7') + alt.Y('average(precipitation)').axis(title='Precipitation (inches)', titleColor='#5276A7') ) alt.layer(area, line).resolve_scale( diff --git a/tests/expr/test_expr.py b/tests/expr/test_expr.py index 8842e0ced..15757b09f 100644 --- a/tests/expr/test_expr.py +++ b/tests/expr/test_expr.py @@ -2,14 +2,21 @@ import operator import sys -from inspect import classify_class_attrs, getmembers -from typing import Any, Iterator +from inspect import classify_class_attrs, getmembers, signature +from typing import TYPE_CHECKING, Any, Callable, TypeVar, cast import pytest from jsonschema.exceptions import ValidationError from altair import datum, expr, ExprRef -from altair.expr import _ConstExpressionType +from altair.expr import _ExprMeta +from altair.expr.core import Expression, GetAttrExpression + +if TYPE_CHECKING: + from collections.abc import Iterable, Iterator + from inspect import _IntrospectableCallable + +T = TypeVar("T") # This maps vega expression function names to the Python name VEGA_REMAP = {"if_": "if"} @@ -19,20 +26,29 @@ def _is_property(obj: Any, /) -> bool: return isinstance(obj, property) -def _get_classmethod_names(tp: type[Any], /) -> Iterator[str]: - for m in classify_class_attrs(tp): - if m.kind == "class method" and m.defining_class is tp: - yield m.name +def _get_property_names(tp: type[Any], /) -> Iterator[str]: + for nm, _ in getmembers(tp, _is_property): + yield nm -def _remap_classmethod_names(tp: type[Any], /) -> Iterator[tuple[str, str]]: - for name in _get_classmethod_names(tp): - yield VEGA_REMAP.get(name, name), name +def signature_n_params( + obj: _IntrospectableCallable, + /, + *, + exclude: Iterable[str] = frozenset(("cls", "self")), +) -> int: + sig = signature(obj) + return len(set(sig.parameters).difference(exclude)) -def _get_property_names(tp: type[Any], /) -> Iterator[str]: - for nm, _ in getmembers(tp, _is_property): - yield nm +def _iter_classmethod_specs( + tp: type[T], / +) -> Iterator[tuple[str, Callable[..., Expression], int]]: + for m in classify_class_attrs(tp): + if m.kind == "class method" and m.defining_class is tp: + name = m.name + fn = cast("classmethod[T, ..., Expression]", m.object).__func__ + yield (VEGA_REMAP.get(name, name), fn.__get__(tp), signature_n_params(fn)) def test_unary_operations(): @@ -86,15 +102,18 @@ def test_abs(): assert repr(z) == "abs(datum.xxx)" -@pytest.mark.parametrize(("veganame", "methodname"), _remap_classmethod_names(expr)) -def test_expr_funcs(veganame: str, methodname: str): - """Test all functions defined in expr.funcs.""" - func = getattr(expr, methodname) - z = func(datum.xxx) - assert repr(z) == f"{veganame}(datum.xxx)" +@pytest.mark.parametrize(("veganame", "fn", "n_params"), _iter_classmethod_specs(expr)) +def test_expr_methods( + veganame: str, fn: Callable[..., Expression], n_params: int +) -> None: + datum_names = [f"col_{n}" for n in range(n_params)] + datum_args = ",".join(f"datum.{nm}" for nm in datum_names) + + fn_call = fn(*(GetAttrExpression("datum", nm) for nm in datum_names)) + assert repr(fn_call) == f"{veganame}({datum_args})" -@pytest.mark.parametrize("constname", _get_property_names(_ConstExpressionType)) +@pytest.mark.parametrize("constname", _get_property_names(_ExprMeta)) def test_expr_consts(constname: str): """Test all constants defined in expr.consts.""" const = getattr(expr, constname) @@ -102,7 +121,7 @@ def test_expr_consts(constname: str): assert repr(z) == f"({constname} * datum.xxx)" -@pytest.mark.parametrize("constname", _get_property_names(_ConstExpressionType)) +@pytest.mark.parametrize("constname", _get_property_names(_ExprMeta)) def test_expr_consts_immutable(constname: str): """Ensure e.g `alt.expr.PI = 2` is prevented.""" if sys.version_info >= (3, 11): diff --git a/tests/test_jupyter_chart.py b/tests/test_jupyter_chart.py index 0630ce4b3..be26386bb 100644 --- a/tests/test_jupyter_chart.py +++ b/tests/test_jupyter_chart.py @@ -26,7 +26,7 @@ try: - import vegafusion # type: ignore # noqa: F401 + import vegafusion # noqa: F401 transformers = ["default", "vegafusion"] except ImportError: diff --git a/tests/test_transformed_data.py b/tests/test_transformed_data.py index 1c4d8a095..ee689ff68 100644 --- a/tests/test_transformed_data.py +++ b/tests/test_transformed_data.py @@ -10,7 +10,7 @@ import narwhals as nw try: - import vegafusion as vf # type: ignore + import vegafusion as vf except ImportError: vf = None diff --git a/tests/utils/test_schemapi.py b/tests/utils/test_schemapi.py index 2f0b9faab..fa5e83aff 100644 --- a/tests/utils/test_schemapi.py +++ b/tests/utils/test_schemapi.py @@ -2,6 +2,7 @@ from __future__ import annotations import copy +import datetime as dt import inspect import io import json @@ -10,7 +11,7 @@ import warnings from collections import deque from functools import partial -from typing import TYPE_CHECKING, Any, Callable, Iterable, Sequence +from typing import TYPE_CHECKING, Any, Callable import jsonschema import jsonschema.exceptions @@ -34,6 +35,8 @@ from vega_datasets import data if TYPE_CHECKING: + from collections.abc import Iterable, Sequence + from narwhals.typing import IntoDataFrame _JSON_SCHEMA_DRAFT_URL = load_schema()["$schema"] @@ -1022,3 +1025,138 @@ def test_to_dict_range(tp) -> None: x_dict = alt.X("x:O", sort=tp(0, 5)).to_dict() actual = x_dict["sort"] # type: ignore assert actual == expected + + +@pytest.fixture +def stocks() -> alt.Chart: + source = "https://cdn.jsdelivr.net/npm/vega-datasets@v1.29.0/data/sp500.csv" + return alt.Chart(source).mark_area().encode(x="date:T", y="price:Q") + + +def DateTime( + year: int, + month: int, + day: int, + hour: int = 0, + minute: int = 0, + second: int = 0, + milliseconds: int = 0, + *, + utc: bool | None = None, +) -> alt.DateTime: + """Factory for positionally aligning `datetime.datetime`/ `alt.DateTime`.""" + kwds: dict[str, Any] = {} + if utc is True: + kwds.update(utc=utc) + if (hour, minute, second, milliseconds) != (0, 0, 0, 0): + kwds.update( + hours=hour, minutes=minute, seconds=second, milliseconds=milliseconds + ) + return alt.DateTime(year=year, month=month, date=day, **kwds) + + +@pytest.mark.parametrize( + ("window", "expected"), + [ + ( + (dt.date(2005, 1, 1), dt.date(2009, 1, 1)), + (DateTime(2005, 1, 1), DateTime(2009, 1, 1)), + ), + ( + (dt.datetime(2005, 1, 1), dt.datetime(2009, 1, 1)), + ( + # NOTE: Keep this to test truncating independently! + alt.DateTime(year=2005, month=1, date=1), + alt.DateTime(year=2009, month=1, date=1), + ), + ), + ( + ( + dt.datetime(2001, 1, 1, 9, 30, 0, 2999), + dt.datetime(2002, 1, 1, 17, 0, 0, 5000), + ), + ( + DateTime(2001, 1, 1, 9, 30, 0, 2), + DateTime(2002, 1, 1, 17, 0, 0, 5), + ), + ), + ( + ( + dt.datetime(2003, 5, 1, 1, 30, tzinfo=dt.timezone.utc), + dt.datetime(2003, 6, 3, 4, 3, tzinfo=dt.timezone.utc), + ), + ( + DateTime(2003, 5, 1, 1, 30, 0, 0, utc=True), + DateTime(2003, 6, 3, 4, 3, 0, 0, utc=True), + ), + ), + ], + ids=["date", "datetime (no time)", "datetime (microseconds)", "datetime (UTC)"], +) +def test_to_dict_datetime( + stocks, window: tuple[dt.date, dt.date], expected: tuple[alt.DateTime, alt.DateTime] +) -> None: + """ + Includes `datetime.datetime` with an empty time component. + + This confirms that conversion matches how `alt.DateTime` omits `Undefined`. + """ + expected_dicts = [e.to_dict() for e in expected] + brush = alt.selection_interval(encodings=["x"], value={"x": window}) + base = stocks + + upper = base.encode(alt.X("date:T").scale(domain=brush)) + lower = base.add_params(brush) + chart = upper & lower + mapping = chart.to_dict() + params_value = mapping["params"][0]["value"]["x"] + + assert isinstance(params_value, list) + assert params_value == expected_dicts + + +@pytest.mark.parametrize( + "tzinfo", + [ + dt.timezone(dt.timedelta(hours=2), "UTC+2"), + dt.timezone(dt.timedelta(hours=1), "BST"), + dt.timezone(dt.timedelta(hours=-7), "pdt"), + dt.timezone(dt.timedelta(hours=-3), "BRT"), + dt.timezone(dt.timedelta(hours=9), "UTC"), + dt.timezone(dt.timedelta(minutes=60), "utc"), + ], +) +def test_to_dict_datetime_unsupported_timezone(tzinfo: dt.timezone) -> None: + datetime = dt.datetime(2003, 5, 1, 1, 30) + + result = alt.FieldEqualPredicate(datetime, "column 1") + assert result.to_dict() + + with pytest.raises(TypeError, match=r"Unsupported timezone.+\n.+UTC.+local"): + alt.FieldEqualPredicate(datetime.replace(tzinfo=tzinfo), "column 1") + + +def test_to_dict_datetime_typing() -> None: + """ + Enumerating various places that need updated annotations. + + All work at runtime, just need to give the type checkers the new info. + + Sub-issue of https://github.com/vega/altair/issues/3650 + """ + datetime = dt.datetime(2003, 5, 1, 1, 30) + datetime_seq = [datetime, datetime.replace(2005), datetime.replace(2008)] + assert alt.FieldEqualPredicate(datetime, field="column 1") + assert alt.FieldOneOfPredicate(oneOf=datetime_seq, field="column 1") + + assert alt.Legend(values=datetime_seq) + + assert alt.Scale(domain=datetime_seq) + assert alt.Scale(domainMin=datetime_seq[0], domainMax=datetime_seq[2]) + + # NOTE: `datum` is not annotated? + assert alt.XDatum(datum=datetime).to_dict() + + # NOTE: `*args` is not annotated? + # - All of these uses *args incorrectly + assert alt.Vector2DateTime(datetime_seq[:2]) diff --git a/tests/vegalite/test_common.py b/tests/vegalite/test_common.py index 1e3e83daa..3e8760ad7 100644 --- a/tests/vegalite/test_common.py +++ b/tests/vegalite/test_common.py @@ -92,7 +92,8 @@ def test_max_rows(alt): with alt.data_transformers.enable("default"): basic_chart.to_dict() # this should not fail - with alt.data_transformers.enable("default", max_rows=5), pytest.raises( - alt.MaxRowsError + with ( + alt.data_transformers.enable("default", max_rows=5), + pytest.raises(alt.MaxRowsError), ): basic_chart.to_dict() # this should not fail diff --git a/tests/vegalite/v5/schema/__init__.py b/tests/vegalite/v5/schema/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/tests/vegalite/v5/schema/test_channels.py b/tests/vegalite/v5/schema/test_channels.py new file mode 100644 index 000000000..1193fa739 --- /dev/null +++ b/tests/vegalite/v5/schema/test_channels.py @@ -0,0 +1,82 @@ +from __future__ import annotations + +import datetime as dt +from collections import deque +from typing import TYPE_CHECKING + +import pytest + +from altair.utils.schemapi import SchemaValidationError +from altair.vegalite.v5.schema import channels as alt +from altair.vegalite.v5.schema.core import DateTime + +if TYPE_CHECKING: + from collections.abc import Sequence + + from altair.vegalite.v5.schema._typing import Temporal + + +def test_channels_typing() -> None: + """ + Ensuring static typing aligns with `SchemaValidationError`(s). + + Important + --------- + Unless a comment says otherwise, **every** ``# (type|pyright): ignore`` **is intentional**. + + Notes + ----- + - *Non-exhaustive*, focusing on several repeated patterns. + - Not generated from the schema + - To avoid leaking logic defined during generation + """ + nums: list[int] = [1, 2, 3, 4, 5] + range_nums: range = range(5) + day: dt.date = dt.date(2024, 10, 27) + dates: tuple[dt.date, ...] = tuple(day.replace(day.year + n) for n in range_nums) + dates_mixed: Sequence[Temporal | DateTime] = ( + DateTime(year=2000), + *dates, + dt.datetime(2001, 1, 1), + ) + + angle = alt.Angle("field:Q") + assert angle.to_dict() + + assert angle.sort("ascending").to_dict() + assert angle.sort("-fillOpacity").to_dict() + assert angle.sort(None) + assert angle.sort(nums).to_dict() + assert angle.sort(range_nums).to_dict() + assert angle.sort(deque(nums)).to_dict() + assert angle.sort(dates).to_dict() + assert angle.sort(dates_mixed).to_dict() + + # NOTE: Triggering static and runtime errors + invariant_sequence = angle.sort([*nums, *dates]) # type: ignore[arg-type] # pyright: ignore[reportCallIssue] + with pytest.raises(SchemaValidationError): + invariant_sequence.to_dict() + + positional_as_keyword = angle.sort(_="ascending") # type: ignore[call-overload] + with pytest.raises( + SchemaValidationError, + match=r"'{'_': 'ascending'}' is an invalid value for `sort`", + ): + positional_as_keyword.to_dict() + + keyword_as_positional = angle.sort("field:Q", "min", "descending") # type: ignore[call-overload] + with pytest.raises(SchemaValidationError): + keyword_as_positional.to_dict() + angle.sort(field="field:Q", op="min", order="descending") + + # NOTE: Doesn't raise `SchemaValidationError` + # - `"ascending"` is silently ignored when positional + # - Caught as invalid statically, but not at runtime + bad = angle.sort("x", "ascending").to_dict() # type: ignore[call-overload] + good = angle.sort(encoding="x", order="ascending").to_dict() + assert isinstance(bad, dict) + assert isinstance(good, dict) + with pytest.raises( + AssertionError, match=r"'x' == {'encoding': 'x', 'order': 'ascending'}" + ): + assert bad["sort"] == good["sort"] diff --git a/tests/vegalite/v5/test_api.py b/tests/vegalite/v5/test_api.py index 302355f28..ea8005e70 100644 --- a/tests/vegalite/v5/test_api.py +++ b/tests/vegalite/v5/test_api.py @@ -32,7 +32,6 @@ from altair.vegalite.v5.api import _Conditional, _Conditions from altair.vegalite.v5.schema._typing import Map, SingleDefUnitChannel_T -ibis.set_backend("polars") PANDAS_VERSION = Version(importlib_version("pandas")) @@ -586,9 +585,13 @@ def test_when_labels_position_based_on_condition() -> None: # `mypy` will flag structural errors here cond = when["condition"][0] otherwise = when["value"] - param_color_py_when = alt.param( - expr=alt.expr.if_(cond["test"], cond["value"], otherwise) - ) + + # TODO: Open an issue on making `OperatorMixin` generic + # Something like this would be used as the return type for all `__dunder__` methods: + # R = TypeVar("R", Expression, SelectionPredicateComposition) + test = cond["test"] + assert not isinstance(test, alt.PredicateComposition) + param_color_py_when = alt.param(expr=alt.expr.if_(test, cond["value"], otherwise)) lhs_param = param_color_py_expr.param rhs_param = param_color_py_when.param assert isinstance(lhs_param, alt.VariableParameter) @@ -633,7 +636,9 @@ def test_when_expressions_inside_parameters() -> None: cond = when_then_otherwise["condition"][0] otherwise = when_then_otherwise["value"] expected = alt.expr.if_(alt.datum.b >= 0, 10, -20) - actual = alt.expr.if_(cond["test"], cond["value"], otherwise) + test = cond["test"] + assert not isinstance(test, alt.PredicateComposition) + actual = alt.expr.if_(test, cond["value"], otherwise) assert expected == actual text_conditioned = bar.mark_text( @@ -1632,11 +1637,6 @@ def test_polars_with_pandas_nor_pyarrow(monkeypatch: pytest.MonkeyPatch): assert "numpy" not in sys.modules -@pytest.mark.skipif( - sys.version_info < (3, 9), - reason="The maximum `ibis` version installable on Python 3.8 is `ibis==5.1.0`," - " which doesn't support the dataframe interchange protocol.", -) @pytest.mark.skipif( Version("1.5") > PANDAS_VERSION, reason="A warning is thrown on old pandas versions", @@ -1645,6 +1645,7 @@ def test_polars_with_pandas_nor_pyarrow(monkeypatch: pytest.MonkeyPatch): sys.platform == "win32", reason="Timezone database is not installed on Windows" ) def test_ibis_with_date_32(): + ibis.set_backend("polars") df = pl.DataFrame( {"a": [1, 2, 3], "b": [date(2020, 1, 1), date(2020, 1, 2), date(2020, 1, 3)]} ) @@ -1657,11 +1658,6 @@ def test_ibis_with_date_32(): ] -@pytest.mark.skipif( - sys.version_info < (3, 9), - reason="The maximum `ibis` version installable on Python 3.8 is `ibis==5.1.0`," - " which doesn't support the dataframe interchange protocol.", -) @pytest.mark.skipif( Version("1.5") > PANDAS_VERSION, reason="A warning is thrown on old pandas versions", @@ -1670,6 +1666,7 @@ def test_ibis_with_date_32(): sys.platform == "win32", reason="Timezone database is not installed on Windows" ) def test_ibis_with_vegafusion(monkeypatch: pytest.MonkeyPatch): + ibis.set_backend("polars") df = pl.DataFrame( { "a": [1, 2, 3], diff --git a/tests/vegalite/v5/test_data.py b/tests/vegalite/v5/test_data.py index 5603912f8..f8c41aeff 100644 --- a/tests/vegalite/v5/test_data.py +++ b/tests/vegalite/v5/test_data.py @@ -23,9 +23,10 @@ def test_disable_max_rows(sample_data): try: # Ensure that there is no TypeError for non-max_rows transformers. - with alt.data_transformers.enable( - "json" - ), alt.data_transformers.disable_max_rows(): + with ( + alt.data_transformers.enable("json"), + alt.data_transformers.disable_max_rows(), + ): jsonfile = alt.data_transformers.get()(sample_data) except TypeError: jsonfile = {} diff --git a/tests/vegalite/v5/test_params.py b/tests/vegalite/v5/test_params.py index a5ea3c001..d380586a8 100644 --- a/tests/vegalite/v5/test_params.py +++ b/tests/vegalite/v5/test_params.py @@ -167,6 +167,40 @@ def test_selection_condition(): assert dct["encoding"]["size"]["value"] == 10 +def test_selection_interval_value_typing() -> None: + """Ensure each encoding restricts types independently.""" + import datetime as dt + + w_date = dt.date(2005, 1, 1), dt.date(2009, 1, 1) + w_float = (0, 999) + w_date_datetime = dt.date(2005, 1, 1), alt.DateTime(year=2009) + w_str = ["0", "500"] + + a = alt.selection_interval(encodings=["x"], value={"x": w_date}).to_dict() + b = alt.selection_interval(encodings=["y"], value={"y": w_float}).to_dict() + c = alt.selection_interval(encodings=["x"], value={"x": w_date_datetime}).to_dict() + d = alt.selection_interval(encodings=["text"], value={"text": w_str}).to_dict() + + a_b = alt.selection_interval( + encodings=["x", "y"], value={"x": w_date, "y": w_float} + ).to_dict() + a_c = alt.selection_interval( + encodings=["x", "y"], value={"x": w_date, "y": w_date_datetime} + ).to_dict() + b_c_d = alt.selection_interval( + encodings=["x", "y", "text"], + value={"x": w_date_datetime, "y": w_float, "text": w_str}, + ).to_dict() + + assert a + assert b + assert c + assert d + assert a_b + assert a_c + assert b_c_d + + def test_creation_views_params_layered_repeat_chart(): import altair as alt from vega_datasets import data diff --git a/tools/__init__.py b/tools/__init__.py index 052b8e9c0..46fc97553 100644 --- a/tools/__init__.py +++ b/tools/__init__.py @@ -1,8 +1,15 @@ -from tools import generate_api_docs, generate_schema_wrapper, schemapi, update_init_file +from tools import ( + generate_api_docs, + generate_schema_wrapper, + markup, + schemapi, + update_init_file, +) __all__ = [ "generate_api_docs", "generate_schema_wrapper", + "markup", "schemapi", "update_init_file", ] diff --git a/tools/codemod.py b/tools/codemod.py new file mode 100644 index 000000000..40e2dbcb2 --- /dev/null +++ b/tools/codemod.py @@ -0,0 +1,437 @@ +# ruff: noqa: D418 +from __future__ import annotations + +import ast +import subprocess +import sys +import textwrap +import warnings +from ast import unparse +from collections import deque +from collections.abc import Iterable +from importlib.util import find_spec +from pathlib import Path +from typing import TYPE_CHECKING, Any, TypeVar, overload + +if sys.version_info >= (3, 12): + from typing import Protocol, TypeAliasType +else: + from typing_extensions import Protocol, TypeAliasType + +if TYPE_CHECKING: + if sys.version_info >= (3, 11): + from typing import LiteralString + else: + from typing_extensions import LiteralString + + from collections.abc import Iterator + from typing import ClassVar, Literal + + +__all__ = ["extract_func_def", "extract_func_def_embed", "ruff", "ruff_inline_docs"] + +T = TypeVar("T") +OneOrIterV = TypeAliasType( + "OneOrIterV", + "T | Iterable[T] | Iterable[OneOrIterV[T]]", + type_params=(T,), +) +_Code = OneOrIterV[str] + + +def parse_module(name: str, /) -> ast.Module: + """ + Find absolute path and parse module into an ast. + + Use regular dotted import style, no `.py` suffix. + + Acceptable ``name``: + + altair.package.subpackage.etc + tools.____ + tests.____ + doc.____ + sphinxext.____ + """ + if (spec := find_spec(name)) and (origin := spec.origin): + return ast.parse(Path(origin).read_bytes()) + else: + raise FileNotFoundError(name) + + +def find_func_def(mod: ast.Module, fn_name: str, /) -> ast.FunctionDef: + """ + Return a function node matching ``fn_name``. + + Notes + ----- + Provides some extra type safety, over:: + + ast.Module.body: list[ast.stmt] + """ + for stmt in mod.body: + if isinstance(stmt, ast.FunctionDef) and stmt.name == fn_name: + return stmt + else: + continue + msg = f"Found no function named {fn_name!r}" + raise NotImplementedError(msg) + + +def validate_body(fn: ast.FunctionDef, /) -> tuple[list[ast.stmt], ast.expr]: + """ + Ensure function has inlined imports and a return statement. + + Returns:: + + (ast.FunctionDef.body[:-1], ast.Return.value) + """ + body = fn.body + first = body[0] + if not isinstance(first, (ast.Import, ast.ImportFrom)): + msg = ( + f"First statement in function must be an import, " + f"got {type(first).__name__!r}\n\n" + f"{unparse(first)!r}" + ) + raise TypeError(msg) + last = body.pop() + if not isinstance(last, ast.Return) or last.value is None: + body.append(last) + msg = ( + f"Last statement in function must return an expression, " + f"got {type(last).__name__!r}\n\n" + f"{unparse(last)!r}" + ) + raise TypeError(msg) + else: + return body, last.value + + +def iter_flatten(*elements: _Code) -> Iterator[str]: + for el in elements: + if not isinstance(el, str) and isinstance(el, Iterable): + yield from iter_flatten(*el) + elif isinstance(el, str): + yield el + else: + msg = ( + f"Expected all elements to eventually flatten to ``str``, " + f"but got: {type(el).__name__!r}\n\n" + f"{el!r}" + ) + raise TypeError(msg) + + +def iter_func_def_unparse( + module_name: str, + func_name: str, + /, + *, + return_transform: Literal["assign"] | None = None, + assign_to: str = "chart", +) -> Iterator[str]: + # Planning to add pyscript code before/after + # Then add `ruff check` to clean up duplicate imports (on the whole thing) + # Optional: assign the return to `assign_to` + # - Allows writing modular code that doesn't depend on the variable names in the original function + mod = parse_module(module_name) + fn = find_func_def(mod, func_name) + body, ret = validate_body(fn) + for node in body: + yield unparse(node) + yield "" + ret_value = unparse(ret) + if return_transform is None: + yield ret_value + elif return_transform == "assign": + yield f"{assign_to} = {ret_value}" + else: + msg = f"{return_transform=}" + raise NotImplementedError(msg) + + +def extract_func_def( + module_name: str, + func_name: str, + *, + format: bool = True, + output: Literal["altair-plot", "code-block", "str"] = "str", +) -> str: + """ + Extract the contents of a function for use as a code block. + + Parameters + ---------- + module_name + Absolute, dotted import style. + func_name + Name of function in ``module_name``. + format + Run through ``ruff format`` before returning. + output + Optionally, return embedded in an `rst` directive. + + Notes + ----- + - Functions must define all imports inline, to ensure they are propagated + - Must end with a single return statement + + Warning + ------- + Requires ``python>=3.9`` for `ast.unparse`_ + + Examples + -------- + Transform the contents of a function into a code block:: + + >>> extract_func_def("tests.altair_theme_test", "alt_theme_test", output="code-block") # doctest: +SKIP + + .. _ast.unparse: + https://docs.python.org/3.9/library/ast.html#ast.unparse + """ + if output not in {"altair-plot", "code-block", "str"}: + raise TypeError(output) + it = iter_func_def_unparse(module_name, func_name) + s = ruff_inline_docs.format(it) if format else "\n".join(it) + if output == "str": + return s + else: + return f".. {output}::\n\n{textwrap.indent(s, ' ' * 4)}\n" + + +def extract_func_def_embed( + module_name: str, + func_name: str, + /, + before: _Code | None = None, + after: _Code | None = None, + assign_to: str = "chart", + indent: int | None = None, +) -> str: + """ + Extract the contents of a function, wrapping with ``before`` and ``after``. + + The resulting code block is run through ``ruff`` to deduplicate imports + and apply consistent formatting. + + Parameters + ---------- + module_name + Absolute, dotted import style. + func_name + Name of function in ``module_name``. + before + Code inserted before ``func_name``. + after + Code inserted after ``func_name``. + assign_to + Variable name to use as the result of ``func_name``. + + .. note:: + Allows the ``after`` block to use a consistent reference. + indent + Optionally, prefix ``indent * " "`` to final block. + + .. note:: + Occurs **after** formatting, will not contribute to line length wrap. + """ + if before is None and after is None: + msg = ( + f"At least one additional code fragment should be provided, but:\n" + f"{before=}, {after=}\n\n" + f"Use {extract_func_def.__qualname__!r} instead." + ) + warnings.warn(msg, UserWarning, stacklevel=2) + unparsed = iter_func_def_unparse( + module_name, func_name, return_transform="assign", assign_to=assign_to + ) + parts = [p for p in (before, unparsed, after) if p is not None] + formatted = ruff_inline_docs(parts) + return textwrap.indent(formatted, " " * indent) if indent else formatted + + +class CodeMod(Protocol): + def __call__(self, *code: _Code) -> str: + """ + Transform some input into a single block of modified code. + + Parameters + ---------- + *code + Arbitrarily nested code fragments. + """ + ... + + def _join(self, code: _Code, *, sep: str = "\n") -> str: + """ + Concatenate any number of code fragments. + + All nested groups are unwrapped into a flat iterable. + """ + return sep.join(iter_flatten(code)) + + +class Ruff(CodeMod): + """ + Run `ruff`_ commands against code fragments or files. + + By default, uses the same config as `pyproject.toml`_. + + Parameters + ---------- + *extend_select + `rule codes`_ to use **on top of** the default config. + ignore + `rule codes`_ to `ignore`_. + skip_magic_traling_comma + Enables `skip-magic-trailing-comma`_ during formatting. + + .. note:: + + Only use on code that is changing indent-level + (e.g. unwrapping function contents). + + .. _ruff: + https://docs.astral.sh/ruff/ + .. _pyproject.toml: + https://github.com/vega/altair/blob/main/pyproject.toml + .. _rule codes: + https://docs.astral.sh/ruff/rules/ + .. _ignore: + https://docs.astral.sh/ruff/settings/#lint_ignore + .. _skip-magic-trailing-comma: + https://docs.astral.sh/ruff/settings/#format_skip-magic-trailing-comma + """ + + _stdin_args: ClassVar[tuple[LiteralString, ...]] = ( + "--stdin-filename", + "placeholder.py", + ) + _check_args: ClassVar[tuple[LiteralString, ...]] = ("--fix",) + + def __init__( + self, + *extend_select: str, + ignore: OneOrIterV[str] | None = None, + skip_magic_traling_comma: bool = False, + ) -> None: + self.check_args: deque[str] = deque(self._check_args) + self.format_args: deque[str] = deque() + for c in extend_select: + self.check_args.extend(("--extend-select", c)) + if ignore is not None: + self.check_args.extend( + ("--ignore", ",".join(s for s in iter_flatten(ignore))) + ) + if skip_magic_traling_comma: + self.format_args.extend( + ("--config", "format.skip-magic-trailing-comma = true") + ) + + def write_lint_format(self, fp: Path, code: _Code, /) -> None: + """ + Combined steps of writing, `ruff check`, `ruff format`. + + Parameters + ---------- + fp + Target file to write to + code + Some (potentially) nested code fragments. + + Notes + ----- + - `fp` is written to first, as the size before formatting will be the smallest + - Better utilizes `ruff` performance, rather than `python` str and io + """ + self.check(fp, code) + self.format(fp) + + @overload + def check(self, *code: _Code, decode: Literal[True] = ...) -> str: + """Fixes violations and returns fixed code.""" + + @overload + def check(self, *code: _Code, decode: Literal[False]) -> bytes: + """ + ``decode=False`` will return as ``bytes``. + + Helpful if piping to another command. + """ + + @overload + def check(self, _write_to: Path, /, *code: _Code) -> None: + """ + ``code`` is joined, written to provided path and then checked. + + No input returned. + """ + + def check(self, *code: Any, decode: bool = True) -> str | bytes | None: + """ + Check and fix ``ruff`` rule violations. + + All cases will join ``code`` to a single ``str``. + """ + base = "ruff", "check" + if isinstance(code[0], Path): + fp = code[0] + fp.write_text(self._join(code[1:]), encoding="utf-8") + subprocess.run((*base, fp, *self.check_args), check=True) + return None + r = subprocess.run( + (*base, *self.check_args, *self._stdin_args), + input=self._join(code).encode(), + check=True, + capture_output=True, + ) + return r.stdout.decode() if decode else r.stdout + + @overload + def format(self, *code: _Code) -> str: + """Format arbitrarily nested input as a single block.""" + + @overload + def format(self, _target_file: Path, /, *code: None) -> None: + """ + Format an existing file. + + Running on `win32` after writing lines will ensure ``LF`` is used, and not ``CRLF``: + + ruff format --diff --check _target_file + """ + + @overload + def format(self, _encoded_result: bytes, /, *code: None) -> str: + """Format the raw result of ``ruff.check``.""" + + def format(self, *code: Any) -> str | None: + """ + Format some input code, or an existing file. + + Returns decoded result unless formatting an existing file. + """ + base = "ruff", "format" + if len(code) == 1 and isinstance(code[0], Path): + subprocess.run((*base, code[0], *self.format_args), check=True) + return None + encoded = ( + code[0] + if len(code) == 1 and isinstance(code[0], bytes) + else self._join(code).encode() + ) + r = subprocess.run( + (*base, *self.format_args, *self._stdin_args), + input=encoded, + check=True, + capture_output=True, + ) + return r.stdout.decode() + + def __call__(self, *code: _Code) -> str: + return self.format(self.check(code, decode=False)) + + +ruff_inline_docs = Ruff(ignore="E711", skip_magic_traling_comma=True) +ruff = Ruff() diff --git a/tools/generate_api_docs.py b/tools/generate_api_docs.py index dc93aba24..489375786 100644 --- a/tools/generate_api_docs.py +++ b/tools/generate_api_docs.py @@ -5,10 +5,13 @@ import types from pathlib import Path from types import ModuleType -from typing import Final, Iterator +from typing import TYPE_CHECKING, Final import altair as alt +if TYPE_CHECKING: + from collections.abc import Iterator + API_FILENAME: Final = str(Path.cwd() / "doc" / "user_guide" / "api.rst") API_TEMPLATE: Final = """\ diff --git a/tools/generate_schema_wrapper.py b/tools/generate_schema_wrapper.py index 85860e8f3..e7307078a 100644 --- a/tools/generate_schema_wrapper.py +++ b/tools/generate_schema_wrapper.py @@ -12,7 +12,7 @@ from itertools import chain from operator import attrgetter from pathlib import Path -from typing import TYPE_CHECKING, Any, Final, Iterable, Iterator, Literal +from typing import TYPE_CHECKING, Any, Final, Literal from urllib import request import vl_convert as vlc @@ -20,15 +20,11 @@ sys.path.insert(0, str(Path.cwd())) -from tools.schemapi import ( # noqa: F401 - CodeSnippet, - SchemaInfo, - arg_invalid_kwds, - arg_kwds, - arg_required_kwds, - codegen, -) +from tools.codemod import ruff +from tools.markup import rst_syntax_for_class +from tools.schemapi import CodeSnippet, SchemaInfo, arg_kwds, arg_required_kwds, codegen from tools.schemapi.utils import ( + RemapContext, SchemaProperties, TypeAliasTracer, finalize_type_reprs, @@ -37,16 +33,17 @@ import_typing_extensions, indent_docstring, resolve_references, - rst_syntax_for_class, - ruff_format_py, - ruff_write_lint_format_str, spell_literal, ) +from tools.vega_expr import write_expr_module if TYPE_CHECKING: + from collections.abc import Iterable, Iterator + from tools.schemapi.codegen import ArgInfo, AttrGetter from vl_convert import VegaThemes + SCHEMA_VERSION: Final = "v5.20.1" @@ -60,8 +57,14 @@ """ SCHEMA_URL_TEMPLATE: Final = "https://vega.github.io/schema/{library}/{version}.json" +VL_PACKAGE_TEMPLATE = ( + "https://raw.githubusercontent.com/vega/vega-lite/refs/tags/{version}/package.json" +) SCHEMA_FILE = "vega-lite-schema.json" THEMES_FILE = "vega-themes.json" +EXPR_FILE: Path = ( + Path(__file__).parent / ".." / "altair" / "expr" / "__init__.py" +).resolve() CHANNEL_MYPY_IGNORE_STATEMENTS: Final = """\ # These errors need to be ignored as they come from the overload methods @@ -253,6 +256,25 @@ class {name}(TypedDict{metaclass_kwds}):{comment} THEME_CONFIG: Literal["ThemeConfig"] = "ThemeConfig" PADDING_KWDS: Literal["PaddingKwds"] = "PaddingKwds" ROW_COL_KWDS: Literal["RowColKwds"] = "RowColKwds" +TEMPORAL: Literal["Temporal"] = "Temporal" + +# NOTE: `api.py` typing imports +BIN: Literal["Bin"] = "Bin" +IMPUTE: Literal["Impute"] = "Impute" +INTO_CONDITION: Literal["IntoCondition"] = "IntoCondition" + +# NOTE: `core.py` typing imports +DATETIME: Literal["DateTime"] = "DateTime" +BIN_PARAMS: Literal["BinParams"] = "BinParams" +IMPUTE_PARAMS: Literal["ImputeParams"] = "ImputeParams" +TIME_UNIT_PARAMS: Literal["TimeUnitParams"] = "TimeUnitParams" +SCALE: Literal["Scale"] = "Scale" +AXIS: Literal["Axis"] = "Axis" +LEGEND: Literal["Legend"] = "Legend" +REPEAT_REF: Literal["RepeatRef"] = "RepeatRef" +HEADER_COLUMN: Literal["Header"] = "Header" +ENCODING_SORT_FIELD: Literal["EncodingSortField"] = "EncodingSortField" + ENCODE_KWDS_SUMMARY: Final = ( "Encoding channels map properties of the data to visual properties of the chart." ) @@ -277,10 +299,7 @@ class _EncodingMixin: def encode(self, *args: Any, {method_args}) -> Self: """Map properties of the data to visual properties of the chart (see :class:`FacetedEncoding`) {docstring}""" - # Compat prep for `infer_encoding_types` signature - kwargs = locals() - kwargs.pop("self") - args = kwargs.pop("args") + kwargs = {dict_literal} if args: kwargs = {{k: v for k, v in kwargs.items() if v is not Undefined}} @@ -393,10 +412,11 @@ class PaddingKwds(TypedDict, total=False): left: float right: float top: float + +Temporal: TypeAlias = Union[date, datetime] ''' _ChannelType = Literal["field", "datum", "value"] -INTO_CONDITION: Literal["IntoCondition"] = "IntoCondition" class SchemaGenerator(codegen.SchemaGenerator): @@ -425,6 +445,7 @@ class {classname}(FieldChannelMixin, core.{basename}): {init_code} ''' ) + haspropsetters = True class ValueSchemaGenerator(SchemaGenerator): @@ -441,6 +462,7 @@ class {classname}(ValueChannelMixin, core.{basename}): {init_code} ''' ) + haspropsetters = True class DatumSchemaGenerator(SchemaGenerator): @@ -457,6 +479,7 @@ class {classname}(DatumChannelMixin, core.{basename}): {init_code} ''' ) + haspropsetters = True def schema_class(*args, **kwargs) -> str: @@ -544,13 +567,14 @@ def copy_schemapi_util() -> None: destination_fp = Path(__file__).parent / ".." / "altair" / "utils" / "schemapi.py" print(f"Copying\n {source_fp!s}\n -> {destination_fp!s}") - with source_fp.open(encoding="utf8") as source, destination_fp.open( - "w", encoding="utf8" - ) as dest: + with ( + source_fp.open(encoding="utf8") as source, + destination_fp.open("w", encoding="utf8") as dest, + ): dest.write(HEADER_COMMENT) dest.writelines(source.readlines()) if sys.platform == "win32": - ruff_format_py(destination_fp) + ruff.format(destination_fp) def recursive_dict_update(schema: dict, root: dict, def_dict: dict) -> None: @@ -667,6 +691,7 @@ def generate_vegalite_schema_wrapper(fp: Path, /) -> str: "from narwhals.dependencies import is_pandas_dataframe as _is_pandas_dataframe", "from altair.utils.schemapi import SchemaBase, Undefined, UndefinedType, _subclasses # noqa: F401\n", import_type_checking( + "from datetime import date, datetime", "from altair import Parameter", "from altair.typing import Optional", "from ._typing import * # noqa: F403", @@ -748,7 +773,6 @@ def generate_vegalite_channel_wrappers(fp: Path, /) -> str: "schema": defschema, "rootschema": schema, "encodingname": prop, - "haspropsetters": True, } if encoding_spec == "field": gen = FieldSchemaGenerator(classname, nodefault=[], **kwds) @@ -787,14 +811,27 @@ def generate_vegalite_channel_wrappers(fp: Path, /) -> str: "from . import core", "from ._typing import * # noqa: F403", ] + TYPING_CORE = ( + DATETIME, + TIME_UNIT_PARAMS, + SCALE, + AXIS, + LEGEND, + REPEAT_REF, + HEADER_COLUMN, + ENCODING_SORT_FIELD, + ) + TYPING_API = INTO_CONDITION, BIN, IMPUTE contents = [ HEADER, CHANNEL_MYPY_IGNORE_STATEMENTS, *imports, import_type_checking( + "from datetime import date, datetime", "from altair import Parameter, SchemaBase", "from altair.typing import Optional", - f"from altair.vegalite.v5.api import {INTO_CONDITION}", + f"from altair.vegalite.v5.schema.core import {', '.join(TYPING_CORE)}", + f"from altair.vegalite.v5.api import {', '.join(TYPING_API)}", textwrap.indent(import_typing_extensions((3, 11), "Self"), " "), ), "\n" f"__all__ = {sorted(all_)}\n", @@ -1026,7 +1063,7 @@ def vegalite_main(skip_download: bool = False) -> None: f"SCHEMA_VERSION = '{version}'\n", f"SCHEMA_URL = {schema_url(version)!r}\n", ] - ruff_write_lint_format_str(outfile, content) + ruff.write_lint_format(outfile, content) TypeAliasTracer.update_aliases(("Map", "Mapping[str, Any]")) @@ -1040,7 +1077,10 @@ def vegalite_main(skip_download: bool = False) -> None: # Generate the channel wrappers fp_channels = schemapath / "channels.py" print(f"Generating\n {schemafile!s}\n ->{fp_channels!s}") - files[fp_channels] = generate_vegalite_channel_wrappers(schemafile) + with RemapContext( + {DATETIME: (TEMPORAL, DATETIME), BIN_PARAMS: (BIN,), IMPUTE_PARAMS: (IMPUTE,)} + ): + files[fp_channels] = generate_vegalite_channel_wrappers(schemafile) # generate the mark mixin markdefs = {k: f"{k}Def" for k in ["Mark", "BoxPlot", "ErrorBar", "ErrorBand"]} @@ -1102,13 +1142,14 @@ def vegalite_main(skip_download: bool = False) -> None: "is_color_hex", ROW_COL_KWDS, PADDING_KWDS, + TEMPORAL, header=HEADER, extra=TYPING_EXTRA, ) # Write the pre-generated modules for fp, contents in files.items(): print(f"Writing\n {schemafile!s}\n ->{fp!s}") - ruff_write_lint_format_str(fp, contents) + ruff.write_lint_format(fp, contents) def generate_encoding_artifacts( @@ -1180,6 +1221,7 @@ def generate_encoding_artifacts( method: str = fmt_method.format( method_args=", ".join(signature_args), docstring=indent_docstring(signature_doc_params, indent_level=8, lstrip=False), + dict_literal="{" + ", ".join(f"{kwd!r}:{kwd}" for kwd in channel_infos) + "}", ) typed_dict = generate_typed_dict( facet_encoding, @@ -1207,6 +1249,11 @@ def main() -> None: args = parser.parse_args() copy_schemapi_util() vegalite_main(args.skip_download) + write_expr_module( + vlc.get_vega_version(), + output=EXPR_FILE, + header=HEADER_COMMENT, + ) # The modules below are imported after the generation of the new schema files # as these modules import Altair. This allows them to use the new changes diff --git a/tools/markup.py b/tools/markup.py new file mode 100644 index 000000000..440efe629 --- /dev/null +++ b/tools/markup.py @@ -0,0 +1,151 @@ +"""Tools for working with formats like ``.md``, ``.rst``.""" + +from __future__ import annotations + +import re +from html import unescape +from pathlib import Path +from typing import TYPE_CHECKING, Any, Literal +from urllib import request + +import mistune.util +from mistune import InlineParser as _InlineParser +from mistune import Markdown as _Markdown +from mistune.renderers.rst import RSTRenderer as _RSTRenderer + +if TYPE_CHECKING: + import sys + from collections.abc import Iterable + + if sys.version_info >= (3, 11): + from typing import TypeAlias + else: + from typing_extensions import TypeAlias + from re import Pattern + + from mistune import BaseRenderer, BlockParser, BlockState, InlineState + + Url: TypeAlias = str + +Token: TypeAlias = "dict[str, Any]" + +_RE_LINK: Pattern[str] = re.compile(r"(?<=\[)([^\]]+)(?=\]\([^\)]+\))", re.MULTILINE) +_RE_SPECIAL: Pattern[str] = re.compile(r"[*_]{2,3}|`", re.MULTILINE) +_RE_LIQUID_INCLUDE: Pattern[str] = re.compile(r"( \{% include.+%\})") + + +class RSTRenderer(_RSTRenderer): + def __init__(self) -> None: + super().__init__() + + def inline_html(self, token: Token, state: BlockState) -> str: + html = token["raw"] + return rf"\ :raw-html:`{html}`\ " + + +class RSTParse(_Markdown): + """ + Minor extension to support partial `ast`_ conversion. + + Only need to convert the docstring tokens to `.rst`. + + .. _ast: + https://mistune.lepture.com/en/latest/guide.html#abstract-syntax-tree + """ + + def __init__( + self, + renderer: BaseRenderer | Literal["ast"] | None, + block: BlockParser | None = None, + inline: _InlineParser | None = None, + plugins=None, + ) -> None: + if renderer == "ast": + renderer = None + super().__init__(renderer, block, inline, plugins) + + def __call__(self, s: str) -> str: + s = super().__call__(s) # pyright: ignore[reportAssignmentType] + return unescape(s).replace(r"\ ,", ",").replace(r"\ ", " ") + + def render_tokens(self, tokens: Iterable[Token], /) -> str: + """ + Render ast tokens originating from another parser. + + Parameters + ---------- + tokens + All tokens will be rendered into a single `.rst` string + """ + if self.renderer is None: + msg = "Unable to render tokens without a renderer." + raise TypeError(msg) + state = self.block.state_cls() + s = self.renderer(self._iter_render(tokens, state), state) + return mistune.util.unescape(s) + + +class RSTParseVegaLite(RSTParse): + def __init__( + self, + renderer: RSTRenderer | None = None, + block: BlockParser | None = None, + inline: _InlineParser | None = None, + plugins=None, + ) -> None: + super().__init__(renderer or RSTRenderer(), block, inline, plugins) + + def __call__(self, s: str) -> str: + # remove formatting from links + description = "".join( + _RE_SPECIAL.sub("", d) if i % 2 else d + for i, d in enumerate(_RE_LINK.split(s)) + ) + + description = super().__call__(description) + # Some entries in the Vega-Lite schema miss the second occurence of '__' + description = description.replace("__Default value: ", "__Default value:__ ") + # Links to the vega-lite documentation cannot be relative but instead need to + # contain the full URL. + description = description.replace( + "types#datetime", "https://vega.github.io/vega-lite/docs/datetime.html" + ) + # Fixing ambiguous unicode, RUF001 produces RUF002 in docs + description = description.replace("’", "'") # noqa: RUF001 [RIGHT SINGLE QUOTATION MARK] + description = description.replace("–", "-") # noqa: RUF001 [EN DASH] + description = description.replace(" ", " ") # noqa: RUF001 [NO-BREAK SPACE] + return description.strip() + + +class InlineParser(_InlineParser): + def __init__(self, hard_wrap: bool = False) -> None: + super().__init__(hard_wrap) + + def process_text(self, text: str, state: InlineState) -> None: + """ + Removes `liquid`_ templating markup. + + .. _liquid: + https://shopify.github.io/liquid/ + """ + state.append_token({"type": "text", "raw": _RE_LIQUID_INCLUDE.sub(r"", text)}) + + +def read_ast_tokens(source: Url | Path, /) -> list[Token]: + """ + Read from ``source``, drop ``BlockState``. + + Factored out to provide accurate typing. + """ + markdown = _Markdown(renderer=None, inline=InlineParser()) + if isinstance(source, Path): + tokens = markdown.read(source) + else: + with request.urlopen(source) as response: + s = response.read().decode("utf-8") + tokens = markdown.parse(s, markdown.block.state_cls()) + return tokens[0] + + +def rst_syntax_for_class(class_name: str) -> str: + return f":class:`{class_name}`" diff --git a/tools/schemapi/__init__.py b/tools/schemapi/__init__.py index 55c5f4148..b3ea70704 100644 --- a/tools/schemapi/__init__.py +++ b/tools/schemapi/__init__.py @@ -9,6 +9,7 @@ ) from tools.schemapi.schemapi import SchemaBase, Undefined from tools.schemapi.utils import OneOrSeq, SchemaInfo +from tools.vega_expr import write_expr_module __all__ = [ "CodeSnippet", @@ -21,4 +22,5 @@ "arg_required_kwds", "codegen", "utils", + "write_expr_module", ] diff --git a/tools/schemapi/codegen.py b/tools/schemapi/codegen.py index 5e6d3107b..47d96dcd7 100644 --- a/tools/schemapi/codegen.py +++ b/tools/schemapi/codegen.py @@ -5,20 +5,18 @@ import re import sys import textwrap +from collections.abc import Iterable, Iterator from dataclasses import dataclass -from itertools import chain +from itertools import chain, starmap from operator import attrgetter -from typing import Any, Callable, Final, Iterable, Iterator, TypeVar, Union +from typing import Any, Callable, ClassVar, Final, Literal, TypeVar, Union from .utils import ( + Grouped, SchemaInfo, - TypeAliasTracer, - flatten, indent_docstring, is_valid_identifier, - jsonschema_to_python_types, process_description, - spell_literal, ) if sys.version_info >= (3, 12): @@ -38,6 +36,11 @@ Spelled more generically to support future extension. """ +ANON: Literal["_"] = "_" +DOUBLESTAR_ARGS: Literal["**kwds"] = "**kwds" +POS_ONLY: Literal["/"] = "/" +KWD_ONLY: Literal["*"] = "*" + class CodeSnippet: """Object whose repr() is a string of code.""" @@ -207,6 +210,8 @@ def __init__({arglist}): """ ).lstrip() + haspropsetters: ClassVar[bool] = False + def __init__( self, classname: str, @@ -216,7 +221,6 @@ def __init__( schemarepr: object | None = None, rootschemarepr: object | None = None, nodefault: list[str] | None = None, - haspropsetters: bool = False, **kwargs, ) -> None: self.classname = classname @@ -226,7 +230,6 @@ def __init__( self.schemarepr = schemarepr self.rootschemarepr = rootschemarepr self.nodefault = nodefault or () - self.haspropsetters = haspropsetters self.kwargs = kwargs def subclasses(self) -> Iterator[str]: @@ -264,7 +267,9 @@ def schema_class(self) -> str: rootschema=rootschemarepr, docstring=self.docstring(indent=4), init_code=self.init_code(indent=4), - method_code=self.method_code(indent=4), + method_code=( + self.overload_code(indent=4) if type(self).haspropsetters else None + ), **self.kwargs, ) @@ -350,89 +355,84 @@ def init_args(self) -> tuple[list[str], list[str]]: ) if arg_info.additional: - args.append("**kwds") - super_args.append("**kwds") + args.append(DOUBLESTAR_ARGS) + super_args.append(DOUBLESTAR_ARGS) return args, super_args - def get_args(self, si: SchemaInfo) -> list[str]: - contents = ["self"] - prop_infos: dict[str, SchemaInfo] = {} - if si.is_anyOf(): - prop_infos = {} - for si_sub in si.anyOf: - prop_infos.update(si_sub.properties) - elif si.properties: - prop_infos = dict(si.properties.items()) - - if prop_infos: - contents.extend( - f"{p}: {info.to_type_repr(target='annotation', use_undefined=True)} = Undefined" - for p, info in prop_infos.items() - ) - elif isinstance(si.type, str): - py_type = jsonschema_to_python_types[si.type] - if py_type == "list": - # Try to get a type hint like "List[str]" which is more specific - # then just "list" - item_vl_type = si.items.get("type", None) - if item_vl_type is not None: - item_type = jsonschema_to_python_types[item_vl_type] - else: - item_si = SchemaInfo(si.items, self.rootschema) - assert item_si.is_reference() - altair_class_name = item_si.title - item_type = f"core.{altair_class_name}" - py_type = f"List[{item_type}]" - elif si.is_literal(): - # If it's an enum, we can type hint it as a Literal which tells - # a type checker that only the values in enum are acceptable - py_type = TypeAliasTracer.add_literal( - si, spell_literal(si.literal), replace=True + # TODO: Resolve 45x ``list[core.ConditionalValueDef...] annotations + def overload_signature( + self, prop: str, info: SchemaInfo | Iterable[SchemaInfo], / + ) -> Iterator[str]: + """Yields a single, fully annotated ``@overload``, signature.""" + TARGET: Literal["annotation"] = "annotation" + yield "@overload" + signature = "def {0}(self, {1}) -> {2}: ..." + if isinstance(info, SchemaInfo): + if info.properties: + it = ( + f"{name}: {p_info.to_type_repr(target=TARGET, use_undefined=True)} = Undefined" + for name, p_info in info.properties.items() ) - contents.append(f"_: {py_type}") - - contents.append("**kwds") - - return contents - - def get_signature( - self, attr: str, sub_si: SchemaInfo, indent: int, has_overload: bool = False - ) -> list[str]: - lines = [] - if has_overload: - lines.append("@overload") - args = ", ".join(self.get_args(sub_si)) - lines.extend( - (f"def {attr}({args}) -> '{self.classname}':", indent * " " + "...\n") - ) - return lines - - def setter_hint(self, attr: str, indent: int) -> list[str]: - si = SchemaInfo(self.schema, self.rootschema).properties[attr] - if si.is_anyOf(): - return self._get_signature_any_of(si, attr, indent) + content = f"{KWD_ONLY}, {', '.join(it)}" + elif isinstance(info.type, str): + if info.is_array() and (title := info.child(info.items).title): + tp = f"list[core.{title}]" + else: + tp = info.to_type_repr(target=TARGET, use_concrete=True) + content = f"{ANON}: {tp}, {POS_ONLY}" + else: + msg = f"Assumed unreachable\n{info!r}" + raise NotImplementedError(msg) + else: + tp = SchemaInfo.to_type_repr_batched(info, target=TARGET, use_concrete=True) + content = f"{ANON}: {tp}, {POS_ONLY}" + yield signature.format(prop, content, self.classname) + + def _overload_expand( + self, prop: str, info: SchemaInfo | Iterable[SchemaInfo], / + ) -> Iterator[str]: + children: Iterable[SchemaInfo] + if isinstance(info, SchemaInfo): + children = info.anyOf if info.is_anyOf() else (info,) else: - return self.get_signature(attr, si, indent, has_overload=True) - - def _get_signature_any_of( - self, si: SchemaInfo, attr: str, indent: int - ) -> list[str]: - signatures = [] - for sub_si in si.anyOf: - if sub_si.is_anyOf(): - # Recursively call method again to go a level deeper - signatures.extend(self._get_signature_any_of(sub_si, attr, indent)) + children = info + for child in children: + if child.is_anyOf() and not child.is_union_flattenable(): + yield from self._overload_expand(prop, child) else: - signatures.extend( - self.get_signature(attr, sub_si, indent, has_overload=True) - ) - return list(flatten(signatures)) - - def method_code(self, indent: int = 0) -> str | None: - """Return code to assist setter methods.""" - if not self.haspropsetters: - return None - args = self.init_kwds - type_hints = (hint for a in args for hint in self.setter_hint(a, indent)) + yield from self.overload_signature(prop, child) - return ("\n" + indent * " ").join(type_hints) + def overload_dispatch(self, prop: str, info: SchemaInfo, /) -> Iterator[str]: + """ + For a given property ``prop``, decide how to represent all valid signatures. + + In this context, dispatching between **3** kinds of ``@overload``: + - ``Union`` + 1. The subset of basic types form a single signature + - See `thread`_ for special case handling mixed ``@overload``. + 2. More complex types are recursed into, possibly expanding to multiple signatures + - Others + 3. Only one signature is required + + .. _thread: + https://github.com/vega/altair/pull/3659#discussion_r1818164457 + """ + if info.is_anyOf(): + grouped = Grouped(info.anyOf, SchemaInfo.is_flattenable) + if (expand := grouped.falsy) and len(expand) == 1 and expand[0].properties: + grouped.truthy.append(expand[0]) + if flatten := grouped.truthy: + yield from self.overload_signature(prop, flatten) + if expand := grouped.falsy: + yield from self._overload_expand(prop, expand) + else: + yield from self.overload_signature(prop, info) + + def overload_code(self, indent: int = 0) -> str: + """Return all ``@overload`` for property setter methods and as an indented code block.""" + indented = "\n" + indent * " " + it = starmap( + self.overload_dispatch, + self.arg_info.iter_args(arg_kwds, exclude=self.nodefault), + ) + return indented.join(chain.from_iterable(it)) diff --git a/tools/schemapi/schemapi.py b/tools/schemapi/schemapi.py index 3089886eb..b41c61a85 100644 --- a/tools/schemapi/schemapi.py +++ b/tools/schemapi/schemapi.py @@ -2,11 +2,13 @@ import contextlib import copy +import datetime as dt import inspect import json import sys import textwrap from collections import defaultdict +from collections.abc import Iterable, Iterator, Mapping, Sequence from functools import partial from importlib.metadata import version as importlib_version from itertools import chain, zip_longest @@ -14,15 +16,9 @@ from typing import ( TYPE_CHECKING, Any, - Dict, Final, Generic, - Iterable, - Iterator, - List, Literal, - Mapping, - Sequence, TypeVar, Union, cast, @@ -65,8 +61,8 @@ from typing_extensions import Never, Self _OptionalModule: TypeAlias = "ModuleType | None" -ValidationErrorList: TypeAlias = List[jsonschema.exceptions.ValidationError] -GroupedValidationErrors: TypeAlias = Dict[str, ValidationErrorList] +ValidationErrorList: TypeAlias = list[jsonschema.exceptions.ValidationError] +GroupedValidationErrors: TypeAlias = dict[str, ValidationErrorList] # This URI is arbitrary and could be anything else. It just cannot be an empty # string as we need to reference the schema registered in @@ -505,6 +501,34 @@ def _from_array_like(obj: Iterable[Any], /) -> list[Any]: return list(obj) +def _from_date_datetime(obj: dt.date | dt.datetime, /) -> dict[str, Any]: + """ + Parse native `datetime.(date|datetime)` into a `DateTime`_ schema. + + .. _DateTime: + https://vega.github.io/vega-lite/docs/datetime.html + """ + result: dict[str, Any] = {"year": obj.year, "month": obj.month, "date": obj.day} + if isinstance(obj, dt.datetime): + if obj.time() != dt.time.min: + us = obj.microsecond + ms = us if us == 0 else us // 1_000 + result.update( + hours=obj.hour, minutes=obj.minute, seconds=obj.second, milliseconds=ms + ) + if tzinfo := obj.tzinfo: + if tzinfo is dt.timezone.utc: + result["utc"] = True + else: + msg = ( + f"Unsupported timezone {tzinfo!r}.\n" + "Only `'UTC'` or naive (local) datetimes are permitted.\n" + "See https://altair-viz.github.io/user_guide/generated/core/altair.DateTime.html" + ) + raise TypeError(msg) + return result + + def _todict(obj: Any, context: dict[str, Any] | None, np_opt: Any, pd_opt: Any) -> Any: # noqa: C901 """Convert an object to a dict representation.""" if np_opt is not None: @@ -535,6 +559,8 @@ def _todict(obj: Any, context: dict[str, Any] | None, np_opt: Any, pd_opt: Any) return pd_opt.Timestamp(obj).isoformat() elif _is_iterable(obj, exclude=(str, bytes)): return _todict(_from_array_like(obj), context, np_opt, pd_opt) + elif isinstance(obj, dt.date): + return _from_date_datetime(obj) else: return obj @@ -1349,7 +1375,7 @@ def _replace_parsed_shorthand( TSchemaBase = TypeVar("TSchemaBase", bound=SchemaBase) -_CopyImpl = TypeVar("_CopyImpl", SchemaBase, Dict[Any, Any], List[Any]) +_CopyImpl = TypeVar("_CopyImpl", SchemaBase, dict[Any, Any], list[Any]) """ Types which have an implementation in ``SchemaBase.copy()``. diff --git a/tools/schemapi/utils.py b/tools/schemapi/utils.py index 5c4a84f9c..caf2cec2b 100644 --- a/tools/schemapi/utils.py +++ b/tools/schemapi/utils.py @@ -4,40 +4,30 @@ import json import re -import subprocess import sys import textwrap import urllib.parse -from html import unescape +from collections import deque +from collections.abc import Sequence +from contextlib import AbstractContextManager +from copy import deepcopy from itertools import chain from keyword import iskeyword from operator import itemgetter -from typing import ( - TYPE_CHECKING, - Any, - ClassVar, - Iterable, - Iterator, - Literal, - Mapping, - MutableSequence, - Sequence, - TypeVar, - Union, - overload, -) - -import mistune -from mistune.renderers.rst import RSTRenderer as _RSTRenderer +from typing import TYPE_CHECKING, Generic, Literal, TypeVar, Union, overload +from tools.codemod import ruff +from tools.markup import RSTParseVegaLite, rst_syntax_for_class from tools.schemapi.schemapi import _resolve_references as resolve_references if TYPE_CHECKING: - from _collections_abc import KeysView + from collections.abc import Callable, Iterable, Iterator, KeysView, Mapping from pathlib import Path from re import Pattern + from typing import Any, ClassVar + + from _typeshed import SupportsKeysAndGetItem - from mistune import BlockState if sys.version_info >= (3, 12): from typing import TypeAliasType @@ -74,10 +64,26 @@ "array": "list", "null": "None", } +_STDLIB_TYPE_NAMES = frozenset( + ( + "int", + "float", + "str", + "None", + "bool", + "date", + "datetime", + "time", + "tuple", + "list", + "deque", + "dict", + "set", + ) +) _VALID_IDENT: Pattern[str] = re.compile(r"^[^\d\W]\w*\Z", re.ASCII) -_RE_LINK: Pattern[str] = re.compile(r"(?<=\[)([^\]]+)(?=\]\([^\)]+\))", re.MULTILINE) -_RE_SPECIAL: Pattern[str] = re.compile(r"[*_]{2,3}|`", re.MULTILINE) + _RE_LIST_MISSING_ASTERISK: Pattern[str] = re.compile(r"^-(?=[ `\"a-z])", re.MULTILINE) _RE_LIST_MISSING_WHITESPACE: Pattern[str] = re.compile(r"^\*(?=[`\"a-z])", re.MULTILINE) @@ -96,13 +102,6 @@ class _TypeAliasTracer: A format specifier to produce the `TypeAlias` name. Will be provided a `SchemaInfo.title` as a single positional argument. - *ruff_check - Optional [ruff rule codes](https://docs.astral.sh/ruff/rules/), - each prefixed with `--select ` and follow a `ruff check --fix ` call. - - If not provided, uses `[tool.ruff.lint.select]` from `pyproject.toml`. - ruff_format - Optional argument list supplied to [ruff format](https://docs.astral.sh/ruff/formatter/#ruff-format) Attributes ---------- @@ -116,12 +115,7 @@ class _TypeAliasTracer: Prefined import statements to appear at beginning of module. """ - def __init__( - self, - fmt: str = "{}_T", - *ruff_check: str, - ruff_format: Sequence[str] | None = None, - ) -> None: + def __init__(self, fmt: str = "{}_T") -> None: self.fmt: str = fmt self._literals: dict[str, str] = {} self._literals_invert: dict[str, str] = {} @@ -129,7 +123,8 @@ def __init__( self._imports: Sequence[str] = ( "from __future__ import annotations\n", "import sys", - "from typing import Any, Generic, Literal, Mapping, TypeVar, Sequence, Union", + "from datetime import date, datetime", + "from typing import Annotated, Any, Generic, Literal, Mapping, TypeVar, Sequence, Union, get_args", "import re", import_typing_extensions( (3, 14), "TypedDict", reason="https://peps.python.org/pep-0728/" @@ -138,12 +133,7 @@ def __init__( import_typing_extensions((3, 12), "TypeAliasType"), import_typing_extensions((3, 11), "LiteralString"), import_typing_extensions((3, 10), "TypeAlias"), - import_typing_extensions((3, 9), "Annotated", "get_args"), ) - self._cmd_check: list[str] = ["--fix"] - self._cmd_format: Sequence[str] = ruff_format or () - for c in ruff_check: - self._cmd_check.extend(("--extend-select", c)) def _update_literals(self, name: str, tp: str, /) -> None: """Produces an inverted index, to reuse a `Literal` when `SchemaInfo.title` is empty.""" @@ -180,6 +170,20 @@ def add_literal( tp = f"Union[SchemaBase, {', '.join(it)}]" return tp + def add_union( + self, info: SchemaInfo, tp_iter: Iterator[str], /, *, replace: bool = False + ) -> str: + if title := info.title: + alias = self.fmt.format(title) + if alias not in self._aliases: + self.update_aliases( + (alias, f"Union[{', '.join(sort_type_reprs(tp_iter))}]") + ) + return alias if replace else title + else: + msg = f"Unsupported operation.\nRequires a title.\n\n{info!r}" + raise NotImplementedError(msg) + def update_aliases(self, *name_statement: tuple[str, str]) -> None: """ Adds `(name, statement)` pairs to the definitions. @@ -228,13 +232,6 @@ def write_module( extra `tools.generate_schema_wrapper.TYPING_EXTRA`. """ - ruff_format: MutableSequence[str | Path] = ["ruff", "format", fp] - if self._cmd_format: - ruff_format.extend(self._cmd_format) - commands: tuple[Sequence[str | Path], ...] = ( - ["ruff", "check", fp, *self._cmd_check], - ruff_format, - ) static = (header, "\n", *self._imports, "\n\n") self.update_aliases(*sorted(self._literals.items(), key=itemgetter(0))) all_ = [*iter(self._aliases), *extra_all] @@ -243,10 +240,7 @@ def write_module( [f"__all__ = {all_}", "\n\n", extra], self.generate_aliases(), ) - fp.write_text("\n".join(it), encoding="utf-8") - for cmd in commands: - r = subprocess.run(cmd, check=True) - r.check_returncode() + ruff.write_lint_format(fp, it) @property def n_entries(self) -> int: @@ -494,7 +488,7 @@ def to_type_repr( # noqa: C901 tp_str = TypeAliasTracer.add_literal(self, tp_str, replace=True) tps.add(tp_str) elif FOR_TYPE_HINTS and self.is_union_literal(): - it = chain.from_iterable(el.literal for el in self.anyOf) + it: Iterator[str] = chain.from_iterable(el.literal for el in self.anyOf) tp_str = TypeAliasTracer.add_literal(self, spell_literal(it), replace=True) tps.add(tp_str) elif self.is_anyOf(): @@ -503,6 +497,14 @@ def to_type_repr( # noqa: C901 for s in self.anyOf ) tps.update(maybe_rewrap_literal(chain.from_iterable(it_nest))) + elif FOR_TYPE_HINTS and self.is_type_alias_union(): + it = ( + SchemaInfo(dict(self.schema, type=tp)).to_type_repr( + target=target, use_concrete=use_concrete + ) + for tp in self.type + ) + tps.add(TypeAliasTracer.add_union(self, it, replace=True)) elif isinstance(self.type, list): # We always use title if possible for nested objects tps.update( @@ -540,6 +542,47 @@ def to_type_repr( # noqa: C901 else sort_type_reprs(tps) ) + @classmethod + def to_type_repr_batched( + cls, + infos: Iterable[SchemaInfo], + /, + *, + target: TargetType = "doc", + use_concrete: bool = False, + use_undefined: bool = False, + ) -> str: + """ + Return the python type representation of multiple ``SchemaInfo``. + + Intended to handle a subset of a ``Union``. + + Parameters + ---------- + infos + Schemas to collapse into a single representation. + target: {"annotation", "doc"} + Where the representation will be used. + use_concrete + Avoid base classes/wrappers that don't provide type info. + use_undefined + Wrap the result in ``altair.typing.Optional``. + + See Also + -------- + - ``SchemaInfo.to_type_repr`` + """ + it: Iterator[str] = chain.from_iterable( + info.to_type_repr( + as_str=False, + target=target, + use_concrete=use_concrete, + use_undefined=False, + ) + for info in infos + ) + return finalize_type_reprs(it, target=target, use_undefined=use_undefined) + def title_to_type_reprs(self, *, use_concrete: bool) -> set[str]: """ Possibly use ``self.title`` as a type, or provide alternative(s). @@ -568,6 +611,8 @@ def title_to_type_reprs(self, *, use_concrete: bool) -> set[str]: # NOTE: To keep type hints simple, we annotate with `SchemaBase` for all subclasses. if title in tp_param: tps.add("Parameter") + if self.is_datetime(): + tps.add("Temporal") elif self.is_value(): value = self.properties["value"] t = value.to_type_repr(target="annotation", use_concrete=use_concrete) @@ -695,6 +740,21 @@ def is_const(self) -> bool: return "const" in self.schema def is_literal(self) -> bool: + """ + Return True for `const`_ or `enum`_ values. + + JSON Schema distinguishes between singular/multiple values. + + But we annotate them both the same way: + + ConstInfo = Literal["single value"] + EnumInfo = Literal["value 1", "value 2", "value 3"] + + .. _const: + https://json-schema.org/understanding-json-schema/reference/const + .. _enum: + https://json-schema.org/understanding-json-schema/reference/enum + """ return not ({"enum", "const"}.isdisjoint(self.schema)) def is_empty(self) -> bool: @@ -761,6 +821,66 @@ def is_union_literal(self) -> bool: """ return self.is_union() and all(el.is_literal() for el in self.anyOf) + def is_primitive(self) -> bool: + """ + A basic JSON Schema `type`_ or an array of **only** basic types. + + .. _type: + https://json-schema.org/understanding-json-schema/reference/type + """ + TP = "type" + return (self.schema.keys() == {TP}) or ( + self.is_array() and self.child(self.items).is_primitive() + ) + + def is_flattenable(self) -> bool: + """ + Represents a range of cases we want to annotate in ``@overload``(s). + + Examples + -------- + The following are non-exhaustive examples, using ``python`` types. + + Base cases look like: + + Literal["left", "center", "right"] + float + Sequence[str] + + We also include compound cases, but only when **every** member meets these criteria: + + Literal["pad", "none", "fit"] | None + float | Sequence[float] + Sequence[str] | str | bool | float | None + """ + return self.is_literal() or self.is_primitive() or self.is_union_flattenable() + + def is_union_flattenable(self) -> bool: + """ + Represents a fully flattenable ``Union``. + + Used to prevent ``@overload`` explosion in ``channels.py`` + + Requires **every** member of the ``Union`` satisfies *at least* **one** the criteria. + + See Also + -------- + - ``SchemaInfo.is_literal`` + - ``SchemaInfo.is_array`` + - ``SchemaInfo.is_primitive`` + - ``SchemaInfo.is_flattenable`` + """ + if not self.is_union(): + return False + else: + fns = ( + SchemaInfo.is_literal, + SchemaInfo.is_array, + SchemaInfo.is_primitive, + SchemaInfo.is_union_flattenable, + ) + return all(any(fn(el) for fn in fns) for el in self.anyOf) + def is_format(self) -> bool: """ Represents a string format specifier. @@ -808,6 +928,25 @@ def is_type_alias(self) -> bool: and self.type in jsonschema_to_python_types ) + def is_type_alias_union(self) -> bool: + """ + Represents a name assigned to a list of literal types. + + Example: + + {"PrimitiveValue": {"type": ["number", "string", "boolean", "null"]}} + + Translating from JSON -> Python, this is the same as an ``"anyOf"`` -> ``Union``. + + The distinction in the schema is purely due to these types being defined in the draft, rather than definitions. + """ + TP = "type" + return ( + self.schema.keys() == {TP} + and isinstance(self.type, list) + and bool(self.title) + ) + def is_theme_config_target(self) -> bool: """ Return `True` for candidates classes in ``ThemeConfig`` hierarchy of ``TypedDict``(s). @@ -827,6 +966,74 @@ def is_theme_config_target(self) -> bool: and not (iskeyword(next(iter(self.required), ""))) ) + def is_datetime(self) -> bool: + return self.refname == "DateTime" + + +class Grouped(Generic[T]): + """ + Simple group-by like utility. + + Intended for consuming an iterator in full, splitting into true/false cases. + + Parameters + ---------- + iterable + Elements to divide into two groups. + predicate + Function to classify each element. + + Attributes + ---------- + truthy: deque[T] + Elements which pass ``predicate``. + falsy: deque[T] + Elements which fail ``predicate``. + """ + + def __init__( + self, iterable: Iterable[T], /, predicate: Callable[[T], bool] + ) -> None: + truthy, falsy = deque[T](), deque[T]() + for el in iterable: + if predicate(el): + truthy.append(el) + else: + falsy.append(el) + self.truthy: deque[T] = truthy + self.falsy: deque[T] = falsy + + +class RemapContext(AbstractContextManager): + """ + Context Manager to temporarily apply substitution rules for ``SchemaInfo``. + + Upon exiting, the original rules will be in effect. + + Notes + ----- + The constructor accepts arguments exactly the same way as ``dict``. + """ + + def __init__( + self, + m: SupportsKeysAndGetItem[str, Sequence[str]] + | Iterable[tuple[str, Sequence[str]]] = (), + /, + **kwds: Sequence[str], + ) -> None: + self._mapping: Mapping[str, Sequence[str]] = dict(m, **kwds) + self._orig: Mapping[str, Sequence[str]] + + def __enter__(self) -> Any: + self._orig = deepcopy(SchemaInfo._remap_title) + SchemaInfo._remap_title.update(self._mapping) + return self + + def __exit__(self, *args) -> None: + SchemaInfo._remap_title = dict(**self._orig) + del self._orig + def flatten(container: Iterable) -> Iterable: """ @@ -903,14 +1110,26 @@ def sort_type_reprs(tps: Iterable[str], /) -> list[str]: We use `set`_ for unique elements, but the lack of ordering requires additional sorts: - If types have same length names, order would still be non-deterministic - Hence, we sort as well by type name as a tie-breaker, see `sort-stability`_. - - Using ``str.lower`` gives priority to `builtins`_ over ``None``. - - Lowest priority is given to generated aliases from ``TypeAliasTracer``. + - Using ``str.lower`` gives priority to `builtins`_. + - Lower priority is given to generated aliases from ``TypeAliasTracer``. - These are purely to improve autocompletion + - ``None`` will always appear last. Related ------- - https://github.com/vega/altair/pull/3573#discussion_r1747121600 + Examples + -------- + >>> sort_type_reprs(["float", "None", "bool", "Chart", "float", "bool", "Chart", "str"]) + ['str', 'bool', 'float', 'Chart', 'None'] + + >>> sort_type_reprs(("None", "int", "Literal[5]", "int", "float")) + ['int', 'float', 'Literal[5]', 'None'] + + >>> sort_type_reprs({"date", "int", "str", "datetime", "Date"}) + ['int', 'str', 'date', 'datetime', 'Date'] + .. _set: https://docs.python.org/3/tutorial/datastructures.html#sets .. _sort-stability: @@ -919,9 +1138,30 @@ def sort_type_reprs(tps: Iterable[str], /) -> list[str]: https://docs.python.org/3/library/functions.html """ dedup = tps if isinstance(tps, set) else set(tps) - it = sorted(dedup, key=str.lower) # Tertiary sort - it = sorted(it, key=len) # Secondary sort - return sorted(it, key=TypeAliasTracer.is_cached) # Primary sort + it = sorted(dedup, key=str.lower) # Quinary sort + it = sorted(it, key=len) # Quaternary sort + it = sorted(it, key=TypeAliasTracer.is_cached) # Tertiary sort + it = sorted(it, key=is_not_stdlib) # Secondary sort + it = sorted(it, key=is_none) # Primary sort + return it + + +def is_not_stdlib(s: str, /) -> bool: + """ + Sort key. + + Places a subset of stdlib types at the **start** of list. + """ + return s not in _STDLIB_TYPE_NAMES + + +def is_none(s: str, /) -> bool: + """ + Sort key. + + Always places ``None`` at the **end** of list. + """ + return s == "None" def spell_nested_sequence( @@ -1002,49 +1242,6 @@ def unwrap_literal(tp: str, /) -> str: return re.sub(r"Literal\[(.+)\]", r"\g<1>", tp) -def ruff_format_py(fp: Path, /, *extra_args: str) -> None: - """ - Format an existing file. - - Running on `win32` after writing lines will ensure "lf" is used before: - ```bash - ruff format --diff --check . - ``` - """ - cmd: MutableSequence[str | Path] = ["ruff", "format", fp] - if extra_args: - cmd.extend(extra_args) - r = subprocess.run(cmd, check=True) - r.check_returncode() - - -def ruff_write_lint_format_str( - fp: Path, code: str | Iterable[str], /, *, encoding: str = "utf-8" -) -> None: - """ - Combined steps of writing, `ruff check`, `ruff format`. - - Notes - ----- - - `fp` is written to first, as the size before formatting will be the smallest - - Better utilizes `ruff` performance, rather than `python` str and io - - `code` is no longer bound to `list` - - Encoding set as default - - `I001/2` are `isort` rules, to sort imports. - """ - commands: Iterable[Sequence[str | Path]] = ( - ["ruff", "check", fp, "--fix"], - ["ruff", "check", fp, "--fix", "--select", "I001", "--select", "I002"], - ) - if not isinstance(code, str): - code = "\n".join(code) - fp.write_text(code, encoding=encoding) - for cmd in commands: - r = subprocess.run(cmd, check=True) - r.check_returncode() - ruff_format_py(fp) - - def import_type_checking(*imports: str) -> str: """Write an `if TYPE_CHECKING` block.""" imps = "\n".join(f" {s}" for s in imports) @@ -1071,7 +1268,7 @@ def import_typing_extensions( ) -TypeAliasTracer: _TypeAliasTracer = _TypeAliasTracer("{}_T", "I001", "I002") +TypeAliasTracer: _TypeAliasTracer = _TypeAliasTracer("{}_T") """An instance of `_TypeAliasTracer`. Collects a cache of unique `Literal` types used globally. @@ -1083,30 +1280,6 @@ def import_typing_extensions( """ -class RSTRenderer(_RSTRenderer): - def __init__(self) -> None: - super().__init__() - - def inline_html(self, token: dict[str, Any], state: BlockState) -> str: - html = token["raw"] - return rf"\ :raw-html:`{html}`\ " - - -class RSTParse(mistune.Markdown): - def __init__( - self, - renderer: mistune.BaseRenderer, - block: mistune.BlockParser | None = None, - inline: mistune.InlineParser | None = None, - plugins=None, - ) -> None: - super().__init__(renderer, block, inline, plugins) - - def __call__(self, s: str) -> str: - s = super().__call__(s) # pyright: ignore[reportAssignmentType] - return unescape(s).replace(r"\ ,", ",").replace(r"\ ", " ") - - def indent_docstring( # noqa: C901 lines: Iterable[str], indent_level: int, width: int = 100, lstrip=True ) -> str: @@ -1192,31 +1365,10 @@ def fix_docstring_issues(docstring: str) -> str: ) -def rst_syntax_for_class(class_name: str) -> str: - return f":class:`{class_name}`" - - -rst_parse: RSTParse = RSTParse(RSTRenderer()) +rst_parse: RSTParseVegaLite = RSTParseVegaLite() # TODO: Investigate `mistune.Markdown.(before|after)_render_hooks`. def process_description(description: str) -> str: """Parse a JSON encoded markdown description into an `RST` string.""" - # remove formatting from links - description = "".join( - _RE_SPECIAL.sub("", d) if i % 2 else d - for i, d in enumerate(_RE_LINK.split(description)) - ) - description = rst_parse(description) - # Some entries in the Vega-Lite schema miss the second occurence of '__' - description = description.replace("__Default value: ", "__Default value:__ ") - # Links to the vega-lite documentation cannot be relative but instead need to - # contain the full URL. - description = description.replace( - "types#datetime", "https://vega.github.io/vega-lite/docs/datetime.html" - ) - # Fixing ambiguous unicode, RUF001 produces RUF002 in docs - description = description.replace("’", "'") # noqa: RUF001 [RIGHT SINGLE QUOTATION MARK] - description = description.replace("–", "-") # noqa: RUF001 [EN DASH] - description = description.replace(" ", " ") # noqa: RUF001 [NO-BREAK SPACE] - return description.strip() + return rst_parse(description) diff --git a/tools/update_init_file.py b/tools/update_init_file.py index c1831093a..f795667b7 100644 --- a/tools/update_init_file.py +++ b/tools/update_init_file.py @@ -8,7 +8,7 @@ from pathlib import Path from typing import TYPE_CHECKING -from tools.schemapi.utils import ruff_write_lint_format_str +from tools.codemod import ruff _TYPING_CONSTRUCTS = { te.TypeAlias, @@ -16,9 +16,9 @@ t.cast, t.overload, te.runtime_checkable, - t.List, - t.Dict, - t.Tuple, + list, + dict, + tuple, t.Any, t.Literal, t.Union, @@ -74,7 +74,7 @@ def update__all__variable() -> None: ] # Write new version of altair/__init__.py # Format file content with ruff - ruff_write_lint_format_str(init_path, new_lines) + ruff.write_lint_format(init_path, new_lines) def relevant_attributes(namespace: dict[str, t.Any], /) -> list[str]: diff --git a/tools/vega_expr.py b/tools/vega_expr.py new file mode 100644 index 000000000..1941f64fd --- /dev/null +++ b/tools/vega_expr.py @@ -0,0 +1,968 @@ +""" +Parsing `Vega Expressions`_ docs to write the ``alt.expr`` module. + +.. _Vega Expressions: + https://vega.github.io/vega/docs/expressions/ +""" + +from __future__ import annotations + +import dataclasses +import enum +import keyword +import re +from collections import deque +from inspect import getmembers +from itertools import chain +from textwrap import TextWrapper as _TextWrapper +from textwrap import indent +from typing import TYPE_CHECKING, Any, Callable, ClassVar, Literal, overload + +from tools.codemod import ruff +from tools.markup import RSTParse, Token, read_ast_tokens +from tools.markup import RSTRenderer as _RSTRenderer +from tools.schemapi.schemapi import SchemaBase as _SchemaBase + +if TYPE_CHECKING: + import sys + from collections.abc import Iterable, Iterator, Mapping, Sequence + from pathlib import Path + from re import Match, Pattern + + from mistune import BlockState + + if sys.version_info >= (3, 11): + from typing import LiteralString, Self + else: + from typing_extensions import LiteralString, Self + from _typeshed import SupportsKeysAndGetItem + + from tools.markup import Url + +__all__ = ["parse_expressions", "write_expr_module"] + + +# NOTE: Urls/fragments +VEGA_DOCS_URL: LiteralString = "https://vega.github.io/vega/docs/" +EXPRESSIONS_DOCS_URL: LiteralString = f"{VEGA_DOCS_URL}expressions/" +EXPRESSIONS_URL_TEMPLATE = "https://raw.githubusercontent.com/vega/vega/refs/tags/{version}/docs/docs/expressions.md" + + +# NOTE: Regex patterns +FUNCTION_DEF_LINE: Pattern[str] = re.compile( + r".+)\" href=\"#(.+)\">" +) +SENTENCE_BREAK: Pattern[str] = re.compile(r"(?= (3, 12): + from typing import override +else: + from typing_extensions import override + +if TYPE_CHECKING: + from altair.expr.core import {return_ann}, {input_ann} + + +class {metaclass}(type): + """ + Metaclass for :class:`expr`. + + Currently providing read-only class properties, representing JavaScript constants. + """ + + @property + def NaN(cls) -> {return_ann}: + """Not a number (same as JavaScript literal NaN).""" + return {const}("NaN") + + @property + def LN10(cls) -> {return_ann}: + """The natural log of 10 (alias to Math.LN10).""" + return {const}("LN10") + + @property + def E(cls) -> {return_ann}: + """The transcendental number e (alias to Math.E).""" + return {const}("E") + + @property + def LOG10E(cls) -> {return_ann}: + """The base 10 logarithm e (alias to Math.LOG10E).""" + return {const}("LOG10E") + + @property + def LOG2E(cls) -> {return_ann}: + """The base 2 logarithm of e (alias to Math.LOG2E).""" + return {const}("LOG2E") + + @property + def SQRT1_2(cls) -> {return_ann}: + """The square root of 0.5 (alias to Math.SQRT1_2).""" + return {const}("SQRT1_2") + + @property + def LN2(cls) -> {return_ann}: + """The natural log of 2 (alias to Math.LN2).""" + return {const}("LN2") + + @property + def SQRT2(cls) -> {return_ann}: + """The square root of 2 (alias to Math.SQRT1_2).""" + return {const}("SQRT2") + + @property + def PI(cls) -> {return_ann}: + """The transcendental number pi (alias to Math.PI).""" + return {const}("PI") +''' + +MODULE_POST = """\ +_ExprType = expr +# NOTE: Compatibility alias for previous type of `alt.expr`. +# `_ExprType` was not referenced in any internal imports/tests. +""" + +CLS_DOC = """ + Utility providing *constants* and *classmethods* to construct expressions. + + `Expressions`_ can be used to write basic formulas that enable custom interactions. + + Alternatively, an `inline expression`_ may be defined via :class:`expr()`. + + Parameters + ---------- + expr: str + A `vega expression`_ string. + + Returns + ------- + ``ExprRef`` + + .. _Expressions: + https://altair-viz.github.io/user_guide/interactions.html#expressions + .. _inline expression: + https://altair-viz.github.io/user_guide/interactions.html#inline-expressions + .. _vega expression: + https://vega.github.io/vega/docs/expressions/ + + Examples + -------- + >>> import altair as alt + + >>> bind_range = alt.binding_range(min=100, max=300, name="Slider value: ") + >>> param_width = alt.param(bind=bind_range, name="param_width") + >>> param_color = alt.param( + ... expr=alt.expr.if_(param_width < 200, "red", "black"), + ... name="param_color", + ... ) + >>> y = alt.Y("yval").axis(titleColor=param_color) + + >>> y + Y({ + axis: {'titleColor': Parameter('param_color', VariableParameter({ + expr: if((param_width < 200),'red','black'), + name: 'param_color' + }))}, + shorthand: 'yval' + }) + """ + +CLS_TEMPLATE = '''\ +class expr({base}, metaclass={metaclass}): + """{doc}""" + + @override + def __new__(cls: type[{base}], expr: str) -> {base}: {type_ignore} + return {base}(expr=expr) +''' + +METHOD_SIGNATURE = ( + """def {title}(cls{sep}{param_list}{marker}) -> {return_ann}:{type_ignore}""" +) + +METHOD_TEMPLATE = '''\ + {decorator} + {signature} + """ + {doc} + """ + return {return_wrapper}({name}, {body_params}) +''' + + +def _override_predicate(obj: Any, /) -> bool: + return callable(obj) and not (name := obj.__name__).startswith("_") # noqa: F841 + + +_SCHEMA_BASE_MEMBERS: frozenset[str] = frozenset( + nm for nm, _ in getmembers(_SchemaBase, _override_predicate) +) + + +class RSTRenderer(_RSTRenderer): + def __init__(self) -> None: + super().__init__() + + def link(self, token: Token, state: BlockState) -> str: + """Store link url, for appending at the end of doc.""" + attrs = token["attrs"] + url = expand_urls(attrs["url"]) + text = self.render_children(token, state) + text = text.replace("`", "") + inline = f"`{text}`_" + state.env["ref_links"][text] = {"url": url} + return inline + + def _with_links(self, s: str, links: dict[str, Any] | Any, /) -> str: + it = chain.from_iterable( + (f".. _{ref_name}:", f" {attrs['url']}") + for ref_name, attrs in links.items() + ) + return "\n".join(chain([s], it)) + + def __call__(self, tokens: Iterable[Token], state: BlockState) -> str: + result = super().__call__(tokens, state) + if links := state.env.get("ref_links", {}): + return self._with_links(result, links) + else: + return result + + +parser: RSTParse = RSTParse(RSTRenderer()) +text_wrap = _TextWrapper( + width=100, + break_long_words=False, + break_on_hyphens=False, + initial_indent=METHOD_INDENT, + subsequent_indent=METHOD_INDENT, +) + + +class ReplaceMany: + """ + Perform many ``1:1`` replacements on a given text. + + Structured wrapper around a `dict`_ and `re.sub`_. + + Parameters + ---------- + mapping + Optional initial mapping. + fmt_match + **Combined** format string/regex pattern. + Receives the keys of the final ``self._mapping`` as a positional argument. + + .. note:: + Special characters must be escaped **first**, if present. + + fmt_replace + Format string applied to a succesful match, after substition. + Receives ``self._mapping[key]`` as a positional argument. + + .. _dict: + https://docs.python.org/3/library/stdtypes.html#mapping-types-dict + .. _re.sub: + https://docs.python.org/3/library/re.html#re.sub + + Examples + -------- + Providing a mapping during construction: + + >>> string = "The dog chased the cat, chasing the mouse. Poor mouse" + >>> animal_replacer = ReplaceMany({"dog": "cat"}) + >>> animal_replacer(string) + 'The cat chased the cat, chasing the mouse. Poor mouse' + + Updating with new replacements: + + >>> animal_replacer.update({"cat": "mouse", "mouse": "dog"}, duck="rabbit") + >>> animal_replacer(string, refresh=True) + 'The cat chased the mouse, chasing the dog. Poor dog' + + Further calls will continue using the most recent update: + + >>> animal_replacer("duck") + 'rabbit' + """ + + def __init__( + self, + mapping: Mapping[str, str] | None = None, + /, + fmt_match: str = "(?P{0})", + fmt_replace: str = "{0}", + ) -> None: + self._mapping: dict[str, str] = dict(mapping) if mapping else {} + self._fmt_match: str = fmt_match + self._fmt_replace: str = fmt_replace + self.pattern: Pattern[str] + self.repl: Callable[[Match[str]], str] + self._is_prepared: bool = False + + def update( + self, + m: SupportsKeysAndGetItem[str, str] | Iterable[tuple[str, str]], + /, + **kwds: str, + ) -> None: + """Update replacements mapping.""" + self._mapping.update(m, **kwds) + + def clear(self) -> None: + """Reset replacements mapping.""" + self._mapping.clear() + + def refresh(self) -> None: + """ + Compile replacement pattern and generate substitution function. + + Notes + ----- + Should be called **after** all (old, new) pairs have been collected. + """ + self.pattern = self._compile() + self.repl = self._replacer() + self._is_prepared = True + + def __call__(self, s: str, count: int = 0, /, refresh: bool = False) -> str: + """ + Replace the leftmost non-overlapping occurrences of ``self.pattern`` in ``s`` using ``self.repl``. + + Wraps `re.sub`_ + + .. _re.sub: + https://docs.python.org/3/library/re.html#re.sub + """ + if not self._is_prepared or refresh: + self.refresh() + return self.pattern.sub(self.repl, s, count) + + def _compile(self) -> Pattern[str]: + if not self._mapping: + name = self._mapping.__qualname__ # type: ignore[attr-defined] + msg = ( + f"Requires {name!r} to be populated, but got:\n" + f"{name}={self._mapping!r}" + ) + raise TypeError(msg) + return re.compile(rf"{self._fmt_match.format('|'.join(self._mapping))}") + + def _replacer(self) -> Callable[[Match[str]], str]: + def repl(m: Match[str], /) -> str: + return self._fmt_replace.format(self._mapping[m["key"]]) + + return repl + + def __getitem__(self, key: str) -> str: + return self._mapping[key] + + def __setitem__(self, key: str, value: str) -> None: + self._mapping[key] = value + + def __repr__(self) -> str: + return f"{type(self).__name__}(\n {self._mapping!r}\n)" + + +class Special(enum.Enum): + """ + Special-case identifiers. + + Representing ``VegaExprDef`` states that may be otherwise ambiguous. + """ + + NO_PARAMETERS = enum.auto() + + +class VegaExprDef: + """ + ``SchemaInfo``-like, but operates on `expressions.md`_. + + .. _expressions.md: + https://raw.githubusercontent.com/vega/vega/main/docs/docs/expressions.md + """ + + remap_title: ClassVar[ReplaceMany] = ReplaceMany( + fmt_match=r"(?P{0})\(", fmt_replace="{0}(" + ) + + def __init__(self, name: str, children: Sequence[Token], /) -> None: + self.name: str = name + self._children: Sequence[Token] = children + self.parameters: list[VegaExprParam] = [] + self.doc: str = "" + self.signature: str = "" + self._special: set[Special] = set() + + def with_doc(self) -> Self: + """ + Parses docstring content in full. + + Accessible via ``self.doc`` + """ + s: str = parser.render_tokens(self._doc_tokens()) + s = italics_to_backticks(s, self.parameter_names(variadic=False)) + s = type(self).remap_title(s) + self.doc = format_doc(s) + return self + + def with_parameters(self) -> Self: + """ + Parses signature content into an intermediate representation. + + Accessible via ``self.parameters``. + """ + split: Iterator[str] = self._split_signature_tokens(exclude_name=True) + self.parameters = list(VegaExprParam.from_texts(split)) + if not self.parameters: + self._special.add(Special.NO_PARAMETERS) + return self + + def with_signature(self) -> Self: + """ + Parses ``self.parameters`` into a full signature definition line. + + Accessible via ``self.signature`` + """ + param_list = ( + VegaExprParam.star_args() + if self.is_overloaded() + else ", ".join(p.render() for p in self.parameters) + ) + self.signature = METHOD_SIGNATURE.format( + title=self.title, + sep="" if self.is_no_parameters() else ",", + param_list=param_list, + marker="" if (self.is_variadic() or self.is_no_parameters()) else ", /", + return_ann=RETURN_ANNOTATION, + type_ignore=( + f" {IGNORE_OVERRIDE}" if self.is_incompatible_override() else "" + ), + ) + return self + + def parameter_names(self, *, variadic: bool = True) -> Iterator[str]: + """Pass ``variadic=False`` to omit names like``*args``.""" + if self.parameters: + it: Iterator[str] = ( + (p.name for p in self.parameters) + if variadic + else (p.name for p in self.parameters if not p.variadic) + ) + yield from it + elif self.is_no_parameters(): + yield from () + else: + msg = ( + f"Cannot provide `parameter_names` until they have been initialized via:\n" + f"{type(self).__name__}.with_parameters()\n\n" + f"{self!r}" + ) + raise TypeError(msg) + + def render(self) -> str: + """Return fully parsed method definition.""" + if self.is_overloaded(): + body_params = STAR_ARGS[1:] + else: + body_params = ( + f"({self.parameters[0].name},)" + if len(self.parameters) == 1 + else f"({','.join(self.parameter_names())})" + ) + return METHOD_TEMPLATE.format( + decorator=DECORATOR, + signature=self.signature, + doc=self.doc, + return_wrapper=RETURN_WRAPPER, + name=f"{self.name!r}", + body_params=body_params, + ) + + @property + def title(self) -> str: + """ + Use for the method definition, but not when calling internally. + + Updates ``remap_title`` class variable for documentation example substitutions. + """ + title = f"{self.name}_" if self.is_keyword() else self.name + type(self).remap_title.update({self.name: f"alt.expr.{title}"}) + return title + + def _signature_tokens(self) -> Iterator[Token]: + """ + Target for signature appears between 2 softbreak tokens. + + - Proceeds to the first token **after** a softbreak + - Yield **only** text tokens + - Skips all inline html tags + - Stops at 2nd softbreak + """ + it: Iterator[Token] = iter(self) + current = next(it) + while current[TYPE] != SOFTBREAK: + current = next(it) + next(it) + for target in it: + if target[TYPE] == TEXT: + yield target + elif target[TYPE] == SOFTBREAK: + break + else: + continue + + def _split_signature_tokens(self, *, exclude_name: bool = False) -> Iterator[str]: + """ + Normalize the text content of the signature. + + Examples + -------- + The following definition: + + # + sequence([start, ]stop[, step])
+ Returns an array containing an arithmetic sequence of numbers. + ... + + Will yield: + + ['sequence', '(', '[', 'start', ']', 'stop', '[', 'step', ']', ')'] + + When called with ``exclude_name=True``: + + ['(', '[', 'start', ']', 'stop', '[', 'step', ']', ')'] + """ + EXCLUDE_INNER: set[str] = {self.name} if exclude_name else set() + EXCLUDE: set[str] = {", "} | EXCLUDE_INNER + for token in self._signature_tokens(): + raw: str = token[RAW] + if raw == OPEN_PAREN: + yield raw + elif raw.startswith(OPEN_PAREN): + yield raw[0] + for s in raw[1:].split(","): + if (clean := s.strip(" -")) not in EXCLUDE_INNER: + yield from VegaExprDef._split_markers(clean) + elif (clean := raw.strip(", -")) not in EXCLUDE: + yield from VegaExprDef._split_markers(clean) + + @staticmethod + def _split_markers(s: str, /) -> Iterator[str]: + """ + When ``s`` ends with one of these markers: + + ")", "]", "...", " |" + + - Split ``s`` into rest, match + - using the length of the match to index + - Append match to ``end`` + - Recurse + """ # noqa: D400 + if s.isalnum(): + yield s + else: + end: list[str] = [] + if s.endswith((CLOSE_PAREN, CLOSE_BRACKET)): + end.append(s[-1]) + s = s[:-1] + elif s.endswith(ELLIPSIS): + end.append(s[-3:]) + s = s[:-3] + elif s.endswith(INLINE_OVERLOAD): + end.append(s[-2:]) + s = s[:-2] + if len(s) == 1: + yield s + elif len(s) > 1: + yield from VegaExprDef._split_markers(s) + yield from end + + def _doc_tokens(self) -> Sequence[Token]: + """Return the slice of `self.children` that contains docstring content.""" + for idx, item in enumerate(self): + if item[TYPE] == SOFTBREAK and self[idx + 1][TYPE] == TEXT: + return self[idx + 1 :] + else: + continue + msg = ( + f"Expected to find a text node marking the start of docstring content.\n" + f"Failed for:\n\n{self!r}" + ) + raise NotImplementedError(msg) + + def is_callable(self) -> bool: + """ + Rough filter for excluding `constants`_. + + - Most of the parsing is to handle varying signatures. + - Constants can just be referenced by name, so can skip those + + Notes + ----- + - Overwriting the with the rendered text + - required for `clamprange` -> `clampRange` + + .. _constants: + https://vega.github.io/vega/docs/expressions/#constants + """ + if self.is_overloaded_string_array() or self.is_bound_variable_name(): + return False + it: Iterator[Token] = iter(self) + current: str = next(it, {}).get(RAW, "") + name: str = self.name.casefold() + while current.casefold() != name: + if (el := next(it, None)) is not None: + current = el.get(RAW, "") + else: + return False + if current != self.name: + self.name = current + next(it) + return next(it).get(RAW, "").startswith(OPEN_PAREN) + + def is_bound_variable_name(self) -> bool: + """ + ``Vega`` `bound variables`_. + + These do not provide signatures: + + {"datum", "event", "signal"} + + .. _bound variables: + https://vega.github.io/vega/docs/expressions/#bound-variables + """ + RESERVED_NAMES: set[str] = {"datum", "event", "signal"} + return self.name in RESERVED_NAMES + + def is_overloaded(self) -> bool: + """ + Covers the `color functions`_. + + These look like: + + lab(l, a, b[, opacity]) | lab(specifier) + + Looping of parameters is for signatures like `sequence`_: + + sequence([start, ]stop[, step]) + + The optional first parameter, followed by a required one would need an + ``@overload`` in ``python``. + + .. _color functions: + https://vega.github.io/vega/docs/expressions/#color-functions + .. _sequence: + https://vega.github.io/vega/docs/expressions/#sequence + """ + for idx, item in enumerate(self): + if item[TYPE] == TEXT and item.get(RAW, "").endswith(INLINE_OVERLOAD): + return self[idx + 1][TYPE] == SOFTBREAK + else: + continue + for idx, p in enumerate(self.parameters): + if not p.required: + others = self.parameters[idx + 1 :] + if not others: + return False + else: + return any(sp.required for sp in others) + + return False + + def is_overloaded_string_array(self) -> bool: + """ + HACK: There are string/array functions that overlap. + + - the `.md` handles this by prefixing the ` bool: + return keyword.iskeyword(self.name) + + def is_incompatible_override(self) -> bool: + """ + ``self.title`` shadows an unrelated ``SchemaBase`` method. + + Requires an ignore comment for a type checker. + """ + return self.title in _SCHEMA_BASE_MEMBERS + + def is_variadic(self) -> bool: + """Position-only parameter separator `"/"` not allowed after `"*"` parameter.""" + return self.is_overloaded() or any(p.variadic for p in self.parameters) + + def is_no_parameters(self) -> bool: + """ + Signature has been parsed for parameters, but none were present. + + For example the definition for `now`_ would **only** return ``True`` + after calling ``self.with_parameters()``. + + .. _now: + https://vega.github.io/vega/docs/expressions/#now + """ + return bool(self._special) and Special.NO_PARAMETERS in self._special + + def __iter__(self) -> Iterator[Token]: + yield from self._children + + @overload + def __getitem__(self, index: int) -> Token: ... + @overload + def __getitem__(self, index: slice) -> Sequence[Token]: ... + def __getitem__(self, index: int | slice) -> Token | Sequence[Token]: + return self._children.__getitem__(index) + + def __repr__(self) -> str: + return ( + f"{type(self).__name__}(\n " + f"name={self.name!r},\n " + f"parameters={self.parameters!r},\n " + f"doc={self.doc!r}\n" + ")" + ) + + @classmethod + def from_tokens(cls, tokens: Iterable[Token], /) -> Iterator[Self]: + """ + Lazy, filtered partial parser. + + Applies a series of filters before rendering everything but the docs. + + Parameters + ---------- + tokens + `ast tokens`_ produced by ``mistune`` + + .. _ast tokens: + https://mistune.lepture.com/en/latest/guide.html#abstract-syntax-tree + """ + for tok in tokens: + if ( + (children := tok.get(CHILDREN)) is not None + and (child := next(iter(children)).get(RAW)) is not None + and (match := FUNCTION_DEF_LINE.match(child)) + and (node := cls(match["name"], children)).is_callable() + ): + yield node.with_parameters().with_signature() + + +@dataclasses.dataclass +class VegaExprParam: + name: str + required: bool + variadic: bool = False + + @staticmethod + def star_args() -> LiteralString: + return f"{STAR_ARGS}: Any" + + def render(self) -> str: + """Return as an annotated parameter, with a default if needed.""" + if self.required: + return f"{self.name}: {INPUT_ANNOTATION}" + elif not self.variadic: + return f"{self.name}: {INPUT_ANNOTATION} = {NONE}" + else: + return self.star_args() + + @classmethod + def from_texts(cls, raw_texts: Iterable[str], /) -> Iterator[Self]: + """Yields an ordered parameter list.""" + is_required: bool = True + for s in raw_texts: + if s not in {OPEN_PAREN, CLOSE_PAREN}: + if s == OPEN_BRACKET: + is_required = False + continue + elif s == CLOSE_BRACKET: + is_required = True + continue + elif s.isalnum(): + yield cls(s, required=is_required) + elif s == ELLIPSIS: + yield cls(STAR_ARGS, required=False, variadic=True) + else: + continue + + +def expand_urls(url: str, /) -> str: + if url.startswith("#"): + url = f"{EXPRESSIONS_DOCS_URL}{url}" + else: + url = url.replace(r"../", VEGA_DOCS_URL) + return url + + +def format_doc(doc: str, /) -> str: + """ + Format rendered docstring content. + + Primarily used to prevent wrapping on `summary line`_ and references. + + Notes + ----- + - Source is very different to `vega-lite` + - There are no real sections, so these are created here + - Single line docs are unchanged + - Multi-line have everything following the first line wrappped. + - With a double break inserted for a summary line + - Reference-like links section (if present) are also ommitted from wrapping + + .. _summary line: + https://numpydoc.readthedocs.io/en/latest/format.html#short-summary + """ + sentences: deque[str] = deque(SENTENCE_BREAK.split(doc)) + if len(sentences) > 1: + references: str = "" + summary = f"{sentences.popleft()}.\n" + last_line = sentences.pop().strip() + sentences = deque(f"{s}. " for s in sentences) + if SECTION_BREAK in last_line: + last_line, references = last_line.split(SECTION_BREAK, maxsplit=1) + sentences.append(last_line) + sentences = deque(text_wrap.wrap("".join(sentences))) + sentences.appendleft(summary) + if references: + sentences.extend(("", indent(references, METHOD_INDENT))) + return "\n".join(sentences) + elif SECTION_BREAK in doc: + # NOTE: 2 cases have a single line with a reference + summary, references = doc.split(SECTION_BREAK, maxsplit=1) + return "\n".join((summary, "", indent(references, METHOD_INDENT))) + else: + return sentences.pop().strip() + + +def italics_to_backticks(s: str, names: Iterable[str], /) -> str: + """ + Perform a targeted replacement, considering links. + + Parameters + ---------- + s + String containing rendered `.rst`. + names + Group of names the replacement applies to. + + Notes + ----- + - Avoids adding backticks to parameter names that are also used in a link. + - All cases of these are for `unit|units`. + + Examples + -------- + >>> italics_to_backticks( + ... "some text and *name* and more text but also *other* text", + ... ("name", "other"), + ... ) + 'some text and ``name`` and more text but also ``other`` text' + """ + pattern = rf"(?P[^`_])\*(?P{'|'.join(names)})\*(?P[^`])" + return re.sub(pattern, r"\g``\g``\g", s) + + +def parse_expressions(source: Url | Path, /) -> Iterator[VegaExprDef]: + """ + Download remote or read local `.md` resource and eagerly parse signatures of relevant definitions. + + Yields with docs to ensure each can use all remapped names, regardless of the order they appear. + """ + tokens = read_ast_tokens(source) + expr_defs = tuple(VegaExprDef.from_tokens(tokens)) + VegaExprDef.remap_title.refresh() + for expr_def in expr_defs: + yield expr_def.with_doc() + + +def write_expr_module(version: str, output: Path, *, header: str) -> None: + """ + Parse an ``expressions.md`` into a ``.py`` module. + + Parameters + ---------- + version + Vega release version, e.g. ``"v5.30.0"``. + output + Target path to write to. + """ + version = version if version.startswith("v") else f"v{version}" + url = EXPRESSIONS_URL_TEMPLATE.format(version=version) + content = ( + MODULE_PRE.format( + header=header, + metaclass=CLS_META, + const=CONST_WRAPPER, + return_ann=RETURN_ANNOTATION, + input_ann=INPUT_ANNOTATION, + func=RETURN_WRAPPER, + ), + CLS_TEMPLATE.format( + base="_ExprRef", + metaclass=CLS_META, + doc=CLS_DOC, + type_ignore=IGNORE_MISC, + ), + ) + contents = chain( + content, + (expr_def.render() for expr_def in parse_expressions(url)), + [MODULE_POST], + ) + print(f"Generating\n {url!s}\n ->{output!s}") + ruff.write_lint_format(output, contents)