Error: Provide a one-off default now

django error

Si en alguna ocasión al trabajar con Django, y correr una migración recibes el error Provide a one-off default now, entonces este post puede serte de ayuda.

Este error, suele suceder cuando añadimos a un modelo ya existente, una nueva llave (ForeingKey), con un valor determinado.

En este post mostraré dos formas de hacerlo.

Siguiendo la documentación, Añadir una ForeignKey (non-nullable) en Django se divide en tres pasos:

Veamos primero la situación inicial:

class Post(models.Model):
    name = models.CharField(max_length=100)

Paso 1.

Primero se añade la nueva llave, donde primero definiremos null, como null=TRUE y luego desde consola correremos makemigrations().

Esto creará una nueva migración que añade el campo que hemos creado.a la tabla, por tanto ahora tenemos una nueva columna con todas sus filas con valor Null.

class Post(models.Model):
    name = models.CharField(max_length=100)
    category = models.ForeignKey(Category, null=True, on_delete=models.CASCADE))

$ python manage.py makemigrations
Migrations for 'mi_App':
  mi_App/migrations/0002_post_category.py
    - Add field author to post

Paso 2

Ahora correremos nuevamente makemigrations, creando una una nueva migración vacía  (makemigrations --empty).

$ python manage.py makemigrations  --empty -n mi_App assign_category
Migrations for 'mi_App':
 mi_App/migrations/0003_assign_category.py

Ahora  editamos esta migración para que contenga los datos que deseamos, y es en este momento donde de acuerdo a nuestra necesidades colocaremos el valor que debe tener la nueva Foreign key.

from django.db import migrations

def assign_category(apps, schema_editor):
    Category= apps.get_model('category', 'Category')  
    Post = apps.get_model('mi_App', 'Post')               
    
    Post.objects.all().update(category=category)  # and bulk update all posts.


class Migration(migrations.Migration):

    dependencies = [...]

    operations = [
        migrations.RunPython(assign_category, migrations.RunPython.noop),
    ]

Otros posts sobre Django

Paso 3

En el tercer paso modificaremos la nueva ForeignKey en nuestro modelo, eliminando la posibilidad de valor nulo:

null=False 

class Post(models.Model):
    name = models.CharField(max_length=100)
    category = models.ForeignKey(Category, null=False, on_delete=models.CASCADE))

Y creamos una nueva migración corriendo nuevamente makemigrations.

$ python manage.py makemigrations mi_App -n post_category_non_null

Recibirás este mensaje:

You are trying to change the nullable field 'author' on something. to non-nullable without a default; we can't do that (the database needs something to populate existing rows).
Please select a fix:
 1) Provide a one-off default now (will be set on all existing rows with a null value for this column)
 2) Ignore for now, and let me handle existing rows with NULL myself (e.g. because you added a RunPython or RunSQL operation to handle NULL values in a previous data migration)
 3) Quit, and let me add a default in models.py

Seleccionamos la opción 2 y problema resuelto.

Migrations for 'mi_App':
  something/migrations/0004_post_author_non_null.py
    - Alter field category on post

Este es el camino más largo, que sugiere la documentación, pero como siempre hay una posibilidad mas corta:

  1. En la carpeta migraciones eliminamos todas la migraciones existentes,
  2. corremos nuevamente makemigrations, con las modificaciones nuevas.
  3. corremos migrate
  4. creamos nuevamente el superusuario

Con esto quedaría resuelto.

Espero sinceramente, que esto sirva de ayuda a alguien .

……..y para cuando a ti te estén rompiendo el alma, ya el tiempo habrá cicatrizado mis heridas.

A. Torres

Un saludo

AttributeError: _io.TextIOWrapper object has no attribute  split

error en python

El error  _io.TextIOWrapper object has no attribute  split, que nos puede aparecer en Python, en alguna ocasión, suele tener una explicación sencilla.

Tal y como nos dice el propio error, el objeto no posee un atributo o método split().

