File: PKG-INFO

package info (click to toggle)
sqlacodegen 1.1.6-2
  • links: PTS, VCS
  • area: main
  • in suites: bullseye, buster, sid, stretch
  • size: 176 kB
  • ctags: 118
  • sloc: python: 1,381; makefile: 4
file content (146 lines) | stat: -rw-r--r-- 5,457 bytes parent folder | download | duplicates (2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
Metadata-Version: 1.1
Name: sqlacodegen
Version: 1.1.6
Summary: Automatic model code generator for SQLAlchemy
Home-page: http://pypi.python.org/pypi/sqlacodegen/
Author: Alex Gronholm
Author-email: sqlacodegen@nextday.fi
License: MIT
Description: This is a tool that reads the structure of an existing database and generates
        the appropriate SQLAlchemy model code, using the declarative style if
        possible.
        
        This tool was written as a replacement for
        `sqlautocode <http://code.google.com/p/sqlautocode/>`_, which was suffering
        from several issues (including, but not limited to, incompatibility with
        Python 3 and the latest SQLAlchemy version).
        
        
        Features
        ========
        
        * Supports SQLAlchemy 0.6.x - 0.9.x
        * Produces declarative code that almost looks like it was hand written
        * Produces `PEP 8 <http://www.python.org/dev/peps/pep-0008/>`_ compliant code
        * Accurately determines relationships, including many-to-many, one-to-one
        * Automatically detects joined table inheritance
        * Excellent test coverage
        
        
        Usage instructions
        ==================
        
        Installation
        ------------
        
        To install, do::
        
            pip install sqlacodegen
        
        or, failing that::
        
            easy_install sqlacodegen
        
        
        Example usage
        -------------
        
        At the minimum, you have to give sqlacodegen a database URL.
        The URL is passed directly to SQLAlchemy's
        `create_engine() <http://docs.sqlalchemy.org/en/latest/core/engines.html?highlight=create_engine#sqlalchemy.create_engine>`_
        method so please refer to
        `SQLAlchemy's documentation <http://docs.sqlalchemy.org/en/latest/core/engines.html>`_
        for instructions on how to construct a proper URL.
        
        Examples::
        
            sqlacodegen postgresql:///some_local_db
            sqlacodegen mysql+oursql://user:password@localhost/dbname
            sqlacodegen sqlite:///database.db
        
        To see the full list of options::
        
            sqlacodegen --help
        
        
        Model class naming logic
        ------------------------
        
        The table name (which is assumed to be in English) is converted to singular
        form using the "inflect" library. Then, every underscore is removed while
        transforming the next letter to upper case. For example, ``sales_invoices``
        becomes ``SalesInvoice``.
        
        
        Relationship detection logic
        ----------------------------
        
        Relationships are detected based on existing foreign key constraints as
        follows:
        
        * **many-to-one**: a foreign key constraint exists on the table
        * **one-to-one**: same as **many-to-one**, but a unique constraint exists on
          the column(s) involved
        * **many-to-many**: an association table is found to exist between two tables
        
        A table is considered an association table if it satisfies all of the
        following conditions:
        
        #. has exactly two foreign key constraints
        #. all its columns are involved in said constraints
        
        
        Relationship naming logic
        -------------------------
        
        Relationships are typically named based on the opposite class name.
        For example, if an ``Employee`` class has a column named ``employer`` which
        has a foreign key to ``Company.id``, the relationship is named ``company``.
        
        A special case for single column many-to-one and one-to-one relationships,
        however, is if the column is named like ``employer_id``. Then the
        relationship is named ``employer`` due to that ``_id`` suffix.
        
        If more than one relationship would be created with the same name, the
        latter ones are appended numeric suffixes, starting from 1.
        
        
        Source code
        ===========
        
        The source can be browsed at `Bitbucket
        <http://bitbucket.org/agronholm/sqlacodegen/src/>`_.
        
        
        Reporting bugs
        ==============
        
        A `bug tracker <http://bitbucket.org/agronholm/sqlacodegen/issues/>`_
        is provided by bitbucket.org.
        
        
        Getting help
        ============
        
        If you have problems or other questions, you can either:
        
        * Ask on the `SQLAlchemy Google group
          <http://groups.google.com/group/sqlalchemy>`_, or
        * Ask on the ``#sqlalchemy`` channel on
          `Freenode IRC <http://freenode.net/irc_servers.shtml>`_
        
Keywords: sqlalchemy
Platform: UNKNOWN
Classifier: Development Status :: 5 - Production/Stable
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: MIT License
Classifier: Environment :: Console
Classifier: Topic :: Database
Classifier: Topic :: Software Development :: Code Generators
Classifier: Programming Language :: Python
Classifier: Programming Language :: Python :: 2.6
Classifier: Programming Language :: Python :: 2.7
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.2
Classifier: Programming Language :: Python :: 3.3
Classifier: Programming Language :: Python :: 3.4