def output_design(): import eralchemy from magnet import Base eralchemy.render_er(Base, "er.png") markdown = get_table_define_as_markdown(Base) with open("tables.md", mode='w') as f: f.write(markdown)
def main(argv=None): usage = """Data Model ERD Generator Generates an entity relationship diagram for the data model specified. If passing a custom URL, the data model returned must be in the JSON format defined by the chop-dbhi/data-models package. The generated diagram is saved to the named output file. Usage: erd.py [options] <model> <version> <outfile> Options: -h --help Show this screen. -u URL --url=URL Retrieve model JSON from this URL instead of the default or environment-variable-passed URL. """ # noqa from docopt import docopt # Ignore command name if called from command line. argv = argv or sys.argv[1:] args = docopt(usage, argv=argv, version=__version__) url = args['--url'] or get_url(args['<model>'], args['<version>']) model_json = requests.get(url).json() metadata = MetaData() make_model(model_json, metadata) render_er(metadata, args['<outfile>'])
def main(): """entry point of the whole application, equivalent to django's manage.py""" args = docopt(__doc__) setproctitle('socialite') # setup logging level_name = os.environ.get('DEBUG', 'INFO') level = getattr(logging, level_name) daiquiri.setup(level=level, outputs=('stderr', )) if args.get('web'): loop = asyncio.get_event_loop() app = create_app(loop) web.run_app(app, host='127.0.0.1', port=8000) elif args.get('init'): loop = asyncio.get_event_loop() loop.run_until_complete(init(settings)) elif args.get('database') and args.get('migrate'): directory = Path(__file__) / '..' / 'migrations' directory = directory.resolve() directory = str(directory) yoyo([ '--no-config-file', '-b', 'apply', '--database', settings.DSN, directory, ]) elif args.get('database') and args.get('diagram'): render_er(settings.DSN, 'socialite-diagram.png') else: print('Use --help to know more')
def create_table(engine): event.listen( Base.metadata, "before_create", DDL(f"CREATE SCHEMA IF NOT EXISTS {SCHEMA}") ) Base.metadata.create_all(engine) render_er(os.environ.get("CONNECTION_STRING"), "static/drugbank_schema.png")
def create_with_eralchemy(image_path: Path): # SEE https://github.com/Alexis-benoist/eralchemy from eralchemy import render_er for ext in (".png", ".svg"): render_er(metadata, str(image_path.with_suffix(ext)))
def save_layout(self, filename: str): """ Save the layout of the database to file. Args: filename (str): Filetypes are png, dot, er (markdown), and pdf. """ from eralchemy import render_er render_er(self.metadata, filename)
def erd(): """ Create an ERD of the current data model """ import os from eralchemy import render_er from dataservice.api.participant.models import Participant if not os.path.isdir('docs'): os.mkdir('docs') render_er(Participant, os.path.join('docs', 'erd.png'))
def main(): database_config = read_config(database_config_template(), filter_section='sqlalchemy') setup_db(database_config) render_er( "{}://{}:{}@{}:{}/{}".format(database_config['drivername'], database_config['username'], database_config['password'], database_config['host'], database_config['port'], database_config['database']), os.path.join('..', '_static', 'img', 'schema_db.png'))
def drawerd(image_name, publish): """ Generates ERD in /temp/<image_name> """ # TODO : add publishing functionality once GCP access is setup from eralchemy import render_er pathlib.Path("temp").mkdir(parents=True, exist_ok=True) render_er(db.Model, os.path.join("temp", image_name)) print( f"Diagram created : {os.path.join(os.path.curdir, 'temp', image_name)}" ) if publish: upload_blob("<your_bucket_goes_here>", f"temp/{image_name}", "erd.png")
def main(argv=sys.argv): if len(argv) < 3: usage(argv) config_uri = argv[1] output_file = argv[2] options = parse_vars(argv[3:]) setup_logging(config_uri) settings = get_appsettings(config_uri, options=options) durl = os.environ.get("DATABASE_URL") #heroku if durl: settings['sqlalchemy.url']=durl from eralchemy import render_er ## Draw from SQLAlchemy base render_er(settings.get("sqlalchemy.url"), output_file)
class Planetas(Base): __tablename__ = 'planetas' # Here we define columns for the table address. # Notice that each column is also a normal Python instance attribute. id = Column(Integer, primary_key=True) diameter = Column(String(250) population = Column(String(250), nullable=False) terrain = Column(String(250), nullable=False) class User(Base): __tablename__ = 'user' # Here we define columns for the table address. # Notice that each column is also a normal Python instance attribute. id = Column(Integer, primary_key=True) name = Column(String(250), nullable=False) mail= Column(String(250), nullable=False) password = Column(String(250), nullable=False) class Favoritos(Base): __tablename__ = 'planetas' # Here we define columns for the table address. # Notice that each column is also a normal Python instance attribute. id = Column(Integer, primary_key=True) user_id = Column(String(250) planeta_id = Column(String(250), nullable=False) persona_id = Column(String(250), nullable=False) def to_dict(self): return {} ## Draw from SQLAlchemy base render_er(Base, 'diagram.png')
def erd(self, line, cell=''): '''Format.''' parser = ArgumentParser() parser.add_argument('-o', '--output_type', default='svg') parser.add_argument('-f', '--filestub', default='erd_from_db') parser.add_argument('-c', '--connection_string', default=None) parser.add_argument('-i', '--include_tables', default=None) parser.add_argument('-x', '--exclude_tables', default=None) args = parser.parse_args(shlex.split(line)) if args.connection_string is None: return fname = '{}.{}'.format(args.filestub, args.output_type) include_tables = [i for i in reader([args.include_tables]) ][0] if args.include_tables is not None else None exclude_tables = [i for i in reader([args.exclude_tables]) ][0] if args.exclude_tables is not None else None retval = render_er(args.connection_string, fname, include_tables=include_tables, exclude_tables=exclude_tables) #return SVG(filename=fname) #retval is a graphviz object with a _repr_svg_() method return retval
def er(directory): """Generate entity-relation diagrams for each package.""" try: import eralchemy except ImportError: click.echo('Can not import eralchemy. Try `pip install eralchemy`.') return sys.exit(1) os.makedirs(directory, exist_ok=True) it = tqdm(sorted(MANAGERS.items()), leave=False) for name, manager_cls in it: base = getattr(manager_cls, '_base', None) if base is None: it.write(f'{name} does not have a SQLAlchemy base') continue it.write(f'generating for {name}') eralchemy.render_er(base, os.path.join(directory, f'{name}_erd.png'))
def write(model, model_version, output, service): """Generate entity relationship diagram for the data model specified. Arguments: model Model to generate DDL for. model_version Model version to generate DDL for. output Output file for ERD. service Base URL of the data models service to use. Raises: ImportError, if erlalchemy cannot be imported """ # noqa metadata = MetaData() model_json = get_model_json(model, model_version, service) make_model(model_json, metadata) from eralchemy import render_er render_er(metadata, output)
def erd(config_name=None, filepath=None): """ Generate an entity relationship diagram from the database :param config_name: a dict key which specifies which Config class to select in config.config dict. The Config class encapsulates all db parameters such as user, pw, host, port, and name of the db. See config.py for more info. :param filepath: Path to output ERD file """ config = _select_config(config_name) doc_dir = os.path.join(os.path.dirname(ROOT_DIR), 'docs') if not filepath: filepath = os.path.join(doc_dir, 'erd.png') # Draw from database print(f'Generating ERD for {config.PG_HOST}/{config.PG_NAME} ...') render_er(config.SQLALCHEMY_DATABASE_URI, filepath) print(f'Entity relationship diagram generated: {filepath}')
def main(): parser = argparse.ArgumentParser() parser.add_argument("--out", help="output pdf file.") args = parser.parse_args() os.getcwd() current = datetime.now(tz=JST()) if args.out is None: out_target = "%s/eralchemy/%s-%s.pdf" % ( os.getcwd(), db_name, current.strftime("%Y-%m-%d_%H%M%S")) else: out_target = args.out df = open("exclude.yml", "r+") excludes = " ".join(yaml.load(df)['exclude_tables']) connect_url = "postgresql+psycopg2://%s:%s@%s:%s/%s" % ( db_user, db_password, db_host, db_port, db_name) logger.info("start : %s ---> %s" % (connect_url, out_target)) render_er(connect_url, out_target, exclude=excludes)
def main(argv=sys.argv): if len(argv) < 2: usage(argv) config_uri = argv[1] options = parse_vars(argv[2:]) setup_logging(config_uri) settings = get_appsettings(config_uri, options=options) # passwords_config_path = helpers.get_passwords_config_path(global_config['__file__']) passwords_config_path = helpers.get_passwords_config_path(config_uri) if os.path.isfile(passwords_config_path): passwords_settings = helpers.load_config(passwords_config_path) settings = helpers.dicts_merge(passwords_settings.get('app:main', {}), settings) # sql_engine = engine_from_config(settings, 'sqlalchemy.') # # DBSession.configure(bind=engine) # Base.metadata.bind = sql_engine erd_file_path = path.realpath( path.join(server_path, '..', 'dia', erd_file_name)) eralchemy.render_er(Base, erd_file_path) print('file generated. see "' + erd_file_path + '"')
class Edge(Base): __tablename__ = 'edge' lower_id = Column(Integer, ForeignKey('node.node_id'), primary_key=True) higher_id = Column(Integer, ForeignKey('node.node_id'), primary_key=True) lower_node = relationship(Node, primaryjoin=lower_id == Node.node_id, backref='lower_edges') higher_node = relationship(Node, primaryjoin=higher_id == Node.node_id, backref='higher_edges') # here we have lower.node_id <= higher.node_id def __init__(self, n1, n2): if n1.node_id < n2.node_id: self.lower_node = n1 self.higher_node = n2 else: self.lower_node = n2 self.higher_node = n1 if __name__ == '__main__': render_er(Base, 'graph.png') render_er(Base, 'graph.dot') render_er(Base, 'graph.pdf')
user = relationship(User) class Comments(Base): __tablename__ = 'comments' id = Column(Integer, unique=True, primary_key=True) text = Column(String) user_id = Column(Integer, ForeignKey("user.id")) post_id = Column(Integer, ForeignKey("post.id")) user = relationship(User) post = relationship(Post) class Followers(Base): __tablename__ = 'followers' id = Column(Integer, unique=True, primary_key=True) user_id = Column(Integer, ForeignKey("user.id")) follower_by = Column(Integer, ForeignKey("user.id")) user = relationship(User) def to_dict(self): return {} ## Draw from SQLAlchemy base try: result = render_er(Base, 'diagram.png') print("Success! Check the diagram.png file") except Exception as e: print("There was a problem genering the diagram") raise e
from sqlalchemy.ext.declarative import declarative_base from sqlalchemy.orm import relationship from sqlalchemy import create_engine from eralchemy import render_er Base = declarative_base() class Person(Base): __tablename__ = 'person' # Here we define columns for the table person # Notice that each column is also a normal Python instance attribute. id = Column(Integer, primary_key=True) name = Column(String(250), nullable=False) class Address(Base): __tablename__ = 'address' # Here we define columns for the table address. # Notice that each column is also a normal Python instance attribute. id = Column(Integer, primary_key=True) street_name = Column(String(250)) street_number = Column(String(250)) post_code = Column(String(250), nullable=False) person_id = Column(Integer, ForeignKey('person.id')) person = relationship(Person) def to_dict(self): return {} ## Draw from SQLAlchemy base render_er(Base, 'diagram.png')
"text": self.text, "icon": self.icon, "like": self.like, } class Direct(Base): __tablename__ = 'direct' id = Column(Integer, primary_key=True) user_id = Column(Integer, ForeignKey('user.id')) messege_id = Column(Integer, ForeignKey('messege.id'))# tabla no existe userOtro_id = Column(Integer, ForeignKey('userOtro.id'))# tabla no existe photo_id = Column(Integer, ForeignKey('photo.id'))# tabla no existe text = Column(String(250), nullable=False) icon = Column(String(250), nullable=False) def serialize(self): return { "id": self.id, "user_id": self.user_id, "messege_id": self.messege_id, "userOtro_id": self.userOtro_id, "photo_id": self.photo_id, "text": self.text, "icon": self.icon } ## Draw from SQLAlchemy base render_er(Base, 'diagramUML.png')
class Edge(Base): __tablename__ = 'edge' lower_id = Column(Integer, ForeignKey('node.node_id'), primary_key=True) higher_id = Column(Integer, ForeignKey('node.node_id'), primary_key=True) lower_node = relationship(Node, primaryjoin=lower_id==Node.node_id, backref='lower_edges') higher_node = relationship(Node, primaryjoin=higher_id==Node.node_id, backref='higher_edges') # here we have lower.node_id <= higher.node_id def __init__(self, n1, n2): if n1.node_id < n2.node_id: self.lower_node = n1 self.higher_node = n2 else: self.lower_node = n2 self.higher_node = n1 render_er(Base, 'graph.png')
ForeignKey(Post.id, ondelete='CASCADE'), nullable=False) parent_id = Column(Integer, ForeignKey("comments.id", ondelete='CASCADE')) comment = Column(UnicodeText) date_created = Column(DateTime, default=datetime.utcnow) score = Column(Integer, default=1) votes = Column(Text) author = relation(User, innerjoin=True, lazy="joined") post = relation(Post, innerjoin=True, lazy="joined") parent = relation('Comment', remote_side=[id]) class Tag(Base): __tablename__ = "tags" id = Column(Integer, primary_key=True) slug = Column(Unicode(80), unique=True) _name = Column("name", Unicode(80), unique=True) if __name__ == '__main__': from eralchemy import render_er render_er(Base, 'newsmeme.pdf')
# -*- coding: 850 -*- from eralchemy import render_er import getpass import psycopg2 salida = False while not salida : print 'Entre las credenciales del servidor--->' servidor = raw_input("Entre servidor : ") puerto = raw_input("Entre el puerto : ") basedatos = raw_input("Entre el la base de datos: ") usuario = raw_input("Entre el usuario: ") contrasena = getpass.getpass('Password') try: cadena = 'postgresql+psycopg2://'+usuario+':'+contrasena+'@'+servidor+':'+puerto+'/'+basedatos render_er(cadena, 'salida.png') print 'El modelo se encuentra en el archivo salida.png' salida=True except Exception, e: print u'Verifique los parametros de conexión' print str(e)
lower_id = Column(Integer, ForeignKey('node.node_id'), primary_key=True) higher_id = Column(Integer, ForeignKey('node.node_id'), primary_key=True) lower_node = relationship(Node, primaryjoin=lower_id == Node.node_id, backref='lower_edges') higher_node = relationship(Node, primaryjoin=higher_id == Node.node_id, backref='higher_edges') # here we have lower.node_id <= higher.node_id def __init__(self, n1, n2): if n1.node_id < n2.node_id: self.lower_node = n1 self.higher_node = n2 else: self.lower_node = n2 self.higher_node = n1 if __name__ == '__main__': render_er(Base, 'graph.png') render_er(Base, 'graph.dot') render_er(Base, 'graph.pdf')
if __name__ == "__main__": parser = argparse.ArgumentParser( description='SAP Ariba ER Diagram generator') parser.add_argument('--document_type', type=str, default='', help='Example value: S4ApprovalFlowFact') args = parser.parse_args() er_markdown = "" if args.document_type != "": er_markdown = generate_er_markdown( document_type_entities(args.document_type)) else: er_markdown = generate_er_markdown() # Generate output file name document_filename = "_" + args.document_type if args.document_type != "" else "" er_markdown_filename = f"analytical_reporting{document_filename}" # Store Entity Relationship markdown with open(er_markdown_filename + ".er", "w") as f: f.write(er_markdown) ## Draw from Entity Relationship markdown to PDF render_er(er_markdown_filename + ".er", er_markdown_filename + ".pdf")
def get_tables(): return query_db("SELECT name FROM sqlite_master WHERE type='table'") def get_table_content(t): header = [c[1] for c in query_db("PRAGMA table_info('" + t + "')")] content = query_db("SELECT * FROM " + t + " LIMIT 10") return [header] + content def get_table_numbers(t): return query_db("SELECT count(*) FROM " + t, one=True)[0] # init DB_NAME = get_db_name() print 'Database:', DB_NAME render_er('sqlite:///' + DB_NAME, 'static/schema.png') # routes @app.route('/') def root(): return app.send_static_file('index.html') @app.route('/overview/') def overview(): tables = [{"name": t[0], "records": 0} for t in get_tables()] for i in range(len(tables)): tables[i]["records"] = get_table_numbers(tables[i]["name"]) return jsonify(results=tables) @app.route('/tables/')
from eralchemy import render_er from db.config import Config import os.path image_path = os.path.dirname(__file__)+'/../db/docs/' ## Draw from SQLAlchemy base render_er(Config.SQLALCHEMY_DATABASE_URI, image_path+'erd_from_sqlalchemy.png')
def example(): render_er(Base, 'simple.png') render_er(Base, 'simple.dot') render_er(Base, 'simple.pdf') render_er(Base, 'simple.er')
# ERAlchemy # Github: https://github.com/Alexis-benoist/eralchemy # Pypi: https://pypi.org/project/ERAlchemy/ import os import sys sys.path.append(os.getcwd()) from eralchemy import render_er from app.core.config import settings # Draw from database render_er(settings.SQLALCHEMY_DATABASE_URI, 'docs/schemas/entity-relation_diagram.png')
__author__ = 'anthony' # -*- coding: 850 -*- from eralchemy import render_er import getpass import psycopg2 salida = False while not salida: print('Entre las credenciales del servidor--->') servidor = raw_input("localhost") puerto = raw_input("5433") basedatos = raw_input("EjemploBaseInsti") usuario = raw_input("postgres") contrasena = getpass.getpass('Holapostgres') try: cadena = 'postgresql+psycopg2://' + usuario + ':' + contrasena + '@' + servidor + ':' + puerto + '/' + basedatos render_er(cadena, 'salida.png') print('El modelo se encuentra en el archivo EjemploBase.png') salida = True except Exception as e: print('Verifique los parametros de conexión') print(str(e))
) conn = engine.connect() conn.execute("commit") try: conn.execute("create database tmp") except: conn.execute("drop database tmp") conn.execute("create database tmp") engine = create_engine( "mysql+mysqlconnector://<username>:<password>@localhost/tmp?charset=utf8" ) conn = engine.connect() import_sql(conn, commands[1]) render_er( "mysql+mysqlconnector://root:qqwe@localhost/tmp?charset=utf8", 'erd_from_sqlite.png') conn.execute("drop database tmp") conn.close() image = Image.open('erd_from_sqlite.png') image.show() else: print('\nInvalid Path\n') elif (commands[0] == 'query'): if not dbms: print('\nthere is no database yet\n') elif (commands[1] == '-e'): ### query_db = deepcopy(dbms[0]) ###
def main(): output = (current_dir / "../doc/img/postgres-database-models.svg").resolve() render_er(metadata, str(output))
from eralchemy import render_er import re import os def find_filepath_from_directory(directory, filename): regex = re.compile(r'(%s)$' % filename) for root, dirs, files in os.walk(directory): for file in files: if regex.match(file): return os.path.join(root, file) def_file_path = find_filepath_from_directory('.', 'table_definition.er') def_file_directory = os.path.dirname(def_file_path) render_er(def_file_path, os.path.join(def_file_directory, "table_definition.png"))
#"edited": "2014-12-20T21:26:24.783000Z", #"url": "http://swapi.dev/api/starships/9/" #} class Username(Base): __tablename__ = 'username' id = Column(Integer, primary_key=True) username = Column(String(50), unique=True, nullable=False) email = Column(String(100), unique=True, nullable=False) def to_dict(self): return {} class Favorites(Base): __tablename__ = 'favorites' user_id = Column(Integer, ForeignKey(Username.id)) id = Column(Integer, primary_key=True) name = Column(String(60)) planet_name = Column(String(60), ForeignKey(Planet.name)) person_name = Column(String(60), ForeignKey(Character.name)) startship = Column(String(60), ForeignKey(StartShip.name)) def to_dict(self): return {} ## Draw from SQLAlchemy base render_er(Base, 'diagram.png')
def dump_schema(outf): from wikiparse.db.tables import metadata from eralchemy import render_er render_er(metadata, outf)