jaclang 0.6.1__py3-none-any.whl → 0.6.2__py3-none-any.whl

jaclang/vendor/mypy/typeshed/stdlib/statistics.pyi

@@ -0,0 +1,151 @@
+import sys
+from _typeshed import SupportsRichComparisonT
+from collections.abc import Hashable, Iterable, Sequence
+from decimal import Decimal
+from fractions import Fraction
+from typing import Any, Literal, NamedTuple, SupportsFloat, TypeVar
+from typing_extensions import Self, TypeAlias
+
+__all__ = [
+    "StatisticsError",
+    "fmean",
+    "geometric_mean",
+    "mean",
+    "harmonic_mean",
+    "pstdev",
+    "pvariance",
+    "stdev",
+    "variance",
+    "median",
+    "median_low",
+    "median_high",
+    "median_grouped",
+    "mode",
+    "multimode",
+    "NormalDist",
+    "quantiles",
+]
+
+if sys.version_info >= (3, 10):
+    __all__ += ["covariance", "correlation", "linear_regression"]
+
+# Most functions in this module accept homogeneous collections of one of these types
+_Number: TypeAlias = float | Decimal | Fraction
+_NumberT = TypeVar("_NumberT", float, Decimal, Fraction)
+
+# Used in mode, multimode
+_HashableT = TypeVar("_HashableT", bound=Hashable)
+
+class StatisticsError(ValueError): ...
+
+if sys.version_info >= (3, 11):
+    def fmean(
+        data: Iterable[SupportsFloat], weights: Iterable[SupportsFloat] | None = None
+    ) -> float: ...
+
+else:
+    def fmean(data: Iterable[SupportsFloat]) -> float: ...
+
+def geometric_mean(data: Iterable[SupportsFloat]) -> float: ...
+def mean(data: Iterable[_NumberT]) -> _NumberT: ...
+
+if sys.version_info >= (3, 10):
+    def harmonic_mean(
+        data: Iterable[_NumberT], weights: Iterable[_Number] | None = None
+    ) -> _NumberT: ...
+
+else:
+    def harmonic_mean(data: Iterable[_NumberT]) -> _NumberT: ...
+
+def median(data: Iterable[_NumberT]) -> _NumberT: ...
+def median_low(data: Iterable[SupportsRichComparisonT]) -> SupportsRichComparisonT: ...
+def median_high(data: Iterable[SupportsRichComparisonT]) -> SupportsRichComparisonT: ...
+
+if sys.version_info >= (3, 11):
+    def median_grouped(
+        data: Iterable[SupportsFloat], interval: SupportsFloat = 1.0
+    ) -> float: ...
+
+else:
+    def median_grouped(
+        data: Iterable[_NumberT], interval: _NumberT | float = 1
+    ) -> _NumberT | float: ...
+
+def mode(data: Iterable[_HashableT]) -> _HashableT: ...
+def multimode(data: Iterable[_HashableT]) -> list[_HashableT]: ...
+def pstdev(data: Iterable[_NumberT], mu: _NumberT | None = None) -> _NumberT: ...
+def pvariance(data: Iterable[_NumberT], mu: _NumberT | None = None) -> _NumberT: ...
+def quantiles(
+    data: Iterable[_NumberT],
+    *,
+    n: int = 4,
+    method: Literal["inclusive", "exclusive"] = "exclusive"
+) -> list[_NumberT]: ...
+def stdev(data: Iterable[_NumberT], xbar: _NumberT | None = None) -> _NumberT: ...
+def variance(data: Iterable[_NumberT], xbar: _NumberT | None = None) -> _NumberT: ...
+
+class NormalDist:
+    def __init__(self, mu: float = 0.0, sigma: float = 1.0) -> None: ...
+    @property
+    def mean(self) -> float: ...
+    @property
+    def median(self) -> float: ...
+    @property
+    def mode(self) -> float: ...
+    @property
+    def stdev(self) -> float: ...
+    @property
+    def variance(self) -> float: ...
+    @classmethod
+    def from_samples(cls, data: Iterable[SupportsFloat]) -> Self: ...
+    def samples(self, n: int, *, seed: Any | None = None) -> list[float]: ...
+    def pdf(self, x: float) -> float: ...
+    def cdf(self, x: float) -> float: ...
+    def inv_cdf(self, p: float) -> float: ...
+    def overlap(self, other: NormalDist) -> float: ...
+    def quantiles(self, n: int = 4) -> list[float]: ...
+    if sys.version_info >= (3, 9):
+        def zscore(self, x: float) -> float: ...
+
+    def __eq__(self, x2: object) -> bool: ...
+    def __add__(self, x2: float | NormalDist) -> NormalDist: ...
+    def __sub__(self, x2: float | NormalDist) -> NormalDist: ...
+    def __mul__(self, x2: float) -> NormalDist: ...
+    def __truediv__(self, x2: float) -> NormalDist: ...
+    def __pos__(self) -> NormalDist: ...
+    def __neg__(self) -> NormalDist: ...
+    __radd__ = __add__
+    def __rsub__(self, x2: float | NormalDist) -> NormalDist: ...
+    __rmul__ = __mul__
+    def __hash__(self) -> int: ...
+
+if sys.version_info >= (3, 12):
+    def correlation(
+        __x: Sequence[_Number],
+        __y: Sequence[_Number],
+        *,
+        method: Literal["linear", "ranked"] = "linear"
+    ) -> float: ...
+
+elif sys.version_info >= (3, 10):
+    def correlation(__x: Sequence[_Number], __y: Sequence[_Number]) -> float: ...
+
+if sys.version_info >= (3, 10):
+    def covariance(__x: Sequence[_Number], __y: Sequence[_Number]) -> float: ...
+
+    class LinearRegression(NamedTuple):
+        slope: float
+        intercept: float
+
+if sys.version_info >= (3, 11):
+    def linear_regression(
+        __regressor: Sequence[_Number],
+        __dependent_variable: Sequence[_Number],
+        *,
+        proportional: bool = False
+    ) -> LinearRegression: ...
+
+elif sys.version_info >= (3, 10):
+    def linear_regression(
+        __regressor: Sequence[_Number], __dependent_variable: Sequence[_Number]
+    ) -> LinearRegression: ...

