aDriv4 website!

Linux host71.registrar-servers.com 4.18.0-553.54.1.lve.el8.x86_64 #1 SMP Wed Jun 4 13:01:13 UTC 2025 x86_64
Apache
199.188.205.52

File Name : schema.py

# testing/schema.py
# Copyright (C) 2005-2025 the SQLAlchemy authors and contributors
# <see AUTHORS file>
#
# This module is part of SQLAlchemy and is released under
# the MIT License: https://www.opensource.org/licenses/mit-license.php
# mypy: ignore-errors

from __future__ import annotations

import sys

from . import config
from . import exclusions
from .. import event
from .. import schema
from .. import types as sqltypes
from ..orm import mapped_column as _orm_mapped_column
from ..util import OrderedDict

__all__ = ["Table", "Column"]

table_options = {}

def Table(*args, **kw) -> schema.Table:
    """A schema.Table wrapper/hook for dialect-specific tweaks."""

test_opts = {k: kw.pop(k) for k in list(kw) if k.startswith("test_")}

kw.update(table_options)

if exclusions.against(config._current, "mysql"):
        if (
            "mysql_engine" not in kw
            and "mysql_type" not in kw
            and "autoload_with" not in kw
        ):
            if "test_needs_fk" in test_opts or "test_needs_acid" in test_opts:
                kw["mysql_engine"] = "InnoDB"
            else:
                # there are in fact test fixtures that rely upon MyISAM,
                # due to MySQL / MariaDB having poor FK behavior under innodb,
                # such as a self-referential table can't be deleted from at
                # once without attending to per-row dependencies.  We'd need to
                # add special steps to some fixtures if we want to not
                # explicitly state MyISAM here
                kw["mysql_engine"] = "MyISAM"
    elif exclusions.against(config._current, "mariadb"):
        if (
            "mariadb_engine" not in kw
            and "mariadb_type" not in kw
            and "autoload_with" not in kw
        ):
            if "test_needs_fk" in test_opts or "test_needs_acid" in test_opts:
                kw["mariadb_engine"] = "InnoDB"
            else:
                kw["mariadb_engine"] = "MyISAM"

return schema.Table(*args, **kw)

def mapped_column(*args, **kw):
    """An orm.mapped_column wrapper/hook for dialect-specific tweaks."""

return _schema_column(_orm_mapped_column, args, kw)

def Column(*args, **kw):
    """A schema.Column wrapper/hook for dialect-specific tweaks."""

return _schema_column(schema.Column, args, kw)

def _schema_column(factory, args, kw):
    test_opts = {k: kw.pop(k) for k in list(kw) if k.startswith("test_")}

if not config.requirements.foreign_key_ddl.enabled_for_config(config):
        args = [arg for arg in args if not isinstance(arg, schema.ForeignKey)]

construct = factory(*args, **kw)

if factory is schema.Column:
        col = construct
    else:
        col = construct.column

if test_opts.get("test_needs_autoincrement", False) and kw.get(
        "primary_key", False
    ):
        if col.default is None and col.server_default is None:
            col.autoincrement = True

# allow any test suite to pick up on this
        col.info["test_needs_autoincrement"] = True

# hardcoded rule for oracle; this should
        # be moved out
        if exclusions.against(config._current, "oracle"):

def add_seq(c, tbl):
                c._init_items(
                    schema.Sequence(
                        _truncate_name(
                            config.db.dialect, tbl.name + "_" + c.name + "_seq"
                        ),
                        optional=True,
                    )
                )

event.listen(col, "after_parent_attach", add_seq, propagate=True)
    return construct

class eq_type_affinity:
    """Helper to compare types inside of datastructures based on affinity.

E.g.::

eq_(
            inspect(connection).get_columns("foo"),
            [
                {
                    "name": "id",
                    "type": testing.eq_type_affinity(sqltypes.INTEGER),
                    "nullable": False,
                    "default": None,
                    "autoincrement": False,
                },
                {
                    "name": "data",
                    "type": testing.eq_type_affinity(sqltypes.NullType),
                    "nullable": True,
                    "default": None,
                    "autoincrement": False,
                },
            ],
        )

"""

