title: Why did I have problems with alembic migrations
body: <p>Project structue(only directory with DB migrations):</p>
  
  <pre><code>--db_manage:
    alembic.ini
    --alembic:
      env.py
      script.py.mako
      README
      --versions:
        #migration files
  </code></pre>
  
  <p>When I try to run command: <code>python db_manage/alembic/env.py</code>, I have response like:</p>
  
  <pre><code>Traceback (most recent call last):
    File "db_manage/alembic/env.py", line 8, in &lt;module&gt;
      config = context.config
  AttributeError: module 'alembic.context' has no attribute 'config'
  </code></pre>
  
  <p>In which case I have that problem?<br>
  <strong>P.S.</strong> <br>
  File <code>alembic.ini</code>:</p>
  
  <pre><code># A generic, single database configuration.
  
  [alembic]
  # path to migration scripts
  script_location = alembic
  
  # template used to generate migration files
  # file_template = %%(rev)s_%%(slug)s
  
  # max length of characters to apply to the
  # "slug" field
  #truncate_slug_length = 40
  
  # set to 'true' to run the environment during
  # the 'revision' command, regardless of autogenerate
  # revision_environment = false
  
  # set to 'true' to allow .pyc and .pyo files without
  # a source .py file to be detected as revisions in the
  # versions/ directory
  # sourceless = false
  
  # version location specification; this defaults
  # to numus/versions.  When using multiple version
  # directories, initial revisions must be specified with --version-path
  # version_locations = %(here)s/bar %(here)s/bat numus/versions
  
  # the output encoding used when revision files
  # are written from script.py.mako
  # output_encoding = utf-8
  
  sqlalchemy.url = postgresql://test:oe50yxXOspYDsaXSO7Gf@localhost/test
  
  
  # Logging configuration
  [loggers]
  keys = root,sqlalchemy,alembic
  
  [handlers]
  keys = console
  
  [formatters]
  keys = generic
  
  [logger_root]
  level = WARN
  handlers = console
  qualname =
  
  [logger_sqlalchemy]
  level = WARN
  handlers =
  qualname = sqlalchemy.engine
  
  [logger_alembic]
  level = INFO
  handlers =
  qualname = alembic
  
  [handler_console]
  class = StreamHandler
  args = (sys.stderr,)
  level = NOTSET
  formatter = generic
  
  [formatter_generic]
  format = %(levelname)-5.5s [%(name)s] %(message)s
  datefmt = %H:%M:%S
  </code></pre>
  
  <p>File <code>env.py</code>:</p>
  
  <pre><code>from __future__ import with_statement
  from alembic import context
  from sqlalchemy import engine_from_config, pool
  from logging.config import fileConfig
  
  # this is the Alembic Config object, which provides
  # access to the values within the .ini file in use.
  config = context.config
  
  # Interpret the config file for Python logging.
  # This line sets up loggers basically.
  fileConfig(config.config_file_name)
  
  # add your model's MetaData object here
  # for 'autogenerate' support
  # from myapp import mymodel
  # target_metadata = mymodel.Base.metadata
  target_metadata = None
  
  # other values from the config, defined by the needs of env.py,
  # can be acquired:
  # my_important_option = config.get_main_option("my_important_option")
  # ... etc.
  
  
  def run_migrations_offline():
      """Run migrations in 'offline' mode.
  
      This configures the context with just a URL
      and not an Engine, though an Engine is acceptable
      here as well.  By skipping the Engine creation
      we don't even need a DBAPI to be available.
  
      Calls to context.execute() here emit the given string to the
      script output.
  
      """
      url = config.get_main_option("sqlalchemy.url")
      context.configure(
          url=url, target_metadata=target_metadata, literal_binds=True)
  
      with context.begin_transaction():
          context.run_migrations()
  
  
  def run_migrations_online():
      """Run migrations in 'online' mode.
  
      In this scenario we need to create an Engine
      and associate a connection with the context.
  
      """
      connectable = engine_from_config(
          config.get_section(config.config_ini_section),
          prefix='sqlalchemy.',
          poolclass=pool.NullPool)
  
      with connectable.connect() as connection:
          context.configure(
              connection=connection,
              target_metadata=target_metadata
          )
  
          with context.begin_transaction():
              context.run_migrations()
  
  if context.is_offline_mode():
      run_migrations_offline()
  else:
      run_migrations_online()
  </code></pre>