jaclang/vendor/mypy/typeshed/stdlib/string.pyi

@@ -0,0 +1,112 @@
+import sys
+from _typeshed import StrOrLiteralStr
+from collections.abc import Iterable, Mapping, Sequence
+from re import Pattern, RegexFlag
+from typing import Any, ClassVar, overload
+from typing_extensions import LiteralString, TypeAlias
+
+__all__ = [
+    "ascii_letters",
+    "ascii_lowercase",
+    "ascii_uppercase",
+    "capwords",
+    "digits",
+    "hexdigits",
+    "octdigits",
+    "printable",
+    "punctuation",
+    "whitespace",
+    "Formatter",
+    "Template",
+]
+
+ascii_letters: LiteralString
+ascii_lowercase: LiteralString
+ascii_uppercase: LiteralString
+digits: LiteralString
+hexdigits: LiteralString
+octdigits: LiteralString
+punctuation: LiteralString
+printable: LiteralString
+whitespace: LiteralString
+
+def capwords(
+    s: StrOrLiteralStr, sep: StrOrLiteralStr | None = None
+) -> StrOrLiteralStr: ...
+
+if sys.version_info >= (3, 9):
+    _TemplateMetaclass: TypeAlias = type
+else:
+    class _TemplateMetaclass(type):
+        pattern: ClassVar[str]
+        def __init__(
+            cls, name: str, bases: tuple[type, ...], dct: dict[str, Any]
+        ) -> None: ...
+
+class Template(metaclass=_TemplateMetaclass):
+    template: str
+    delimiter: ClassVar[str]
+    idpattern: ClassVar[str]
+    braceidpattern: ClassVar[str | None]
+    flags: ClassVar[RegexFlag]
+    pattern: ClassVar[Pattern[str]]
+    def __init__(self, template: str) -> None: ...
+    def substitute(
+        self, __mapping: Mapping[str, object] = {}, **kwds: object
+    ) -> str: ...
+    def safe_substitute(
+        self, __mapping: Mapping[str, object] = {}, **kwds: object
+    ) -> str: ...
+    if sys.version_info >= (3, 11):
+        def get_identifiers(self) -> list[str]: ...
+        def is_valid(self) -> bool: ...
+
+class Formatter:
+    @overload
+    def format(
+        self,
+        __format_string: LiteralString,
+        *args: LiteralString,
+        **kwargs: LiteralString
+    ) -> LiteralString: ...
+    @overload
+    def format(self, __format_string: str, *args: Any, **kwargs: Any) -> str: ...
+    @overload
+    def vformat(
+        self,
+        format_string: LiteralString,
+        args: Sequence[LiteralString],
+        kwargs: Mapping[LiteralString, LiteralString],
+    ) -> LiteralString: ...
+    @overload
+    def vformat(
+        self, format_string: str, args: Sequence[Any], kwargs: Mapping[str, Any]
+    ) -> str: ...
+    def _vformat(  # undocumented
+        self,
+        format_string: str,
+        args: Sequence[Any],
+        kwargs: Mapping[str, Any],
+        used_args: set[int | str],
+        recursion_depth: int,
+        auto_arg_index: int = 0,
+    ) -> tuple[str, int]: ...
+    def parse(self, format_string: StrOrLiteralStr) -> Iterable[
+        tuple[
+            StrOrLiteralStr,
+            StrOrLiteralStr | None,
+            StrOrLiteralStr | None,
+            StrOrLiteralStr | None,
+        ]
+    ]: ...
+    def get_field(
+        self, field_name: str, args: Sequence[Any], kwargs: Mapping[str, Any]
+    ) -> Any: ...
+    def get_value(
+        self, key: int | str, args: Sequence[Any], kwargs: Mapping[str, Any]
+    ) -> Any: ...
+    def check_unused_args(
+        self, used_args: set[int | str], args: Sequence[Any], kwargs: Mapping[str, Any]
+    ) -> None: ...
+    def format_field(self, value: Any, format_spec: str) -> Any: ...
+    def convert_field(self, value: Any, conversion: str) -> Any: ...

