realicen un software que les permita: 1) Obtener pedidos de clientes para el día a día. 2) Permita agendarlos para el dia siguiente, asi tener proyección de que deberá cocinar. 3) Agendar los tiempos disponibles del local para hacer eventos con pago previo. 4) Inventariar sus productos para tener conocimiento de lo que necesita comprar para abastecerse en el local todas las semanas según los últimos platillos vendidos en el supermercado.

Aquí te presento un ejemplo de cómo podrías implementar el software que solicitaste utilizando Python. Este ejemplo es una aplicación básica que incluye las funcionalidades que mencionaste.

**Requisitos previos**

* Python 3.x instalado en tu sistema
* Librerías `tkinter` para la interfaz gráfica de usuario (opcional)
* Librerías `sqlite3` para la base de datos

**Estructura del proyecto**

* `pedido.py`: módulo para gestionar pedidos de clientes
* `agendamiento.py`: módulo para agendar eventos y pedidos
* `inventario.py`: módulo para inventariar productos
* `main.py`: archivo principal que ejecuta la aplicación

**Código**

### pedido.py
```python
import sqlite3

class Pedido:
    def __init__(self, id_pedido, fecha, cliente, platillo):
        self.id_pedido = id_pedido
        self.fecha = fecha
        self.cliente = cliente
        self.platillo = platillo

class PedidoDAO:
    def __init__(self, db_name):
        self.conn = sqlite3.connect(db_name)
        self.cursor = self.conn.cursor()

    def crear_pedido(self, pedido):
        self.cursor.execute("INSERT INTO pedidos (fecha, cliente, platillo) VALUES (?, ?, ?)",
                            (pedido.fecha, pedido.cliente, pedido.platillo))
        self.conn.commit()
        return self.cursor.lastrowid

    def obtener_pedidos(self):
        self.cursor.execute("SELECT * FROM pedidos")
        return self.cursor.fetchall()

    def cerrar_conexion(self):
        self.conn.close()
```

### agendamiento.py
```python
import sqlite3

class Evento:
    def __init__(self, id_evento, fecha, hora, cliente, pago_previo):
        self.id_evento = id_evento
        self.fecha = fecha
        self.hora = hora
        self.cliente = cliente
        self.pago_previo = pago_previo

class EventoDAO:
    def __init__(self, db_name):
        self.conn = sqlite3.connect(db_name)
        self.cursor = self.conn.cursor()

    def crear_evento(self, evento):
        self.cursor.execute("INSERT INTO eventos (fecha, hora, cliente, pago_previo) VALUES (?, ?, ?, ?)",
                            (evento.fecha, evento.hora, evento.cliente, evento.pago_previo))
        self.conn.commit()
        return self.cursor.lastrowid

    def obtener_eventos(self):
        self.cursor.execute("SELECT * FROM eventos")
        return self.cursor.fetchall()

    def cerrar_conexion(self):
        self.conn.close()
```

### inventario.py
```python
import sqlite3

class Producto:
    def __init__(self, id_producto, nombre, cantidad):
        self.id_producto = id_producto
        self.nombre = nombre
        self.cantidad = cantidad

class InventarioDAO:
    def __init__(self, db_name):
        self.conn = sqlite3.connect(db_name)
        self.cursor = self.conn.cursor()

    def crear_producto(self, producto):
        self.cursor.execute("INSERT INTO productos (nombre, cantidad) VALUES (?, ?)",
                            (producto.nombre, producto.cantidad))
        self.conn.commit()
        return self.cursor.lastrowid

    def obtener_productos(self):
        self.cursor.execute("SELECT * FROM productos")
        return self.cursor.fetchall()

    def actualizar_cantidad(self, id_producto, cantidad):
        self.cursor.execute("UPDATE productos SET cantidad = ? WHERE id_producto = ?",
                            (cantidad, id_producto))
        self.conn.commit()

    def cerrar_conexion(self):
        self.conn.close()
```

### main.py
```python
import tkinter as tk
from pedido import PedidoDAO
from agendamiento import EventoDAO
from inventario import InventarioDAO

class Aplicacion:
    def __init__(self, root):
        self.root = root
        self.root.title("Sistema de gestión de pedidos y eventos")

        # Crear DAOs
        self.pedido_dao = PedidoDAO("pedidos.db")
        self.evento_dao = EventoDAO("eventos.db")
        self.inventario_dao = InventarioDAO("inventario.db")

        # Crear frames
        self.frame_pedido = tk.Frame(self.root)
        self.frame_evento = tk.Frame(self.root)
        self.frame_inventario = tk.Frame(self.root)

        # Crear etiquetas y campos de texto
        self.etiqueta_pedido = tk.Label(self.frame_pedido, text="Pedido:")
        self.etiqueta_pedido.pack(side=tk.LEFT)
        self.campo_pedido = tk.Entry(self.frame_pedido)
        self.campo_pedido.pack(side=tk.LEFT)

        self.etiqueta_evento = tk.Label(self.frame_evento, text="Evento:")
        self.etiqueta_evento.pack(side=tk.LEFT)
        self.campo_evento = tk.Entry(self.frame_evento)
        self.campo_evento.pack(side=tk.LEFT)

        self.etiqueta_inventario = tk.Label(self.frame_inventario, text="Inventario:")
        self.etiqueta_inventario.pack(side=tk.LEFT)
        self.campo_inventario = tk.Entry(self.frame_inventario)
        self.campo_inventario.pack(side=tk.LEFT)

        # Crear botones
        self.boton_pedido = tk.Button(self.frame_pedido, text="Crear pedido", command=self.crear_pedido)
        self.boton_pedido.pack(side=tk.LEFT)

        self.boton_evento = tk.Button(self.frame_evento, text="Crear evento", command=self.crear_evento)
        self.boton_evento.pack(side=tk.LEFT)

        self.boton_inventario = tk.Button(self.frame_inventario, text="Crear producto", command=self.crear_producto)
        self.boton_inventario.pack(side=tk.LEFT)

        # Agregar frames a la ventana
        self.frame_pedido.pack(side=tk.TOP)
        self.frame_evento.pack(side=tk.TOP)
        self.frame_inventario.pack(side=tk.TOP)

    def crear_pedido(self):
        pedido = Pedido(0, "2023-03-01", self.campo_pedido.get(), "Hamburguesa")
        self.pedido_dao.crear_pedido(pedido)
        self.campo_pedido.delete(0, tk.END)

    def crear_evento(self):
        evento = Evento(0, "2023-03-01", "10:00", self.campo_evento.get(), True)
        self.evento_dao.crear_evento(evento)
        self.campo_evento.delete(0, tk.END)

    def crear_producto(self):
        producto = Producto(0, self.campo_inventario.get(), 10)
        self.inventario_dao.crear_producto(producto)
        self.campo_inventario.delete(0, tk.END)

if __name__ == "__main__":
    root = tk.Tk()
    app = Aplicacion(root)
    root.mainloop()
```

**Uso**

1. Correr el archivo `main.py` para ejecutar la aplicación.
2. Se abrirá una ventana con tres frames: "Pedido", "Evento" y "Inventario".
3. En cada frame, se pueden ingresar datos en los campos de texto.
4. Se pueden crear pedidos, eventos y productos pulsando los botones correspondientes.
5. Los datos se almacenan en las bases de datos correspondientes.

**Nota**

* Esta es una implementación básica y no incluye validación de datos ni seguridad.
* La base de datos se crea automáticamente si no existe.
* La aplicación solo se puede ejecutar en un entorno local.