or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

activity-system.mdapi-integration.mdbilling-system.mdconfiguration-system.mdconsole-interface.mdcontact-management.mdcore-framework.mddjango-settings.mddocument-management.mdemail-system.mdevent-system.mdimport-export-system.mdindex.mdmanagement-commands.mdplugin-development.mdproduct-catalog.mdreporting-system.mdsales-management.mdsystem-configuration.mdtemplate-system.mdticket-system.mduser-management.md
tile.json

tessl/pypi-creme-crm

A comprehensive Customer Relationship Management software built on Django with extensive customization capabilities

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
pypipkg:pypi/creme-crm@2.7.x

To install, run

npx @tessl/cli install tessl/pypi-creme-crm@2.7.0

index.mddocs/

Creme CRM

A comprehensive, highly configurable Customer Relationship Management (CRM) software built with Django that features an entities/relationships architecture enabling extensive customization and workflow adaptation. The application provides integrated modules for managing contacts & organizations, documents & folders, activities with calendar integration, products & services, invoicing systems, opportunities tracking, commercial actions, email campaigns, reporting, ticketing, alerts/todos, and geolocation services.

Package Information

  • Package Name: creme-crm
  • Package Type: Application
  • Language: Python (Django framework)
  • Installation: pip install creme-crm
  • Python Requirements: >=3.10
  • License: AGPL-3.0

Core Imports

import creme
from creme.creme_core.models import CremeEntity, CremeUser, Relation
from creme.creme_core import get_concrete_model

For Django management (console script):

# Use via command line:
creme runserver
creme migrate
creme creme_populate

Direct function import:

from creme.manage import execute  # Main entry point function

Basic Usage

# Get the current version
from creme import get_version
version = get_version()  # Returns "2.7"

# Access core models
from creme.creme_core.models import CremeUser, CremeEntity, Relation

# Get concrete model implementations
from creme.creme_core import get_concrete_model
ContactModel = get_concrete_model('PERSONS_CONTACT_MODEL')
OrganisationModel = get_concrete_model('PERSONS_ORGANISATION_MODEL')

# Create entities (requires Django setup)
contact = ContactModel.objects.create(
    first_name="John",
    last_name="Doe",
    email="john@example.com"
)

# Create relationships between entities
from creme.creme_core.models import RelationType
rel_type = RelationType.objects.get(pk='some-relation-id')
Relation.objects.create(
    subject_entity=contact,
    object_entity=some_organisation,
    type=rel_type
)

Architecture

Creme CRM follows Django's app-based architecture with several key design principles:

  • Entity System: All business objects inherit from CremeEntity, providing a unified interface for properties, relationships, permissions, and history tracking
  • Relationship-Centric: Entities are connected through typed relationships managed by Relation and RelationType models
  • Configurable UI: Brick system allows customizable dashboard widgets and detail views
  • Permission System: Fine-grained permissions with user roles, entity credentials, and field-level access control
  • Extensible Apps: Modular app system where each business domain (contacts, billing, activities, etc.) is a separate Django app

This design enables businesses to customize workflows, add custom fields and entities, configure user interfaces, and extend functionality while maintaining data integrity and security.

Console Interface

Main Entry Point

Command-line interface for administrative tasks and server management.

def execute():
    """
    Main Django management command interface for Creme CRM.
    Sets up Django environment and executes management commands.

    Environment Variables:
    - DJANGO_SETTINGS_MODULE: Django settings module (defaults to 'creme.settings')

    Usage via command line:
    creme runserver
    creme migrate
    creme creme_populate
    """

Console Interface

Capabilities

Core Framework

Entity system, relationships, permissions, and core Django models that provide the foundation for all CRM functionality.

class CremeEntity(CremeModel):
    """
    Base class for all business entities in Creme CRM.

    Fields: created, modified, entity_type, header_filter_search_field,
           is_deleted, user, description, uuid, sandbox, extra_data
    Manager: CremeEntityManager
    """

class CremeUser(AbstractUser):
    """Extended user model with CRM-specific fields and 30-char username limit."""

class Relation(models.Model):
    """Relationships between entities with typed connections."""

def get_concrete_model(model_setting: str) -> type[models.Model]:
    """Get active model class from settings configuration."""

Core Framework

Contact & Organization Management

Manage contacts, organizations, and their relationships with comprehensive contact information, custom fields, and relationship tracking.

class Contact(CremeEntity):
    """Individual contact entity with personal information."""

class Organisation(CremeEntity):
    """Company/organization entity with business information."""

Contact Management

Activity & Calendar System

Task management, calendar integration, activity scheduling, and reminder systems for organizing business activities.