Según mi experiencia, lo que sucede es que este error común cuando comenzamos , se debe a que estamos confundiendo un tipo de objeto (file), con un tipo de dato(string).

‘El objeto io.TextIOWrapper‘, es el que se obtiene cuando abrimos un documento con open() y este no ha sido leído, ni se ha escrito sobre el.  

El atributo, función o método split() corresponde a objetos de tipo string o cadenas, mientras que los objetos de tipo file, aun cuando  pueden tener un contenido de tipo texto, no son compatibles con split().

Por tanto, es a los string a los que podemos aplicarle  split(), para separar según el elemento que digamos, sus partes.

a= 'serio.jose.alberto.123.124.126' b = a.split('.') print (b)
1
a= 'serio.jose.alberto.123.124.126'
2
b = a.split('.')
3
print (b)
output:
['serio', 'jose', 'alberto', '123', '124', '126']

Hay muchas formas de dividir un objeto tipo file en partes o fragmentos.

Aquí, veremos algunos ejemplos:

Dividiendo un objeto tipo file en líneas

with open('mi_file.txt') as file:  #el metodo open ()pertenece al objeto 
                                   # file, por tanto open
                                   # siempre retorna un objeto tipo file
    mi_file = [line.rstrip('\n') for line in file]

Dividiendo segun otros elementos

Una solución que te permitirá, obtener tu objetivo, por otra vía, es convertir tu objeto file a un objeto string mediante el método read(), y luego aplicarle a este  el método split()

Veámoslo:

with open('/Volumes/Searc/testing/texto.txt','r') as file: #abrimos el objeto file 
    mi_file=file.read()  #lo leemos
    mi_div = mi_file.split(',') # le aplicamos el método split()
    print(mi_div)

La salida seria una lista con el texto dividido según comas.

output:

['Lorem ipsum dolor sit amet', ' consectetur adipiscing elit.\nCurabitur aliquet sem eget magna fermentum', ' non aliquam tortor volutpat.\nNunc pulvinar', ' dolor nec porttitor iaculis', ' diam elit finibus purus', ' et finibus ligula diam luctus erat.\nMorbi placerat sodales ligula. Aliquam iaculis congue libero', ' vel consequat tellus ullamcorper nec.\nPhasellus venenatis tempus pulvinar. Nunc nec fringilla elit. In dignissim nulla eget ligula facilisis cursus.\nVestibulum malesuada nunc sit amet turpis cursus rhoncus sollicitudin quis nisi. Sed pharetra augue nec hendrerit imperdiet.\nVestibulum volutpat dignissim nisl', ' a lobortis lacus hendrerit ut. Suspendisse ac orci felis.\nEtiam arcu tortor', ' lobortis eget commodo in', ' luctus vitae quam.\nDuis convallis', ' metus et luctus convallis', ' metus elit accumsan arcu', ' ac pretium magna justo nec ligula.\nNullam lectus arcu', ' elementum in consectetur id', ' tincidunt id justo.\nCurabitur urna nisl', ' faucibus eget ullamcorper tincidunt', ' tincidunt non ligula.\nCras mi quam', ' venenatis non suscipit vitae', ' fringilla ut tortor. Sed pellentesque turpis quis tincidunt finibus.\nNam eget volutpat metus. Duis viverra', ' mi eget egestas porta', ' purus ligula placerat nunc', ' eu finibus arcu mi eu magna.\nDonec porta lacus ut erat suscipit', ' at tincidunt mi eleifend. Quisque auctor condimentum purus', ' sit amet tempor turpis luctus ac.\nCurabitur placerat tincidunt eros ac lacinia. Curabitur malesuada hendrerit pharetra. Quisque elit ante', ' egestas quis porttitor quis', ' lacinia eu lectus. Donec dictum dictum mattis.']

Python nos permite leer el contenido de un archivo, con read.