jaclang/vendor/mypy/typeshed/stdlib/stringprep.pyi

@@ -0,0 +1,27 @@
+b1_set: set[int]
+b3_exceptions: dict[int, str]
+c22_specials: set[int]
+c6_set: set[int]
+c7_set: set[int]
+c8_set: set[int]
+c9_set: set[int]
+
+def in_table_a1(code: str) -> bool: ...
+def in_table_b1(code: str) -> bool: ...
+def map_table_b3(code: str) -> str: ...
+def map_table_b2(a: str) -> str: ...
+def in_table_c11(code: str) -> bool: ...
+def in_table_c12(code: str) -> bool: ...
+def in_table_c11_c12(code: str) -> bool: ...
+def in_table_c21(code: str) -> bool: ...
+def in_table_c22(code: str) -> bool: ...
+def in_table_c21_c22(code: str) -> bool: ...
+def in_table_c3(code: str) -> bool: ...
+def in_table_c4(code: str) -> bool: ...
+def in_table_c5(code: str) -> bool: ...
+def in_table_c6(code: str) -> bool: ...
+def in_table_c7(code: str) -> bool: ...
+def in_table_c8(code: str) -> bool: ...
+def in_table_c9(code: str) -> bool: ...
+def in_table_d1(code: str) -> bool: ...
+def in_table_d2(code: str) -> bool: ...

jaclang/vendor/mypy/typeshed/stdlib/struct.pyi

@@ -0,0 +1,43 @@
+from _typeshed import ReadableBuffer, WriteableBuffer
+from collections.abc import Iterator
+from typing import Any
+
+__all__ = [
+    "calcsize",
+    "pack",
+    "pack_into",
+    "unpack",
+    "unpack_from",
+    "iter_unpack",
+    "Struct",
+    "error",
+]
+
+class error(Exception): ...
+
+def pack(__fmt: str | bytes, *v: Any) -> bytes: ...
+def pack_into(
+    __fmt: str | bytes, __buffer: WriteableBuffer, __offset: int, *v: Any
+) -> None: ...
+def unpack(__format: str | bytes, __buffer: ReadableBuffer) -> tuple[Any, ...]: ...
+def unpack_from(
+    __format: str | bytes, buffer: ReadableBuffer, offset: int = 0
+) -> tuple[Any, ...]: ...
+def iter_unpack(
+    __format: str | bytes, __buffer: ReadableBuffer
+) -> Iterator[tuple[Any, ...]]: ...
+def calcsize(__format: str | bytes) -> int: ...
+
+class Struct:
+    @property
+    def format(self) -> str: ...
+    @property
+    def size(self) -> int: ...
+    def __init__(self, format: str | bytes) -> None: ...
+    def pack(self, *v: Any) -> bytes: ...
+    def pack_into(self, buffer: WriteableBuffer, offset: int, *v: Any) -> None: ...
+    def unpack(self, __buffer: ReadableBuffer) -> tuple[Any, ...]: ...
+    def unpack_from(
+        self, buffer: ReadableBuffer, offset: int = 0
+    ) -> tuple[Any, ...]: ...
+    def iter_unpack(self, __buffer: ReadableBuffer) -> Iterator[tuple[Any, ...]]: ...