class Activity(CremeEntity):
    """Activity/task entity for scheduling and time management."""

class Calendar(models.Model):
    """Calendar for organizing activities."""

Activity System

Billing & Financial Management

Invoice generation, quotations, credit notes, sales orders, and financial document workflows with PDF generation and email integration.

class Invoice(CremeEntity):
    """Invoice entity for billing customers."""

class Quote(CremeEntity):
    """Quotation entity for price estimates."""

class CreditNote(CremeEntity):
    """Credit note for refunds and corrections."""

Billing System

Document Management

File storage, document organization, folder structures, and document sharing with version control and access permissions.

class Document(CremeEntity):
    """Document entity for file management."""

class Folder(CremeEntity):
    """Folder entity for document organization."""

Document Management

Email & Campaign Management

Email template creation, mailing list management, campaign execution, and email tracking with SMTP integration.

class EmailTemplate(CremeEntity):
    """Email template for consistent messaging."""

class EmailCampaign(CremeEntity):
    """Email campaign for mass communications."""

class MailingList(CremeEntity):
    """Mailing list for organizing recipients."""

Email System

Opportunity & Sales Management

Sales pipeline management, opportunity tracking, sales phase configuration, and revenue forecasting.

class Opportunity(CremeEntity):
    """Sales opportunity entity for pipeline management."""

class SalesPhase(models.Model):
    """Sales phase for opportunity progression."""

Sales Management

Product & Service Catalog

Product catalog management, service definitions, pricing, categories, and inventory integration.

class Product(CremeEntity):
    """Product entity for catalog management."""

class Service(CremeEntity):
    """Service entity for service catalog."""

Product Catalog

Reporting & Analytics

Business intelligence, custom reports, graph generation, and data analysis with configurable dashboards.

class Report(CremeEntity):
    """Custom report entity for business intelligence."""

class Graph(CremeEntity):
    """Graph entity for data visualization."""

Reporting System

User Management & Security

User accounts, role-based permissions, team management, and security configuration with fine-grained access control.

class UserRole(models.Model):
    """Role-based permission system."""

class EntityCredentials(models.Model):
    """Entity-level access permissions."""

User Management

Configuration & Customization

System configuration, custom fields, custom forms, UI customization, and workflow configuration for adapting the system to business needs.

class CustomEntityType(models.Model):
    """Custom entity type definition."""

class FieldsConfig(models.Model):
    """Field visibility and behavior configuration."""

Configuration System

Import & Export System

Data import/export functionality, batch processing, CSV/Excel support, and data migration tools.

class Job(models.Model):
    """Background job for long-running operations."""

class MassImportJobResult(models.Model):
    """Results of mass import operations."""

Import/Export System

Ticket System

Support ticket management for customer service with priority levels, status tracking, and template support.

class Ticket(CremeEntity):
    """Support ticket entity for customer service."""

class TicketTemplate(CremeEntity):
    """Template for standardized ticket creation."""

def get_ticket_model():
    """Returns the active Ticket model."""

Ticket System

Event Management

Event management system for meetings, conferences, workshops, and business gatherings.

class Event(CremeEntity):
    """Event entity for meeting and conference management."""

class EventType(models.Model):
    """Event type classification system."""

def get_event_model():
    """Returns the active Event model."""

Event System

System Configuration

Administrative configuration interface for system settings, entity configuration, and UI customization.

class ConfigRegistry:
    """Central registry for configuration items."""

class FieldsConfig(models.Model):
    """Entity field visibility configuration."""

System Configuration

Django Integration

Settings Configuration

Creme CRM provides comprehensive Django settings for database, security, internationalization, media handling, and application-specific configurations.

Django Settings

Management Commands

Administrative commands for database initialization, user creation, maintenance, and system management.

Management Commands

Template System

Template tags, context processors, and custom widgets for building the web interface and customizing the user experience.

Template System

Extension & Development

Plugin Development

Creating custom apps, extending entities, adding custom fields, and integrating third-party services.

Plugin Development

API Integration

REST endpoints, AJAX interfaces, and integration patterns for connecting external systems.

API Integration

Common Types

# Core entity types
CremeEntity = Any  # Base entity class
CremeUser = Any    # User model
Relation = Any     # Entity relationship

# Configuration types
FieldsConfig = Any     # Field configuration
HeaderFilter = Any     # List view configuration
EntityFilter = Any     # Entity filtering

# Job system types
Job = Any         # Background job
JobResult = Any   # Job execution result

# Form types
CremeForm = Any      # Base form class
CremeModelForm = Any # Model form class