El método read, acepta un parámetro o argumento opcional size, para leer l cierta cantidad de datos y devolverlos como una cadena (en modo de texto) o un objeto de bytes (en modo binario).

Si omites el tamaño o es negativo, Python leerá y devolverá todo el contenido del archivo; esto con archivos muy grandes puede afectar la memoria.

Read devuelve una cadena vacia si lleg al final del archivo y no puede leerlo.

Puedes ver lo métodos del objeto file aquí

Y hasta aquí, espero sinceramente que esto sirva de ayuda a alguien.

El viento hincha la vela, pero la deshilacha y hay tantas velas rotas en el fondo del mar.

J. A. Buesa

TypeError: module.__init__() takes at most 2 arguments (3 given)

python error

TypeError: module.__init__() takes at most 2 arguments (3 given), como su nombre indica, es un error de tipo, que generalmente hace referencia a la estructura que empleamos al importar nuestro módulos, para construir objetos en Python.

La estructura correcta al importar debería seguir esta lógica.

from Object
import ClassName

Para definir la clase podría ser

class Visitor(Object.ClassName):

Podemos también hacer esto:

from Object
import Object as Parent

Y en la definición de la clase llamar directamente a parent

class Visitor(Parent):

Errores en Python

Una estructura adecuada incluso, puede extenderse a diferentes módulos en algo como esto:

from zonas
import NomenclaturaZonas

Si deseáramos emplearlo en otro modulo podría ser: 

from zonas.NomenclaturaZonas
import NomenclaturaZonas

Si nuestro archivo es Parent1 y el classname Parent, podemos escribirlo de esta forma: 

from Parent1
import Parent

Sin embargo, si Parent1.py esta dentro de una carpeta con esta ruta

DemoFolder - > Parent1.py - > Parent(Folder).(File).(Class name)

La forma de acceder seríaa.

from Test.Parent1
import Parent

Y hasta aquí, espero que sinceramente ayudar a alguien con este post.

Subir montañas, hermana hombres

J.Martí

NameError en Python

python error

El error  NameError en Python   ocurre cuando el intérprete CPython no reconoce un nombre de objeto local o global que se haya proporcionado en el código fuente de Python.

Este error hereda de Exception que a su vez se extiende  BaseException

BaseException  -> Exception -> NameError

Emplearemos este código de ejemplo:

import dis


from gw_utility.logging import Logging