def __init__(self, target):
        self.target = sqltypes.to_instance(target)

def __eq__(self, other):
        return self.target._type_affinity is other._type_affinity

def __ne__(self, other):
        return self.target._type_affinity is not other._type_affinity

class eq_compile_type:
    """similar to eq_type_affinity but uses compile"""

def __init__(self, target):
        self.target = target

def __eq__(self, other):
        return self.target == other.compile()

def __ne__(self, other):
        return self.target != other.compile()

class eq_clause_element:
    """Helper to compare SQL structures based on compare()"""

def __init__(self, target):
        self.target = target

def __eq__(self, other):
        return self.target.compare(other)

def __ne__(self, other):
        return not self.target.compare(other)

def _truncate_name(dialect, name):
    if len(name) > dialect.max_identifier_length:
        return (
            name[0 : max(dialect.max_identifier_length - 6, 0)]
            + "_"
            + hex(hash(name) % 64)[2:]
        )
    else:
        return name

def pep435_enum(name):
    # Implements PEP 435 in the minimal fashion needed by SQLAlchemy
    __members__ = OrderedDict()

def __init__(self, name, value, alias=None):
        self.name = name
        self.value = value
        self.__members__[name] = self
        value_to_member[value] = self
        setattr(self.__class__, name, self)
        if alias:
            self.__members__[alias] = self
            setattr(self.__class__, alias, self)

value_to_member = {}

@classmethod
    def get(cls, value):
        return value_to_member[value]

someenum = type(
        name,
        (object,),
        {"__members__": __members__, "__init__": __init__, "get": get},
    )

# getframe() trick for pickling I don't understand courtesy
    # Python namedtuple()
    try:
        module = sys._getframe(1).f_globals.get("__name__", "__main__")
    except (AttributeError, ValueError):
        pass
    if module is not None:
        someenum.__module__ = module

return someenum

Name	Type	Size	Owner/Group	Permission	Last Modified	Actions
.	dir	-	root/root	0755	2025-04-04 08:09:19
..	dir	-	root/root	0755	2025-04-04 08:09:17
__pycache__	dir	-	root/root	0755	2025-04-04 08:09:19
fixtures	dir	-	root/root	0755	2025-04-04 08:09:19
plugin	dir	-	root/root	0755	2025-04-04 08:09:19
suite	dir	-	root/root	0755	2025-04-04 08:09:19
__init__.py	text/x-script.python	3.09 KB	root/root	0644	2025-04-04 08:09:17
assertions.py	text/x-script.python	30.7 KB	root/root	0644	2025-04-04 08:09:17
assertsql.py	text/x-script.python	16.42 KB	root/root	0644	2025-04-04 08:09:17
asyncio.py	text/x-script.python	3.74 KB	root/root	0644	2025-04-04 08:09:17
config.py	text/x-script.python	11.78 KB	root/root	0644	2025-04-04 08:09:17
engines.py	text/x-script.python	13.1 KB	root/root	0644	2025-04-04 08:09:17
entities.py	text/x-script.python	3.28 KB	root/root	0644	2025-04-04 08:09:17
exclusions.py	text/x-script.python	12.17 KB	root/root	0644	2025-04-04 08:09:17
pickleable.py	text/x-script.python	2.77 KB	root/root	0644	2025-04-04 08:09:17
profiling.py	text/x-script.python	9.91 KB	root/root	0644	2025-04-04 08:09:17
provision.py	text/x-script.python	14.36 KB	root/root	0644	2025-04-04 08:09:17
requirements.py	text/x-script.python	51.88 KB	root/root	0644	2025-04-04 08:09:17
schema.py	text/x-script.python	6.36 KB	root/root	0644	2025-04-04 08:09:17
util.py	text/x-script.python	14.23 KB	root/root	0644	2025-04-04 08:09:17
warnings.py	text/x-script.python	1.51 KB	root/root	0644	2025-04-04 08:09:17

For more Private tool come to me!

https://t.me/aDriv4vz