def map_to(self, attrname, tablename=None, selectable=None, schema=None, base=None, mapper_args=util.immutabledict()): if attrname in self._cache: raise AttributeError('Attibute {} is already mapped to {}'.format( attrname, class_mapper(self._cache[attrname]).mapped_table)) if tablename is not None: if not isinstance(tablename, str): raise ArgumentError( 'Tablename must be a string, type found: {}'.format( type(tablename))) if selectable is not None: raise ArgumentError( '`tablename` and `selectable` are mutually exclusive') selectable = Table(tablename, self.metadata, autoload=True, autoload_with=self.bind, schema=schema or self.schema) elif schema: raise ArgumentError( '`tablename` argument is required when using schema.') elif selectable is not None: if not isinstance(selectable, expression.FromClause): raise ArgumentError('`selectable` argument must be a table,' 'select, joing, or other construct.') else: raise ArgumentError( '`tablename` or `selectable` argument is required.') if not selectable.primary_key.columns and not \ 'primary_key' in mapper_args: if tablename: raise NoForeignKeysError( 'table {} does not have a primary key defined'.format( tablename)) else: raise NoForeignKeysError( 'Selectable {} does not have a primary key defined.'. format(selectable)) mapped_cls = class_for_table(self.sess, self.engine, selectable, base or self.base, mapper_args) self._cache[attrname] = mapped_cls return mapped_cls
def recieve_chat_init(target, args, kwargs): chat_name = kwargs.get('name') if not chat_name: raise ArgumentError("Missing chat name") chat = Chat.query.filter_by(name=chat_name).first() if chat: raise ArgumentError("Chat name must be an unique") users = kwargs['users'] for user in users: user = User.query.get(user.id) if not user: raise ArgumentError("User not found") return kwargs
def new(uri, reinitialize=False, echo=False): """ Factory method for instantiating a database object from a URI. For URI specifications, see SQLiteDatabase, PostgreSQLDatabase. :param echo: echo SQL commands to the console as they are executed by SQLAlchemy. :param reinitialize: drop all tables before (re)creating them :param uri: an RFC 3986 URI pointing to the database :return: An initialized database object or raise an ArgumentError if the URI was not recognizable. """ if uri.startswith('postgresql+psycopg2://'): return PostgreSQLDatabase(uri=uri, reinitialize=reinitialize, echo=echo) if uri.startswith('postgresql://'): return PostgreSQLDatabase(uri=uri, reinitialize=reinitialize, echo=echo) elif uri.startswith('sqlite://'): return SQLiteDatabase(uri=uri, reinitialize=reinitialize, echo=echo) else: raise ArgumentError( 'database URI ({}) not recognized.'.format(uri))
def __init__(self, engine_or_metadata, base=object, session=None): """Initialize a new :class:`.SqlSoup`. :param engine_or_metadata: a string database URL, :class:`.Engine` or :class:`.MetaData` object to associate with. If the argument is a :class:`.MetaData`, it should be *bound* to an :class:`.Engine`. :param base: a class which will serve as the default class for returned mapped classes. Defaults to ``object``. :param session: a :class:`.ScopedSession` or :class:`.Session` with which to associate ORM operations for this :class:`.SqlSoup` instance. If ``None``, a :class:`.ScopedSession` that's local to this module is used. """ self.session = session or Session self.base=base if isinstance(engine_or_metadata, MetaData): self._metadata = engine_or_metadata elif isinstance(engine_or_metadata, (basestring, Engine)): self._metadata = MetaData(engine_or_metadata) else: raise ArgumentError("invalid engine or metadata argument %r" % engine_or_metadata) self._cache = {} self.schema = None
def __init__(self, user_id): if WBUserModel.query.filter_by(id=user_id).count() > 0: self.session_id = binascii.hexlify( os.urandom(self.session_id_byte_length)) self.secret = binascii.hexlify(os.urandom(self.secret_byte_length)) self.user_id = user_id self.created = arrow.utcnow() self.accessed = self.created else: raise ArgumentError('Unknown user id')
def create_engine(uri, relative_to=None, debug=False): """Create a new engine. This works a bit like SQLAlchemy's `create_engine` with the difference that it automaticaly set's MySQL engines to 'utf-8', and paths for SQLite are relative to the path provided as `relative_to`. Furthermore the engine is created with `convert_unicode` by default. """ # special case sqlite. We want nicer urls for that one. if uri.startswith('sqlite:'): match = _sqlite_re.match(uri) if match is None: raise ArgumentError('Could not parse rfc1738 URL') database, query = match.groups() if database is None: database = ':memory:' elif relative_to is not None: database = path.join(relative_to, database) if query: query = url_decode(query).to_dict() else: query = {} info = URL('sqlite', database=database, query=query) else: info = make_url(uri) # if mysql is the database engine and no connection encoding is # provided we set it to utf-8 if info.drivername == 'mysql': info.query.setdefault('charset', 'utf8') options = {'convert_unicode': True} # alternative pool sizes / recycle settings and more. These are # interpreter wide and not from the config for the following reasons: # # - system administrators can set it independently from the webserver # configuration via SetEnv and friends. # - this setting is deployment dependent should not affect a development # server for the same instance or a development shell for key in 'pool_size', 'pool_recycle', 'pool_timeout': value = os.environ.get('ZINE_DATABASE_' + key.upper()) if value is not None: options[key] = int(value) # if debugging is enabled, hook the ConnectionDebugProxy in if debug: options['proxy'] = ConnectionDebugProxy() return sqlalchemy.create_engine(info, **options)
def set_isolation_level(self, connection, level): if level is None: level = 'CS' else: if len(level.strip()) < 1: level = 'CS' level = level.upper().replace("-", " ").replace("_", " ") if level not in self._isolation_lookup: raise ArgumentError( "Invalid value '%s' for isolation_level. " "Valid isolation levels for %s are %s" % (level, self.name, ", ".join(self._isolation_lookup))) attrib = { SQL_ATTR_TXN_ISOLATION: self._get_cli_isolation_levels(level) } res = connection.set_option(attrib)
def set_isolation_level(self, connection, level): if level is None: level = 'CS' else: if len(level.strip()) < 1: level = 'CS' level.upper().replace("-", " ") if level not in self._isolation_lookup: raise ArgumentError( "Invalid value '%s' for isolation_level. " "Valid isolation levels for %s are %s" % (level, self.name, ", ".join(self._isolation_lookup))) cursor = connection.cursor() cursor.execute("SET CURRENT ISOLATION %s" % level) cursor.execute("COMMIT") cursor.close()
def database_url(cls): """Find the database URL configured for this site. For compatibility with old configurations, we will look in the site configuration first. If it's not there, we will look in the appropriate environment variable. """ # To avoid expensive mistakes, test and production databases # are always configured with separate keys. The TESTING variable # controls which database is used, and it's set by the # package_setup() function called in every component's # tests/__init__.py. test = os.environ.get("TESTING", False) if test: config_key = cls.DATABASE_TEST_URL environment_variable = cls.DATABASE_TEST_ENVIRONMENT_VARIABLE else: config_key = cls.DATABASE_PRODUCTION_URL environment_variable = cls.DATABASE_PRODUCTION_ENVIRONMENT_VARIABLE url = os.environ.get(environment_variable) if not url: raise CannotLoadConfiguration( "Database URL was not defined in environment variable (%s)." % environment_variable ) url_obj = None try: url_obj = make_url(url) except ArgumentError as e: # Improve the error message by giving a guide as to what's # likely to work. raise ArgumentError( "Bad format for database URL (%s). Expected something like postgres://[username]:[password]@[hostname]:[port]/[database name]" % url ) # Calling __to_string__ will hide the password. logging.info("Connecting to database: %s" % url_obj.__to_string__()) return url
def database_url(cls, test=False): """Find the database URL configured for this site. For compatibility with old configurations, we will look in the site configuration first. If it's not there, we will look in the appropriate environment variable. """ # To avoid expensive mistakes, test and production databases # are always configured with separate keys. if test: config_key = cls.DATABASE_TEST_URL environment_variable = cls.DATABASE_TEST_ENVIRONMENT_VARIABLE else: config_key = cls.DATABASE_PRODUCTION_URL environment_variable = cls.DATABASE_PRODUCTION_ENVIRONMENT_VARIABLE # Check the legacy location (the config file) first. url = None database_integration = cls.integration(cls.DATABASE_INTEGRATION) if database_integration: url = database_integration.get(config_key) # If that didn't work, check the new location (the environment # variable). if not url: url = os.environ.get(environment_variable) if not url: raise CannotLoadConfiguration( "Database URL was not defined in environment variable (%s) or configuration file." % environment_variable) url_obj = None try: url_obj = make_url(url) except ArgumentError, e: # Improve the error message by giving a guide as to what's # likely to work. raise ArgumentError( "Bad format for database URL (%s). Expected something like postgres://[username]:[password]@[hostname]:[port]/[database name]" % url)
def set_isolation_level(self, connection, level): """ Set the connection to a given isolation level :param connection: pyODBC connection :param level: the new level to set isolation to """ if level is None: level = 'CS' else: if len(level.strip()) < 1: level = 'CS' level.upper().replace("-", " ") if level not in self._isolation_lookup: raise ArgumentError( "Invalid value '%s' for isolation_level. " "Valid isolation levels for %s are %s" % (level, self.name, ", ".join(self._isolation_lookup))) attrib = { SQL_ATTR_TXN_ISOLATION: _get_cli_isolation_levels(self, level) } res = connection.set_option(attrib)
def map_to(self, attrname, tablename=None, selectable=None, schema=None, base=None, mapper_args=util.immutabledict()): """Configure a mapping to the given attrname. This is the "master" method that can be used to create any configuration. .. versionadded:: 0.6.6 :param attrname: String attribute name which will be established as an attribute on this :class:.`.SqlSoup` instance. :param base: a Python class which will be used as the base for the mapped class. If ``None``, the "base" argument specified by this :class:`.SqlSoup` instance's constructor will be used, which defaults to ``object``. :param mapper_args: Dictionary of arguments which will be passed directly to :func:`.orm.mapper`. :param tablename: String name of a :class:`.Table` to be reflected. If a :class:`.Table` is already available, use the ``selectable`` argument. This argument is mutually exclusive versus the ``selectable`` argument. :param selectable: a :class:`.Table`, :class:`.Join`, or :class:`.Select` object which will be mapped. This argument is mutually exclusive versus the ``tablename`` argument. :param schema: String schema name to use if the ``tablename`` argument is present. """ if attrname in self._cache: raise InvalidRequestError( "Attribute '%s' is already mapped to '%s'" % ( attrname, class_mapper(self._cache[attrname]).mapped_table )) if tablename is not None: if not isinstance(tablename, basestring): raise ArgumentError("'tablename' argument must be a string." ) if selectable is not None: raise ArgumentError("'tablename' and 'selectable' " "arguments are mutually exclusive") selectable = Table(tablename, self._metadata, autoload=True, autoload_with=self.bind, schema=schema or self.schema) elif schema: raise ArgumentError("'tablename' argument is required when " "using 'schema'.") elif selectable is not None: if not isinstance(selectable, expression.FromClause): raise ArgumentError("'selectable' argument must be a " "table, select, join, or other " "selectable construct.") else: raise ArgumentError("'tablename' or 'selectable' argument is " "required.") if not selectable.primary_key.columns: if tablename: raise PKNotFoundError( "table '%s' does not have a primary " "key defined" % tablename) else: raise PKNotFoundError( "selectable '%s' does not have a primary " "key defined" % selectable) mapped_cls = _class_for_table( self.session, self.engine, selectable, base or self.base, mapper_args ) self._cache[attrname] = mapped_cls return mapped_cls
def recieve_message_init(target, args, kwargs): author, chat = kwargs['author'], kwargs['chat'] if author in chat.users: return kwargs else: raise ArgumentError("author must be in a chat")
def validate_barcode(self, key, value): max_len = getattr(self.__class__, key).prop.columns[0].type.length if value and len(value) > max_len: raise ArgumentError('"barcode" value is too long') return value