def main():
    try:
        # Create Auto.
        auto = Auto("Chevrolet, "Bell Air", 50, datetime.date(1956))

        # Log auto object.
        Logging.line_separator("log_object(auto)", 60)
        log_object(auto)

        # Log invalid object.
        Logging.line_separator("log_invalid_object(auto)", 60)
        log_invalid_object(auto)

        # Disassemble both log_ functions.
        Logging.line_separator("DISASSEMBLY OF log_object()", 60)
        disassemble_object(log_object)

        Logging.line_separator("DISASSEMBLY OF log_invalid_object()", 60)
        disassemble_object(log_invalid_object)
    except NameError as error:
        # Salida esperada es NameErrors.
        Logging.log_exception(error)
    except Exception as exception:
        # Salida inesperada es una Excepcion.
        Logging.log_exception(exception, False)


def log_object(value):
    """Registro del valor de parametro pasado a consola.

    :param value: Value to be logged.
    :return: None
    """
    try:
        Logging.log(value)
    except NameError as error:
        # Salida esperada es NameErrors
        Logging.log_exception(error)
    except Exception as exception:
        # Salida inesperada es una Excepcion.
        Logging.log_exception(exception, False)


def log_invalid_object(value):
    """Intenta  registrar el objeto invalido  valu en la consola

    :param value: Value intended to be logged, but which is instead ignored.
    :return: None
    """
    try:
        Logging.log(valu)
    except NameError as error:
        # Salida esperada es NameErrors
        Logging.log_exception(error)
    except Exception as exception:
        # Salida inesperada es una Excepcion.
        Logging.log_exception(exception, False)


def disassemble_object(value):
    """salida desensamblada del objeto pasado.

    :param value: Object to be disassembled.
    :return: None
    """
    dis.dis(value)


if __name__ == "__main__":
    main()

# auto.py
import datetime


class Auto:
    marca: str
    modelo: int
    potencia: str
    año de fabricación: datetime.date
    potencia: str

    def __eq__(self, other):
        """Determina si el objeto pasado, es equivalente al objeto actual"""
        return self.__dict__ == other.__dict__

    def __init__(self,
                 marca: str = None,
                 modelo: str = None,
                 potencia: int = None,
                 año_fabricacion: datetime.date = None):
        """Inicializa una instanci de Auto .

        :param marca: Nombre de la marca.
        :param modelo: Modelo.
        :param potencia: Potencia en HP.
        :param año_fabricacion: Año de fabricación.
        """
        self.marca = marca
        self.modelo = modelo
        self.potencia = potencia
        self.año_fabricacion = año_fabricacion

    def __getattr__(self, marca: str):
        """Devuelve el atributo pasado comparandolo con marca."""
        # Get internal dict value matching marca.
        value = self.__dict__.get(marca)
        if not value:
            # Lanza AttributeError si el atributo no se encuentra.
            raise AttributeError(f'{self.__class__.__marca__}.{marca} is invalid.')
        # Devuelve el valor del atributo
        return value

    def __len__(self):
        """Devuelve la longitud de la marca."""
        return len(self.title)

    def __str__(self):
        """Retorna una cadena formateada que representa a SAuto."""
        año_fabricacion = '' if self.año_fabricacion is None else f', fabricado en {self.año_fabricacion.__format__(" %Y")}'
        potencia = '' if self.potencia is None else f' con {self.potencia}  de fuerza'
        return f'\'{self.modelo}\'  de la marca {self.marca} con {potencia} HP, fabricado en {año_fabricacion}.'

Desglosaremos ahora el código para explicar el error

Comenzaremos con  parte del  código de ejemplo, que vimos antes escrito  en Python normal; después de lo cual veremos cómo podemos desensamblar este código en el código de bytes que CPython realmente lee e interpreta.

log_object y log_invalid_object

Vamos a emplear dos funciones, que  Python posee para esto log_object(value)  y log_invalid_object(value):

def log_object(value):
    """Registra los valores pasados al parametro en consola.

    :param value: Valor a registrar.
    :return: None
    """
    try:
        Logging.log(value)
    except NameError as error:
        # Salida esperada NameErrors.
        Logging.log_exception(error)
    except Exception as exception:
        # Salida inesperada Exceptions.
        Logging.log_exception(exception, False)


def log_invalid_object(value):
    """Intenta registrar objetos no validos(value) en consola 

    :param value: Valor que se ha intentado registrar, pero que en realidad se ha ignorado 
    :return: None
    """
    try:
        Logging.log(valu)
    except NameError as error:
        # Salida esperada NameErrors.
        Logging.log_exception(error)
    except Exception as exception:
        # Salida inesperada Exceptions.
        Logging.log_exception(exception, False)

Todo el código en ambas funciones se centra en el manejo de errores.

La funcionalidad principal tiene lugar en la línea: Logging.log (valor) y Logging.log (valu), respectivamente.

En esencia, estas dos funciones lo que hacen es registrar el contenido del parámetro de valor pasado en la consola. Sin embargo, en el caso de log_invalid_object () tenemos un leve error tipográfico de valu en lugar de value.

Creemos una instancia del objeto Auto  y  luego la pasaré a ambas funciones:

# Creando Auto.
auto = Auto("Chevreolet", "Bell air", 300hp, datetime.date(1956))
# Log Auto object.
Logging.line_separator("log_object(auto)", 60)
log_object(auto)
 
# Log invalid object.
Logging.line_separator("log_invalid_object(auto)", 60)
log_invalid_object(auto)

La ejecución de este código produce una salida del objeto Auto esperada, seguida de un NameError porque nuestro error tipográfico de valu no es un nombre reconocido.

--------------------- log_object(auto) ---------------------
'Bellair' de la marca Chevrolet con 30 HP, fabricado en 1956.
{self.modelo}\'  de la marca {self.marca} con {potencia} HP, fabricado en {año_fabricacion}.'
 
----------------- log_invalid_object(auto) -----------------
[EXPECTED] NameError: name 'valu' is not defined

Si aplicaramos el metodo    dis, que es un modulo desensamblador integrado en Python, lo cual le permite es un lenguaje poderoso que nos permite mirar profundizar y ver el código de bytes real que cada una de estas funciones log_  que se generan para el intérprete CPython.

Al pasar una referencia de función al método dis.dis (), se nos proporciona una salida completa del código de bytes desensamblado que CPython interpreta durante la ejecución.

Nuestra función local  disassemble_object(value), funciona como una pequeña envoltura para este propósito:

def disassemble_object(value):
    """Salida con el objeto desensamblado pasado.

    :param value: Object to be disassembled.
    :return: None
    """
    dis.dis(value)

Para ver el bytecode de la función log_object (value) ejecutemos el código:

# Disassemble both log_ functions.
Logging.line_separator("DISASSEMBLY OF log_object()", 60)
disassemble_object(log_object)

This produces the following output:

--------------- DISASSEMBLY OF log_object() ----------------
 41           0 SETUP_EXCEPT            14 (to 16)

 42           2 LOAD_GLOBAL              0 (Logging)
              4 LOAD_ATTR                1 (log)
              6 LOAD_FAST                0 (value)
              8 CALL_FUNCTION            1
             10 POP_TOP
             12 POP_BLOCK
             14 JUMP_FORWARD            88 (to 104)

 43     >>   16 DUP_TOP
             18 LOAD_GLOBAL              2 (NameError)
             20 COMPARE_OP              10 (exception match)
             22 POP_JUMP_IF_FALSE       58
             24 POP_TOP
             26 STORE_FAST               1 (error)
             28 POP_TOP
             30 SETUP_FINALLY           16 (to 48)

 45          32 LOAD_GLOBAL              0 (Logging)
             34 LOAD_ATTR                3 (log_exception)
             36 LOAD_FAST                1 (error)
             38 CALL_FUNCTION            1
             40 POP_TOP
             42 POP_BLOCK
             44 POP_EXCEPT
             46 LOAD_CONST               1 (None)
        >>   48 LOAD_CONST               1 (None)
             50 STORE_FAST               1 (error)
             52 DELETE_FAST              1 (error)
             54 END_FINALLY
             56 JUMP_FORWARD            46 (to 104)

 46     >>   58 DUP_TOP
             60 LOAD_GLOBAL              4 (Exception)
             62 COMPARE_OP              10 (exception match)
             64 POP_JUMP_IF_FALSE      102
             66 POP_TOP
             68 STORE_FAST               2 (exception)
             70 POP_TOP
             72 SETUP_FINALLY           18 (to 92)

 48          74 LOAD_GLOBAL              0 (Logging)
             76 LOAD_ATTR                3 (log_exception)
             78 LOAD_FAST                2 (exception)
             80 LOAD_CONST               2 (False)
             82 CALL_FUNCTION            2
             84 POP_TOP
             86 POP_BLOCK
             88 POP_EXCEPT
             90 LOAD_CONST               1 (None)
        >>   92 LOAD_CONST               1 (None)
             94 STORE_FAST               2 (exception)
             96 DELETE_FAST              2 (exception)
             98 END_FINALLY
            100 JUMP_FORWARD             2 (to 104)
        >>  102 END_FINALLY
        >>  104 LOAD_CONST               1 (None)
            106 RETURN_VALUE

Esto puede parecer un poco abrumador al principio, pero estos datos en realidad son bastante fáciles de interpretar con un poco de conocimiento sobre lo que estamos viendo en cada columna. La primera columna (por ejemplo, 41, 42, 43… 48) es el número de línea real en la gama de origen para el conjunto de instrucciones correspondiente.

Por lo tanto, podemos ver que todas las siguientes instrucciones

42           2 LOAD_GLOBAL              0 (Logging)
              4 LOAD_ATTR                1 (log)
              6 LOAD_FAST                0 (value)
              8 CALL_FUNCTION            1
             10 POP_TOP
             12 POP_BLOCK
             14 JUMP_FORWARD            88 (to 104)

 Todos se generaron a partir de una sola línea de código fuente (# 42):

La columna con múltiplos de dos (0, 2, 4, etc.) es la dirección de memoria en el código de bytes subyacente para la instrucción dada. Python moderno almacena instrucciones usando dos bytes de datos, de ahí los múltiplos de dos.

La siguiente columna contiene el nombre de operación (es decir, instrucción) que debe ejecutarse, todo lo cual se puede encontrar en la documentación oficial.

La columna posterior contiene los argumentos, si corresponde, que utilizará cada instrucción en particular.

La columna final proporciona una versión amigable para los humanos de la instrucción, por lo que podemos visualizar mejor cómo la instrucción del código de bytes se correlaciona con el código fuente.

Por lo tanto, echemos un vistazo al código fuente de una sola línea 42 de Logging.log (value) y el conjunto de instrucciones de bytecode generado para ver qué está pasando:

42           2 LOAD_GLOBAL              0 (Logging)
              4 LOAD_ATTR                1 (log)
              6 LOAD_FAST                0 (value)
              8 CALL_FUNCTION            1
             10 POP_TOP
             12 POP_BLOCK
             14 JUMP_FORWARD            88 (to 104)

Comienza con LOAD_GLOBAL para cargar el nombre global Logging en la pila.

Luego carga el atributo de registro en la parte superior de la pila (TOS).

LOAD_FAST empuja una referencia a una variable local llamada value en la pila y a continuación, CALL_FUNCTION llama a la función en la pila de argumentos 1, que es el método de registro que se agregó dos instrucciones antes.

POP_TOP elimina el elemento más reciente agregado a la pila, que es el objeto de valor local.

Cada marco de ejecución contiene una pila de bloques de código, que son las agrupaciones lógicas que vemos y creamos al escribir el código fuente que está agrupado localmente.

Por ejemplo, un bucle anidado o, en este caso, un bloque try-except, está contenido dentro de un bloque de código separado en la pila.

Dado que la siguiente instrucción a la que estamos saltando con JUMP_FORWARD 88 está saliendo del final del bloque try que se encuentra en nuestro código fuente, POP_BLOCK se usa para eliminar el bloque superior (actual) de la pila de bloques de código.

Veamos en qué se diferencia este bytecode compilado para log_object, de la función log_invalid_object ligeramente modificada:

Logging.line_separator("DISASSEMBLY OF log_invalid_object()", 60)
disassemble_object(log_invalid_object)

Ignoraremos la mayoría del bytecode producido aquí, ya que es idéntico al producido por log_object, pero también tenemos el conjunto de instrucciones de la misma línea de código fuente Logging.log (valu) correspondiente que examinamos antes:

58           2 LOAD_GLOBAL              0 (Logging)
              4 LOAD_ATTR                1 (log)
              6 LOAD_GLOBAL              2 (valu)
              8 CALL_FUNCTION            1
             10 POP_TOP
             12 POP_BLOCK
             14 JUMP_FORWARD            88 (to 104)

Todo se ve exactamente igual que antes, con dos excepciones: el número de línea 58 es obviamente diferente, ya que estamos compilando una línea diferente de código fuente.

La segunda diferencia es que la tercera instrucción, cambió de LOAD_FAST 0 (value) a LOAD_GLOBAL2(valu).

¿Por qué sucedió esto?. Pues porque el compilador no puede conciliar un objeto local llamado valu, ya que el parámetro local real pasado a la función es value.

Por lo tanto, el compilador asume que valu es un nombre global e intenta cargarlo a través de LOAD_GLOBAL, y como sabemos al ejecutar la función log_invalid_object, el intérprete de CPython no será capaz de ubicar un objeto llamado valu durante la ejecución, por lo que se genera un NameError para indicarlo.

.. y todo como el diamante, antes de luz , es carbón.

J. Martí

Error HY000/1045: Acceso denegado para el usuario ‘root’ @ ‘localhost’ (usando la contraseña: NO)

error php

Si has recibido el error mysqli_real_connect (): (HY000/1045): Acceso denegado para el usuario ‘root’ @ ‘localhost’ (usando la contraseña: NO) phpMyAdmin intentó conectarse al servidor MySQL y el servidor rechazó la conexión…; aquí intento explicarte como resolverlo.

Tanto para usuarios de Xampp como Lamp, el problema radica en que se esta intentando una conexión a SQL con un usuario que no existe.

Veamos el error:

En el archivo config-db.php, que encontrarás en esta ruta ( /etc/phpmyadmin/config-db.php) existen 2 variables: $ dbuser y $ dbpass, que indican los parámetros de conexión de MySQL.

En el mismo archivo existen otros parámetros importantes que podemos modificar como la dirección del servidor ($ dbserver), el puerto ($ dbport), y otros  que pueden ser de utilidad alterar, ante problemas de conexión.

La solución por tanto, es modificar el config-db.php y configurar su contraseña, con la contraseña que le dio al usuario root , o si no tiene una contraseña, dejarla vacía de este modo ''.

Vaya al archivo config.inc.php y busque – $ cfg ['Servidores'] [$ i] ['auth_type']

Cambie el valor de $ cfg ['Servers'] [$ i] ['auth_type'] a ‘cookie’ o ‘http’.

$cfg['Servers'][$i]['auth_type'] = 'HTTP';

Nota- si elige el tipo de autenticación como cookie, cada vez que cierre el navegador y lo vuelva a abrir, deberá iniciar sesión nuevamente.

Cambie el valor de  $ cfg [‘Servers’] [$ i] [‘password’] a vacio »

$cfg['Servers'][$i]['password'] = ''; <-tu contraseña 

En  $ cfg [‘Servidores’] [$ i] [‘AllowNoPassword’] y cambie su valor a verdadero.

$cfg['Servers'][$i]['AllowNoPassword'] = 'TRUE'; 

Tambien podemos hacerlo desde las funciones para usuario avanzado

/* User for advanced features */
$cfg['Servers'][$i]['controluser'] = 'tu usuario';
$cfg['Servers'][$i]['controlpass'] = 'tu contraseña'; /* '' para dejar vacio */

En total oscuridad, cualquier cosa puede ser luz

Y

ImportError: No module named MySQLdb

python error

ImportError: No module named MySQLdb, es un error que Python lanza cuando tiene problemas para compilar la extensión binaria, de consultas mysql.

Una solución a esto es intentar resolverlo con Python puro empleando PyMySQL

Para ello simplemente debe ser instalado de con pip.

Ver otros errores de Python

pip install pymysql 

Si estas empleando SQLAlchemy también debe cambiarse la URI, para que comience incluyendo pymysql:

SQLALCHEMY_DATABASE_URI = 'mysql+pymysql://.....'

En dependencia de la estructura de tu código y las librerías mysql que emplea, otra solución es instalar el cliente de mysql para Python, mediante pip.

Si usas Python 3

   pip3 install mysqlclient

Si estas aun Python2

pip install mysqlclient

Tambien puedes instalar mysql-python

pip install mysql-python

Y esto es todo, espero modestamente que este post, sirva de ayuda a alguien.

Muchas gracias

El amor tiene firma de autor en las causas perdidas

R.Arjona

Error EOFError en Python

python error

El error EOFError, es un tipo de error que suele aparecer con cierta regularidad en Python y que podemos manipular con excepciones.

Se genera cuando una de las funciones integradas input () o raw_input () alcanza una condición de fin de archivo (EOF) sin leer ningún dato.

Esto ocurre cuando le hemos pedido al usuario una entrada pero no hemos proporcionado ninguna entrada en el cuadro de entrada.

Este error, a veces se experimenta al usar IDE en línea.

Podemos solucionar este problema usando try y except, para manipular la excepción.

Podemos solucionar este problema usando try y except, para manipular la excepción.

Un código como este, arrojará un error del  tipo EOFerror

Podemos manejarlo de la siguiente forma:

n = int(input())
print(n * 10)

Podemos manejarlo de la siguiente forma:

try:
    n = int(input())
    print(n * 10)
    
except EOFError as e:
    print(e)

Lee sobre otros errores de Python en este blog

Hay que sembrar un árbol, un ansia, un sueño, un hijo, porque la vida es eso , sembrar, sembrar, sembrar

J. A. Buesa

NameError: name exit is not defined

python error

En este post veremos el NameError: name exit is not defined, en  Python que cómo indica es un error de nombre, y que podemos solucionar con cierta facilidad.

Ver más errores en Python en este blog

La solución a esto es importar sys y luego importar exit.

Seria algo así:

from sys
import exit
exit()

También puede intentar esta vía

import sys
sys.exit()

Y esto es todo, debería funcionar.

Espero sinceramente que este post, sirva de ayuda  a alguien y muchas gracias.

Entrena duro y en silencio, que el éxito sea tu grito

D.

KeyError en Python

python error

En este post analizaremos cómo se origina  el KeyError, en Python y como surge esta excepción.

El KeyError se genera, cuando se accede a una clave (key) no válida dentro de un diccionario (dict).

Veamos primero la jerarquía general de  las Exceptions Class  de Python.

Resumiendo

Todas las excepciones de Python heredan de la clase BaseException o se extienden desde una clase heredada en la misma.

La jerarquía de excepciones completa de este error es:

BaseException

¿Cuándo debería usarlo?

Dado que IndexError trata con listas y KeyError trata con dictados, deberíamos explorar brevemente la diferencia entre estas dos estructuras de datos comunes en Python. Las listas de Python son similares a las matrices en la mayoría de los otros lenguajes de programación. Es una colección ordenada de objetos que se asignan en un índice numérico incremental para identificar cada elemento.

Las listas se usan comúnmente como pilas, lo que permite el comportamiento de «primero en entrar, último en salir».

Los dictados, por otro lado, se conocen como matrices asociativas en la mayoría de los otros lenguajes. Un dictado también es una colección de objetos, pero no está ordenado, y en lugar de usar índices numéricos, un dictado usa tipos de datos inmutables como claves.

Ahora te será fácil entender que siempre que veas una referencia a los pares clave: valor en Python, esto es una indicación de que la colección que contiene esos pares es un dict o diccionario.

La comprensión del error es muy simple, si creamos un diccionario e intentamos acceder a una clave que no existe, se generará un KeyError

Resultado incorrecto al dividir números grandes en Python3.

python error

Si te ha sucedido ya, te explico porque obtienes un resultado incorrecto al dividir números grandes en Python 3.

 Es cierto que Python 3 da errores en el resultado cuando divides dos números muy largos, empleando el símbolo /.

Esto se debe a que en Python 3.x  el símbolo / significa división de punto flotante y con números muy grandes, puede dar pequeños errores de redondeo.

Lo correcto es usar // para  la división de enteros.

Por ejemplo:

d = a // (b*c)

Espero haber ayudado a alguien.

Muchas gracias

El que siempre soñó, tiene derecho a ganar

I.Delgado