From 12cf076118570eebbff08c6b3090e0d4798447a1 Mon Sep 17 00:00:00 2001 From: cyfraeviolae Date: Wed, 3 Apr 2024 03:17:55 -0400 Subject: no venv --- .../site-packages/sqlalchemy/util/compat.py | 300 --------------------- 1 file changed, 300 deletions(-) delete mode 100644 venv/lib/python3.11/site-packages/sqlalchemy/util/compat.py (limited to 'venv/lib/python3.11/site-packages/sqlalchemy/util/compat.py') diff --git a/venv/lib/python3.11/site-packages/sqlalchemy/util/compat.py b/venv/lib/python3.11/site-packages/sqlalchemy/util/compat.py deleted file mode 100644 index e1b5e66..0000000 --- a/venv/lib/python3.11/site-packages/sqlalchemy/util/compat.py +++ /dev/null @@ -1,300 +0,0 @@ -# util/compat.py -# Copyright (C) 2005-2024 the SQLAlchemy authors and contributors -# -# -# This module is part of SQLAlchemy and is released under -# the MIT License: https://www.opensource.org/licenses/mit-license.php -# mypy: allow-untyped-defs, allow-untyped-calls - -"""Handle Python version/platform incompatibilities.""" - -from __future__ import annotations - -import base64 -import dataclasses -import hashlib -import inspect -import operator -import platform -import sys -import typing -from typing import Any -from typing import Callable -from typing import Dict -from typing import Iterable -from typing import List -from typing import Mapping -from typing import Optional -from typing import Sequence -from typing import Set -from typing import Tuple -from typing import Type -from typing import TypeVar - - -py312 = sys.version_info >= (3, 12) -py311 = sys.version_info >= (3, 11) -py310 = sys.version_info >= (3, 10) -py39 = sys.version_info >= (3, 9) -py38 = sys.version_info >= (3, 8) -pypy = platform.python_implementation() == "PyPy" -cpython = platform.python_implementation() == "CPython" - -win32 = sys.platform.startswith("win") -osx = sys.platform.startswith("darwin") -arm = "aarch" in platform.machine().lower() -is64bit = sys.maxsize > 2**32 - -has_refcount_gc = bool(cpython) - -dottedgetter = operator.attrgetter - -_T_co = TypeVar("_T_co", covariant=True) - - -class FullArgSpec(typing.NamedTuple): - args: List[str] - varargs: Optional[str] - varkw: Optional[str] - defaults: Optional[Tuple[Any, ...]] - kwonlyargs: List[str] - kwonlydefaults: Dict[str, Any] - annotations: Dict[str, Any] - - -def inspect_getfullargspec(func: Callable[..., Any]) -> FullArgSpec: - """Fully vendored version of getfullargspec from Python 3.3.""" - - if inspect.ismethod(func): - func = func.__func__ - if not inspect.isfunction(func): - raise TypeError(f"{func!r} is not a Python function") - - co = func.__code__ - if not inspect.iscode(co): - raise TypeError(f"{co!r} is not a code object") - - nargs = co.co_argcount - names = co.co_varnames - nkwargs = co.co_kwonlyargcount - args = list(names[:nargs]) - kwonlyargs = list(names[nargs : nargs + nkwargs]) - - nargs += nkwargs - varargs = None - if co.co_flags & inspect.CO_VARARGS: - varargs = co.co_varnames[nargs] - nargs = nargs + 1 - varkw = None - if co.co_flags & inspect.CO_VARKEYWORDS: - varkw = co.co_varnames[nargs] - - return FullArgSpec( - args, - varargs, - varkw, - func.__defaults__, - kwonlyargs, - func.__kwdefaults__, - func.__annotations__, - ) - - -if py39: - # python stubs don't have a public type for this. not worth - # making a protocol - def md5_not_for_security() -> Any: - return hashlib.md5(usedforsecurity=False) - -else: - - def md5_not_for_security() -> Any: - return hashlib.md5() - - -if typing.TYPE_CHECKING or py38: - from importlib import metadata as importlib_metadata -else: - import importlib_metadata # noqa - - -if typing.TYPE_CHECKING or py39: - # pep 584 dict union - dict_union = operator.or_ # noqa -else: - - def dict_union(a: dict, b: dict) -> dict: - a = a.copy() - a.update(b) - return a - - -if py310: - anext_ = anext -else: - _NOT_PROVIDED = object() - from collections.abc import AsyncIterator - - async def anext_(async_iterator, default=_NOT_PROVIDED): - """vendored from https://github.com/python/cpython/pull/8895""" - - if not isinstance(async_iterator, AsyncIterator): - raise TypeError( - f"anext expected an AsyncIterator, got {type(async_iterator)}" - ) - anxt = type(async_iterator).__anext__ - try: - return await anxt(async_iterator) - except StopAsyncIteration: - if default is _NOT_PROVIDED: - raise - return default - - -def importlib_metadata_get(group): - ep = importlib_metadata.entry_points() - if typing.TYPE_CHECKING or hasattr(ep, "select"): - return ep.select(group=group) - else: - return ep.get(group, ()) - - -def b(s): - return s.encode("latin-1") - - -def b64decode(x: str) -> bytes: - return base64.b64decode(x.encode("ascii")) - - -def b64encode(x: bytes) -> str: - return base64.b64encode(x).decode("ascii") - - -def decode_backslashreplace(text: bytes, encoding: str) -> str: - return text.decode(encoding, errors="backslashreplace") - - -def cmp(a, b): - return (a > b) - (a < b) - - -def _formatannotation(annotation, base_module=None): - """vendored from python 3.7""" - - if isinstance(annotation, str): - return annotation - - if getattr(annotation, "__module__", None) == "typing": - return repr(annotation).replace("typing.", "").replace("~", "") - if isinstance(annotation, type): - if annotation.__module__ in ("builtins", base_module): - return repr(annotation.__qualname__) - return annotation.__module__ + "." + annotation.__qualname__ - elif isinstance(annotation, typing.TypeVar): - return repr(annotation).replace("~", "") - return repr(annotation).replace("~", "") - - -def inspect_formatargspec( - args: List[str], - varargs: Optional[str] = None, - varkw: Optional[str] = None, - defaults: Optional[Sequence[Any]] = None, - kwonlyargs: Optional[Sequence[str]] = (), - kwonlydefaults: Optional[Mapping[str, Any]] = {}, - annotations: Mapping[str, Any] = {}, - formatarg: Callable[[str], str] = str, - formatvarargs: Callable[[str], str] = lambda name: "*" + name, - formatvarkw: Callable[[str], str] = lambda name: "**" + name, - formatvalue: Callable[[Any], str] = lambda value: "=" + repr(value), - formatreturns: Callable[[Any], str] = lambda text: " -> " + str(text), - formatannotation: Callable[[Any], str] = _formatannotation, -) -> str: - """Copy formatargspec from python 3.7 standard library. - - Python 3 has deprecated formatargspec and requested that Signature - be used instead, however this requires a full reimplementation - of formatargspec() in terms of creating Parameter objects and such. - Instead of introducing all the object-creation overhead and having - to reinvent from scratch, just copy their compatibility routine. - - Ultimately we would need to rewrite our "decorator" routine completely - which is not really worth it right now, until all Python 2.x support - is dropped. - - """ - - kwonlydefaults = kwonlydefaults or {} - annotations = annotations or {} - - def formatargandannotation(arg): - result = formatarg(arg) - if arg in annotations: - result += ": " + formatannotation(annotations[arg]) - return result - - specs = [] - if defaults: - firstdefault = len(args) - len(defaults) - else: - firstdefault = -1 - - for i, arg in enumerate(args): - spec = formatargandannotation(arg) - if defaults and i >= firstdefault: - spec = spec + formatvalue(defaults[i - firstdefault]) - specs.append(spec) - - if varargs is not None: - specs.append(formatvarargs(formatargandannotation(varargs))) - else: - if kwonlyargs: - specs.append("*") - - if kwonlyargs: - for kwonlyarg in kwonlyargs: - spec = formatargandannotation(kwonlyarg) - if kwonlydefaults and kwonlyarg in kwonlydefaults: - spec += formatvalue(kwonlydefaults[kwonlyarg]) - specs.append(spec) - - if varkw is not None: - specs.append(formatvarkw(formatargandannotation(varkw))) - - result = "(" + ", ".join(specs) + ")" - if "return" in annotations: - result += formatreturns(formatannotation(annotations["return"])) - return result - - -def dataclass_fields(cls: Type[Any]) -> Iterable[dataclasses.Field[Any]]: - """Return a sequence of all dataclasses.Field objects associated - with a class as an already processed dataclass. - - The class must **already be a dataclass** for Field objects to be returned. - - """ - - if dataclasses.is_dataclass(cls): - return dataclasses.fields(cls) - else: - return [] - - -def local_dataclass_fields(cls: Type[Any]) -> Iterable[dataclasses.Field[Any]]: - """Return a sequence of all dataclasses.Field objects associated with - an already processed dataclass, excluding those that originate from a - superclass. - - The class must **already be a dataclass** for Field objects to be returned. - - """ - - if dataclasses.is_dataclass(cls): - super_fields: Set[dataclasses.Field[Any]] = set() - for sup in cls.__bases__: - super_fields.update(dataclass_fields(sup)) - return [f for f in dataclasses.fields(cls) if f not in super_fields] - else: - return [] -- cgit v1.2.3