tessl/pypi-nautobot

Source of truth and network automation platform for network infrastructure management.

—

Pending

Overview

Eval results

Files

Core Framework

Name: tessl/pypi-nautobot
Author: tessl

Core functionality providing the foundation for all Nautobot modules including Django setup, base models, API infrastructure, form handling, job system, and plugin architecture.

Capabilities

Setup and Initialization

Configure Django with Nautobot settings and initialize the application.

def setup(config_path=None):
    """
    Configure Django with Nautobot settings.
    
    Args:
        config_path (str, optional): Path to configuration file
    """

def add_success_logger():
    """Add a custom log level for success messages."""

def add_failure_logger():
    """Add a custom log level for failure messages."""

Base Model Classes

Foundation classes for all Nautobot models providing common functionality.

class BaseModel:
    """
    Abstract base model with UUID primary key, natural keys, and validation.
    
    Attributes:
        id (UUID): Primary key
        created (datetime): Creation timestamp
        last_updated (datetime): Last modification timestamp
    """

class BaseManager:
    """Custom model manager with additional functionality."""

class RestrictedQuerySet:
    """Queryset with user permissions filtering."""

class ContentTypeRelatedQuerySet:
    """ContentType-aware queryset for generic relations."""

class CompositeKeyQuerySetMixin:
    """Mixin for composite key support."""

Model Utilities

Helper functions for working with models and keys.

def construct_composite_key(*args):
    """Build composite keys from multiple values."""

def construct_natural_slug(value, max_length=50):
    """Generate natural slugs from values."""

def deconstruct_composite_key(key):
    """Parse composite keys into components."""

API Serializers

Base serializer classes for REST API operations.

class BaseModelSerializer:
    """Base serializer for all Nautobot models."""

class NautobotModelSerializer:
    """Main model serializer with common functionality."""

class BulkOperationSerializer:
    """Serializer for bulk operations."""

class BulkOperationIntegerIDSerializer:
    """Serializer for bulk operations using integer IDs."""

class CustomFieldModelSerializerMixin:
    """Mixin for custom fields integration."""

class GraphQLAPISerializer:
    """Serializer for GraphQL API operations."""

class OptInFieldsMixin:
    """Mixin for optional field selection."""

class PolymorphicProxySerializer:
    """Serializer for polymorphic proxy models."""

class RenderJinjaSerializer:
    """Serializer for Jinja template rendering."""

class ValidatedModelSerializer:
    """Serializer with comprehensive validation."""

class WritableNestedSerializer:
    """Serializer for nested object creation/updates."""

class NotesSerializerMixin:
    """Mixin for notes functionality."""

class RelationshipModelSerializerMixin:
    """Mixin for object relationships."""

class TreeModelSerializerMixin:
    """Mixin for hierarchical data support."""

API Fields

Specialized field types for API serialization.

class ChoiceField:
    """Choice field for API serialization."""

class ContentTypeField:
    """Django ContentType field for APIs."""

class LaxURLField:
    """URL field with relaxed validation."""

class NautobotHyperlinkedRelatedField:
    """Hyperlinked related object field."""

class ObjectTypeField:
    """Field for object type selection."""

class SerializedPKRelatedField:
    """Primary key relation field."""

class TimeZoneSerializerField:
    """Timezone handling field."""

Form Classes

Base form classes with Bootstrap styling and common functionality.

class BootstrapMixin:
    """Bootstrap UI styling mixin."""

class BulkEditForm:
    """Form for bulk editing operations."""

class BulkRenameForm:
    """Form for bulk renaming operations."""

class ConfirmationForm:
    """User confirmation dialog form."""

class CSVModelForm:
    """Form for CSV import/export operations."""

class DynamicFilterForm:
    """Form for dynamic filtering."""

class ImportForm:
    """Data import form."""

class ReturnURLForm:
    """Form with return URL handling."""

class TableConfigForm:
    """Table configuration form."""

class SearchForm:
    """Search functionality form."""

Form Fields

Specialized form field types with validation and widgets.

class AutoPositionField:
    """Field with automatic positioning."""

class CSVChoiceField:
    """CSV choice field."""

class CSVModelChoiceField:
    """CSV model choice field."""

class DynamicModelChoiceField:
    """Dynamic model selection field."""

class ExpandableIPAddressField:
    """IP address field with expansion support."""

