xdatool 0.1.0

A description of your dev key module

XDataTool Library

A Python utility library for database operations, file handling, and web interfaces.

Classes

dev

Database and ORM utility class.

Methods:

• engine(engine_session): Creates a engine
• session(engine_session): Creates database session
• base(): Returns a declarative base
• metadata(base, engine): Creates database tables
• add_commit(session, user): Adds and commits objects to database
• _Column(*args, **kwargs): Column creator helper
• Integer(): Creates Integer column type
• String(length): Creates String column type

dataTool

File and utility operations class.

Methods:

• dell(file): Deletes specified file
• read_data(session, model): Reads and prints all records from model
• connet(file, name): Creates and writes to a file
• email_send(subject, to, from_): Creates email message
• _inter(app_name, route, db_path): Creates Flask interface for database
• create_template(template_dir): Creates default data view template
• ensure_template_dir(path): Ensures template directory exists

Example Usage

from xdatatool import dev, dataTool

# Database setup
engine = dev.engine('sqlite:///database.db')
Session = dev.session(engine)
Base = dev.base()

# Define model
class User(Base):
    __tablename__ = 'users'
    id = dev._Column(dev.Integer(), primary_key=True)
    name = dev._Column(dev.String(50))

# Create tables
dev.metadata(Base, engine)

# Web interface
app = dataTool._inter('myapp', '/data', 'database.db')
app.run(debug=True)

HTTP Interface

The _inter() method in dataTool creates a web interface to view and interact with your database records.

Parameters

• app_name: Name of your Flask application
• route: URL endpoint for the data view (e.g., '/data')
• db_path: Path to your SQLite database file
• port: (Optional) Custom port number (default: 3000)
• model_path: (Optional) Path to model module (e.g., 'models.user.UserModel')
• model_class: (Optional) Direct model class reference

Requirements

• Flask must be installed (pip install flask)
• SQLAlchemy for database operations

Usage Examples

Basic setup with model class:

from models import UserModel
app = dataTool._inter('myapp', '/data', 'database.db', model_class=UserModel)
app.run()

Using model path:

app = dataTool._inter('myapp', '/data', 'database.db', 
                      model_path='models.user.UserModel')
app.run()

Custom configuration:

app = dataTool._inter('myapp', '/data', 'database.db',
                      port=3000,
                      model_class=UserModel)
app.run(host='0.0.0.0')  # Access from other machines

The web interface will automatically:

• Load model class from provided path or direct reference
• Connect to your database
• Display records in a formatted table view
• Handle errors gracefully with proper messages

Template Generation

The dataTool class includes built-in template generation. When _inter() is called, it automatically:

1. Checks for template directory
2. Creates template directory if missing
3. Generates default data.html template

Example implementation:

from xdatatool import dataTool

# Templates are auto-generated on first run
app = dataTool._inter('myapp', '/data', 'database.db')

# Or explicitly create templates
dataTool.ensure_template_dir('templates')
dataTool.create_template('templates')

app.run()

DevKey

A Python module for developer key management.

Installation

pip install devkey

Usage

from devkey import main

License

MIT License