class JSONField:
    """JSON data input field."""

class MACAddressField:
    """MAC address validation field."""

class SlugField:
    """URL-safe slug field."""

class TagFilterField:
    """Tag filtering field."""

Form Widgets

Custom widgets for form fields.

class APISelect:
    """API-driven select widget."""

class APISelectMultiple:
    """API-driven multi-select widget."""

class ColorSelect:
    """Color picker widget."""

class DatePicker:
    """Date selection widget."""

class StaticSelect2:
    """Select2 integration widget."""

System Jobs

Built-in system jobs for common operations.

class GitRepositorySync:
    """Job to sync Git repositories."""

class GitRepositoryDryRun:
    """Job for dry run Git sync operations."""

class ExportObjectList:
    """Job to export objects to CSV/YAML."""

class ImportObjects:
    """Job to import objects from CSV."""

class BulkDeleteObjects:
    """Job for bulk delete operations."""

class BulkEditObjects:
    """Job for bulk edit operations."""

class LogsCleanup:
    """Job to clean up old logs."""

class RefreshDynamicGroupCaches:
    """Job to refresh dynamic group caches."""

App Configuration

Base classes for app and plugin configuration.

class NautobotConfig:
    """Base app configuration class."""

class CoreConfig:
    """Core app configuration."""

UI Components

Components for building the Nautobot user interface.

class HomePagePanel:
    """Homepage layout panels."""

class HomePageGroup:
    """Homepage panel groups."""

class HomePageItem:
    """Homepage panel items."""

class NavMenuTab:
    """Navigation menu tabs."""

class NavMenuGroup:
    """Navigation menu groups."""

class NavMenuItem:
    """Navigation menu items."""

class NavMenuButton:
    """Navigation menu buttons."""

class NavMenuAddButton:
    """Navigation menu add buttons."""

class NavMenuImportButton:
    """Navigation menu import buttons."""

class PermissionsMixin:
    """Permissions mixin for UI components."""

Registration Functions

Functions for registering UI components and extensions.

def register_menu_items(menu_items):
    """Register navigation menu items."""

def register_homepage_panels(panels):
    """Register homepage panels."""

GraphQL Interface

GraphQL query execution and utilities.

def execute_query(query, variables=None, request=None, user=None):
    """Execute GraphQL queries."""

def execute_saved_query(saved_query_name, **kwargs):
    """Execute saved GraphQL queries."""

CLI Management

Command-line interface utilities and management commands.

The nautobot-server command provides extensive CLI functionality:

nautobot-server --help
nautobot-server migrate
nautobot-server runserver
nautobot-server createsuperuser
nautobot-server collectstatic

Usage Examples

Basic Setup

import nautobot

# Initialize Nautobot with default configuration
nautobot.setup()

# Check version
print(f"Nautobot version: {nautobot.__version__}")

Custom Model Creation

from nautobot.core.models import BaseModel
from django.db import models

class MyCustomModel(BaseModel):
    name = models.CharField(max_length=100)
    description = models.TextField(blank=True)
    
    class Meta:
        ordering = ['name']
        
    def __str__(self):
        return self.name

API Serializer Usage

from nautobot.core.api.serializers import NautobotModelSerializer
from .models import MyCustomModel

class MyCustomModelSerializer(NautobotModelSerializer):
    class Meta:
        model = MyCustomModel
        fields = '__all__'

Form Creation

from nautobot.core.forms import BootstrapMixin
from django import forms
from .models import MyCustomModel

class MyCustomModelForm(BootstrapMixin, forms.ModelForm):
    class Meta:
        model = MyCustomModel
        fields = ['name', 'description']

Job Implementation

from nautobot.core.jobs import Job
from nautobot.extras.models import Status

class MyCustomJob(Job):
    class Meta:
        name = "My Custom Job"
        description = "Performs custom automation task"
    
    def run(self):
        self.log_info("Starting custom job")
        
        # Job logic here
        result = "Job completed successfully"
        
        self.log_success(result)
        return result

Error Handling

Common error patterns and handling:

from nautobot.core.models import BaseModel
from django.core.exceptions import ValidationError

try:
    obj = BaseModel.objects.get(id=some_uuid)
except BaseModel.DoesNotExist:
    # Handle missing object
    pass
except ValidationError as e:
    # Handle validation errors
    print(f"Validation error: {e}")

Install with Tessl CLI