Visualizza post

Questa sezione ti permette di visualizzare tutti i post inviati da questo utente. N.B: puoi vedere solo i post relativi alle aree dove hai l'accesso.


Topics - bancaldo

Pagine: [1] 2 3
1
SO = WINDOWS 7
wx = 3.0.2.0 msw (classic)
python = 2.7.8

Buongiorno a tutti.

Ho un problema quando creo un frame child utilizzando un LIST-EVENT invece di un COMMAND-EVENT.
Ovvero:
- Se bindo la callback che creerà il frame figlio a command-events quali EVT_MENU e EVT_BUTTON,
non ho problemi, il frame child viene creato ed è in primo piano.

- Se invece bindo la callback ad un List-Event (wx.EVT_LIST_COL_CLICK), questo viene sì creato,
ma rimane coperto dal frame padre, rimane cioè in secondo piano.

L'unico modo con il quale riesco a creare il child frame in primo piano da wx.ListEvent è
utilizzando il flag wx.STAY_ON_TOP con il metodo SetWindowStyle (commentato nel codice),
Quest però mi elimina lo stile della finestra stessa, visualizzando solo il panel nudo, cosa peraltro che accade solo su Windows 7 e non su
Linux (ubuntu + xfce4)

Di seguito posto un codice tirato all'osso per chi volesse gentilmente fare due prove.

[codice]
import wx
from wx.lib.mixins.listctrl import ListCtrlAutoWidthMixin


ACV = wx.ALIGN_CENTER_VERTICAL


class AutoWidthListCtrl(wx.ListCtrl, ListCtrlAutoWidthMixin):
    def __init__(self, parent):
        wx.ListCtrl.__init__(self, parent, -1, style=wx.LC_REPORT)
        ListCtrlAutoWidthMixin.__init__(self)


class MainFrame(wx.Frame):
    def __init__(self, parent):
        super(MainFrame, self).__init__(parent=parent)
        self.parent = parent
        self.panel = PanelMainFrame(self)
        self.child = None

        self.menu_bar = wx.MenuBar()
        self.SetMenuBar(self.menu_bar)
        m_open = wx.Menu()
        self.menu_bar.Append(m_open, "Open")
        self.m_new = m_open.Append(-1, "Subframe", "Open subframe")

        self.Bind(wx.EVT_MENU, self.on_new, self.m_new)
        self.Bind(wx.EVT_BUTTON, self.on_new, self.panel.btn_new)
        self.Bind(wx.EVT_LIST_COL_CLICK, self.on_new, self.panel.list_control)

        size = (300, 300)
        self.SetSize(size)
        self.Centre()
        self.Show()
        print "Top Window: ", wx.GetApp().TopWindow

    def on_new(self, event):
        if not self.child:
            self.child = SubFrame(parent=self)
            if isinstance(event, wx.ListEvent):
                pass
                # self.child.SetWindowStyle(wx.STAY_ON_TOP)


class PanelMainFrame(wx.Panel):
    def __init__(self, parent):
        super(PanelMainFrame, self).__init__(parent=parent)
        self.list_control = AutoWidthListCtrl(self)
        self.list_control.InsertColumn(0, 'value', wx.LIST_FORMAT_RIGHT, 100)

        btn_sizer = wx.FlexGridSizer(rows=1, cols=2, hgap=5, vgap=5)
        self.btn_new = wx.Button(self, wx.ID_OK, label="Subframe")
        btn_sizer.Add(self.btn_new, 0, wx.EXPAND)

        sizer = wx.BoxSizer(wx.VERTICAL)
        sizer.Add(wx.StaticText(self, label="Data"), 0, ACV)
        sizer.Add(self.list_control, 1, wx.EXPAND | wx.ALL, 5)
        sizer.Add(btn_sizer, 0, wx.EXPAND | wx.ALL, 5)
        self.SetSizer(sizer)


class SubFrame(wx.Frame):
    def __init__(self, parent):
        self.parent = parent
        super(SubFrame, self).__init__(parent=parent)
        self.panel = wx.Panel(parent=self)
        self.SetSize((150, 150))
        self.Centre()
        self.Show()


if __name__ == '__main__':
    app = wx.App(False)
    v = MainFrame(parent=None)
    app.SetTopWindow(v)
    app.MainLoop()
[/codice]

Spero il codice sia leggibile,
saluti e grazie.

2
Ciao a tutti,
avrei una domanda di carattere stilistico riguardante la grafica di un'applicazione generica.
In questo caso specifico utilizzo le wx e ho rimosso ogni traccia di pattern MVC altrimenti il post diventerebbe eterno.
Vorrei sapere quali sono le cose da NON fare, perchè concettualmente sbagliate (anche se funzionanti)

Supponiamo di avere un frame che mi consenta di salvare un oggetto generico ed un altro che lo editi. Se doveste scegliere come strutturare la cosa, come fareste?
Io, di solito, uso indifferentemente questi 3 metodi, a seconda di come mi tira al momento.

Metodo 1: il frame per l'edit è una sottoclasse dal primo usato per l'inserimento

[codice]import wx


class ViewNew(wx.Frame):
    def __init__(self, parent, title):
        self.parent = parent
        self.title = title
        super(ViewNew, self).__init__(parent=self.parent, title=title)
        self._build()
        self._bind_widgets()
        self.Centre()
        self.Show()

    def _build(self):
        self.panel = PanelNew(parent=self)
        sizer = wx.BoxSizer(wx.VERTICAL)
        sizer.Add(self.panel, 1, wx.EXPAND)
        self.SetSizer(sizer)
        self.SetSize((200, 150))

    def _bind_widgets(self):
        pass
        # qui faccio il bind dei miei widgets alle callbacks
       
    # callbacks legate ai widgets


class PanelNew(wx.Panel):
    def __init__(self, parent):
        super(PanelNew, self).__init__(parent)
        self.name = wx.TextCtrl(self)
        # Layout
        text_sizer = wx.FlexGridSizer(rows=1, cols=2, hgap=5, vgap=5)
        text_sizer.Add(wx.StaticText(self, label="name:"),
                       0, wx.ALIGN_CENTER_VERTICAL)
        text_sizer.Add(self.name, 0, wx.EXPAND)
        text_sizer.AddGrowableCol(1)
        button_sizer = wx.StdDialogButtonSizer()
        self.btn_save = wx.Button(self, wx.ID_SAVE)
        self.btn_quit = wx.Button(self, wx.ID_CANCEL)
        self.btn_quit.SetDefault()
        button_sizer.AddButton(self.btn_save)
        button_sizer.AddButton(self.btn_quit)
        sizer = wx.BoxSizer(wx.VERTICAL)
        sizer.Add(text_sizer, 1, wx.EXPAND | wx.ALL, 5)
        sizer.Add(button_sizer, 0, wx.ALIGN_CENTER | wx.ALL, 5)
        button_sizer.Realize()
        self.SetBackgroundColour('LightGray')
        self.SetSizer(sizer)


class ViewEdit(ViewNew):
    def __init__(self, parent, title):
        self.parent = parent
        super(ViewEdit, self).__init__(parent=self.parent, title=title)
        self._additional_bindings()

    def _additional_bindings(self):
        pass
        # qui faccio il bind ai widget addizionali come la Combobox
   
    # qui sovrascrivo ViewNew._build method
    # per creare il pannello ulteriore (edit)
    def _build(self): 
        self.panel_edit = PanelEdit(parent=self)
        self.panel = PanelNew(parent=self)
        sizer = wx.BoxSizer(wx.VERTICAL)
        sizer.Add(self.panel_edit, 0, wx.EXPAND)
        sizer.Add(self.panel, 1, wx.EXPAND)
        self.SetSizer(sizer)
        self.SetSize((200, 150))

    # additional callbacks


class PanelEdit(wx.Panel):
    def __init__(self, parent):
        super(PanelEdit, self).__init__(parent)
        # Attributes

        self.names = ['a', 'b', 'c']  # in realta' qui avro' un iterable
                                      # derivante dal controller...
        self.cb_names = wx.ComboBox(self, -1, "", choices=self.names,
                                    style=wx.CB_DROPDOWN)
        sizer = wx.FlexGridSizer(rows=1, cols=2, hgap=5, vgap=5)
        sizer.Add(wx.StaticText(self, label="names:"), 0,
                  wx.ALIGN_CENTER_VERTICAL)
        sizer.Add(self.cb_names, 0, wx.EXPAND)
        sizer.AddGrowableCol(1)
        self.SetBackgroundColour('LightGray')
        self.SetSizer(sizer)


if __name__ == '__main__':
    app = wx.App()
    # v = ViewNew(None, title='New Name')
    v = ViewEdit(None, title='Edit Name')
    app.MainLoop()
[/codice]

Pro: pannelli separati
Contro: lunghezza del codice e codice ripetitivo.


Metodo 2: il frame è unico e sono presenti tutti i widgets che disabilito a seconda delle esigenze

[codice]import wx


class ViewName(wx.Frame):
    def __init__(self, parent, title, is_editor=False):
        self.parent = parent
        self.title = title
        self.is_editor = is_editor
        super(ViewName, self).__init__(parent=self.parent, title=title)
        self._build()
        self._bind_widgets()
        self.Centre()
        self.Show()

    def _build(self):
        self.panel = PanelName(parent=self)
        sizer = wx.BoxSizer(wx.VERTICAL)
        sizer.Add(self.panel, 1, wx.EXPAND)
        self.SetSizer(sizer)
        self.SetSize((200, 200))
        if not self.is_editor:
            self.panel.cb_names.Disable()

    def _bind_widgets(self):
        pass
        # qui faccio il bind dei miei widgets alle callbacks
       
    # callbacks legate ai widgets


class PanelName(wx.Panel):
    def __init__(self, parent):
        super(PanelName, self).__init__(parent)
        self.names = ['a', 'b', 'c']  # in realta' qui avro' un iterable
                                      # derivante dal controller...
        self.cb_names = wx.ComboBox(self, -1, "", choices=self.names,
                                    style=wx.CB_DROPDOWN)
        self.name = wx.TextCtrl(self)
        # Layout
        text_sizer = wx.FlexGridSizer(rows=2, cols=2, hgap=5, vgap=5)
        text_sizer.Add(wx.StaticText(self, label="names:"),
                       0, wx.ALIGN_CENTER_VERTICAL)
        text_sizer.Add(self.cb_names, 0, wx.EXPAND)
        text_sizer.Add(wx.StaticText(self, label="name:"),
                       0, wx.ALIGN_CENTER_VERTICAL)
        text_sizer.Add(self.name, 0, wx.EXPAND)
        text_sizer.AddGrowableCol(1)
        button_sizer = wx.StdDialogButtonSizer()
        self.btn_save = wx.Button(self, wx.ID_SAVE)
        self.btn_quit = wx.Button(self, wx.ID_CANCEL)
        self.btn_quit.SetDefault()
        button_sizer.AddButton(self.btn_save)
        button_sizer.AddButton(self.btn_quit)
        sizer = wx.BoxSizer(wx.VERTICAL)
        sizer.Add(text_sizer, 1, wx.EXPAND | wx.ALL, 5)
        sizer.Add(button_sizer, 0, wx.ALIGN_CENTER | wx.ALL, 5)
        button_sizer.Realize()
        self.SetBackgroundColour('LightGray')
        self.SetSizer(sizer)


if __name__ == '__main__':
    app = wx.App()
    v = ViewName(None, title='New Name', is_editor=False)
    # v = ViewName(None, title='Edit Name', is_editor=True)
    app.MainLoop()
[/codice]

pro: codice più breve
contro: la necessità di un flag (is_editor) interno e la presenza di widgets "morti"

Metodo 2: il frame è unico ma sono presenti SOLO i widgets che mi servono davvero

[codice]
import wx


class ViewName(wx.Frame):
    def __init__(self, parent, title, is_editor=False):
        self.parent = parent
        self.title = title
        self.is_editor = is_editor
        super(ViewName, self).__init__(parent=self.parent, title=title)
        self._build()
        self._bind_widgets()
        self.Centre()
        self.Show()

    def _build(self):
        self.panel = PanelName(parent=self)
        sizer = wx.BoxSizer(wx.VERTICAL)
        sizer.Add(self.panel, 1, wx.EXPAND)
        self.SetSizer(sizer)
        self.SetSize((200, 200))

    def _bind_widgets(self):
        pass
        # qui faccio il bind dei miei widgets alle callbacks
       
    # callbacks legate ai widgets


class PanelName(wx.Panel):
    def __init__(self, parent):
        super(PanelName, self).__init__(parent)
        self.name = wx.TextCtrl(self)
        # qui decido la griglia del panel
        rows = 1 if parent.is_editor else 2
        text_sizer = wx.FlexGridSizer(rows=rows, cols=2, hgap=5, vgap=5)

        if not parent.is_editor:
            self.names = ['a', 'b', 'c']  # in realta' qui avro' un iterable
                                          # derivante dal controller...
            self.cb_names = wx.ComboBox(self, -1, "", choices=self.names,
                                    style=wx.CB_DROPDOWN)
            text_sizer.Add(wx.StaticText(self, label="names:"),
                           0, wx.ALIGN_CENTER_VERTICAL)
            text_sizer.Add(self.cb_names, 0, wx.EXPAND)
        text_sizer.Add(wx.StaticText(self, label="name:"),
                       0, wx.ALIGN_CENTER_VERTICAL)
        text_sizer.Add(self.name, 0, wx.EXPAND)
        text_sizer.AddGrowableCol(1)
        button_sizer = wx.StdDialogButtonSizer()
        self.btn_save = wx.Button(self, wx.ID_SAVE)
        self.btn_quit = wx.Button(self, wx.ID_CANCEL)
        self.btn_quit.SetDefault()
        button_sizer.AddButton(self.btn_save)
        button_sizer.AddButton(self.btn_quit)
        sizer = wx.BoxSizer(wx.VERTICAL)
        sizer.Add(text_sizer, 1, wx.EXPAND | wx.ALL, 5)
        sizer.Add(button_sizer, 0, wx.ALIGN_CENTER | wx.ALL, 5)
        button_sizer.Realize()
        self.SetBackgroundColour('LightGray')
        self.SetSizer(sizer)


if __name__ == '__main__':
    app = wx.App()
    v = ViewName(None, title='New Name')
    #v = ViewName(None, title='Edit Name', is_editor=True)
    app.MainLoop()
[/codice]

pro: codice breve e interfaccia più pulita
contro: la necessità di un flag (is_editor) interno e la presenza di condizioni if all'interno del codice


Mi rendo conto sia un problema del menga, ma mi piacerebbe sapere se sia o meno esistente uno
"stato dell'arte" su questo tipo di cose. A me ad esempio, piace infinitamente di più il terzo metodo,
ma forse non è bene incasinare con degli if la struttura del panel. If che troverei anche nella callback
legata al Button condiviso.

A voi, sono tutto occhi!

ciao
Buona giornata


3
ForumPython.it cafè / ex-machina: python
« il: Agosto 04, 2015, 12:27 »
Ieri sera sono stato al cinema a vedere "ex machina". Ad un certo punto si intravede un interprete del film, scrivere codice in python.
Niente di ché, ma é stato buffo.
Mi sono sentito ancora più dentro al film  :)

4
Buongiorno a tutti.
Ho un problema che si verifica con l'utilizzo di Pyinstaller e
Flask_SQLAlchemy.

Ho un programma che, ridotto all'osso, si compone di un file data:

[codice]# data.py

import os
from flask import Flask
from flask_sqlalchemy import SQLAlchemy

import flask_sqlalchemy._compat as _
import flask_script as fs

DB_NAME = 'test.db'

app = Flask(__name__)
db = SQLAlchemy(app)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///%s' % DB_NAME
app.config['SQLALCHEMY_ECHO'] = False


class Person(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(40), unique=True)

    def __init__(self, name):
        self.name = name

    def __repr__(self):
        return '<Person %r>' % self.name


def create_db():
    path = os.getcwd()
    if DB_NAME in os.listdir(path):
        print "WARNING: Database already exists!"
    else:
        db.create_all()
        print "INFO: creating Database..."
[/codice]

e un file runner, che lancia il tutto:

[codice]# runner.py
import data


def run():
    data.create_db()


if __name__ == '__main__':
    run()

[/codice]

Se compilo il file runner con Pyinstaller:

[codice]python pyinstaller.py --onefile runner.py --name runner[/codice]

ottengo il binario senza nessun errore, ma all'atto pratico, quando lo eseguo,
il database non viene creato. Nessun errore.

Se invece di avere 2 file separati, ne ho uno unico...

[codice]# datatot.py

import os
from flask import Flask
from flask_sqlalchemy import SQLAlchemy

import flask_sqlalchemy._compat as _
import flask_script as fs

DB_NAME = 'test.db'

app = Flask(__name__)
db = SQLAlchemy(app)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///%s' % DB_NAME
app.config['SQLALCHEMY_ECHO'] = False


class Person(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(40), unique=True)

    def __init__(self, name):
        self.name = name

    def __repr__(self):
        return '<Person %r>' % self.name


def create_db():
    path = os.getcwd()
    if DB_NAME in os.listdir(path):
        print "WARNING: Database already exists!"
    else:
        db.create_all()
        print "INFO: creating Database..."

if __name__ == '__main__':
    create_db()
[/codice]

...non ho nessun problema.
Compilo, eseguo, tutto ok.

Pyinstaller aveva già problemi con gli import delle estensioni, percui non vorrei ci
fosse qualche magagna che non ho trovato sul web.
Oppure non vedo un errore grossolano.

Avete qualche idea o correzione?

EDIT:

se invece di utilizzare l'estensione flask_sqlalchemy, utilizzo direttamente sqlalchemy:
[codice]
#datasqla.py
import sqlalchemy
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String

engine = create_engine('sqlite:///testsqla.db', echo=True)
Base = declarative_base()

class User(Base):
    __tablename__ = 'users'
    id = Column(Integer, primary_key=True)
    name = Column(String)
    def __repr__(self):
       return "<User(name='%s')>" % self.name
[/codice]
e
[codice]
#runnersqla.py
from datasqla import Base, engine

Base.metadata.create_all(engine)
[/codice]

sembra quasi una sfiga tra pyinstaller e appunto flask_sqlalchemy (che ha già problemi nell'importazione delle extensions...

EDIT2:

senza l'opzione --onefile non ho problemi.
Ora è capire cosa succede in quell'ambito. bah.

5
Altre tematiche / [RISOLTO] Che stile di Docstring usare?
« il: Marzo 06, 2015, 09:28 »
Buongiorno a tutti.
Ho terminato un'applicazione e vorrei affinarla per condividerla con voi e magari, a tempo perso, ottenere preziosi consigli.
Prima però vorrei scrivere tutte le Docstring del caso.
Ho consultato la PEP257 ma non mi ha convinto, mentre ho notato ad esempio la google style guide (interpretabile da sphinx), che sembra essere molto più esaustiva.
Voi come documentate?

One line?
Multi line?

stile PEP
[codice]def complex(real=0.0, imag=0.0):
    """Form a complex number.

    Keyword arguments:
    real -- the real part (default 0.0)
    imag -- the imaginary part (default 0.0)
    """
    if imag == 0.0 and real == 0.0:
        return complex_zero[/codice]
?

stile google
[codice]"""
This is a groups style docs.

Parameters:
    param1 - this is the first param
    param2 - this is a second param

Returns:
    This is a description of what is returned

Raises:
    KeyError - raises an exception
"""[/codice]
?

Ciao

6
Buongiorno ragazzi!

Ho un *problema* legato a Flask o forse Sqlalchemy ed ammetto di
non essere fortissimo in materia.

Come vengono ordinati i risultati di una relazione many2many?

Mi aspetterei che gli oggetti legati ad un altro oggetto,
tramite relazione m2m, tornassero nello stesso ordine nel
quale sono stati inseriti, invece non succede.
Perchè?

posto un esempio, molto succinto:
[codice]
from flask import Flask
from flask.ext.sqlalchemy import SQLAlchemy


DB_NAME = 'test.db'

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///%s' % DB_NAME
app.config['SQLALCHEMY_ECHO'] = False
db = SQLAlchemy(app)

# M2M secondary tables
strings_chars = db.Table('strings_chars',
            db.Column('string_id', db.Integer, db.ForeignKey('string.id')),
            db.Column('char_id', db.Integer, db.ForeignKey('char.id')))


class String(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(5))
    chars = db.relationship('Char', secondary=strings_chars,
                            backref=db.backref('strings', lazy='dynamic'))
    def __init__(self, name):
        self.name = name

    def __repr__(self):
        return '<String %r>' % self.name


class Char(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    char = db.Column(db.String(1))

    def __init__(self, char):
        self.char = char

    def __repr__(self):
        return '<Character %r>' % self.char


if __name__ == '__main__':
    db.create_all()
    string = 'abcdef'
    for c in string:
        char = Char(c)
        db.session.add(char)
        db.session.commit()
    s = String(string)
    db.session.add(s)
    db.session.commit()
    chars = Char.query.all()
    s.chars = chars
    db.session.commit()
[/codice]


Se, appunto, controlliamo 'chars':

[codice]>>> for c in chars:
   print c.id, c

   
1 <Character u'a'>
2 <Character u'b'>
3 <Character u'c'>
4 <Character u'd'>
5 <Character u'e'>
6 <Character u'f'>[/codice]

invece se ottengo gli oggetti legati, all'oggetto string:

[codice]>>> for c in s.chars:
   print c.id, c

   
2 <Character u'b'>
6 <Character u'f'>
4 <Character u'd'>
1 <Character u'a'>
5 <Character u'e'>
3 <Character u'c'>[/codice]

Come mai questo fatto?
Tra l'altro sono *quasi* sicuro che questo prima non accadesse.
Non è che per caso adesso sono costretto, se voglio i dati in un certo ordine,
a chiamarli tramite filter_by ed order_by con db.session, invece che accedendo
all'attributo dell'oggetto??
Oppure, non è che l'accesso all'attributo stesso, con una relazione m2m alle spalle e
soprattutto con una secondary table, si comporta come un dizionario nel consegnarmi
la lista risultante?

Ciao


7
Buongiorno ragazzi.
Nella mia django-app ho una relazione manytomany tra due tabelle A e B.
Ho lasciato che la tabella intermedia tra le due, venisse creata in automatico da django.
Quando per un oggetto A accedo alla lista degli oggetti correlati di tipo B, ho un ordinamento nel queryset di default, che però non mi sta bene.
Vorrei che gli oggetti venissero ordinati in base al loro ID di inserimento e non alfabeticamente.

Devo pertanto accedere alla tabella intermedia.

C'è un modo furbo, o devo per forza creare l'oggetto tabella-intermedia nel models.py, per poter poi avere accesso ai campi direttamente?

Per maggior chiarezza, uno spaccato della app:

[codice]class Squadra(models.Model):
    ...

class Giocatore(models.Model):
    squadra = models.ForeignKey(Squadra, null=True, related_name='giocatori')
    ....

class Formazione (models.Model):
    squadra = models.ForeignKey(Squadra, related_name='formazioni')
    titolari = models.ManyToManyField(Giocatore, related_name='titolari')
    panchinari = models.ManyToManyField(Giocatore, related_name='panchinari')
    ...[/codice]

quando da shell carico i dati:

[codice]In [2]: s = Squadra.objects.get(nome__iexact='pippo')

In [3]: s
Out[3]: <Squadra: Pippo>

In [4]: f = s.formazioni.all()[2]

In [5]: f
Out[5]: <Formazione: Pippo gg: 3>

In [6]: f.panchinari.all()
Out[6]: [<Giocatore: 160  - STORARI [JUV]>, <Giocatore: 288  - GASTALDELLO [SAM]>, <Giocatore: 303  - JUAN JESUS [INT]>, <Giocatore: 390  - VRSAL
SAS]>, <Giocatore: 527  - BRIENZA [CES]>, <Giocatore: 542  - CHRISTODOULOPOULOS [VER]>, <Giocatore: 720  - MEDEL [INT]>, <Giocatore: 803  - AMAUR
R]>, <Giocatore: 827  - DJORDJEVIC [LAZ]>, <Giocatore: 872  - PALOSCHI [CHI]>]
[/codice]

il problema è che da Admin, come pure consultando la tabella intermedia ...formazione_panchinari, l'ordine di inserimento è un altro.
Ordine che deve tassativamente rimanere lo stesso.
Quindi il queryset di default non mi va bene.
Come posso ottenere un queryset che tenga conto dell'ordine di inserimento dei giocatori a db.

Grazie ciao.

8
Buongiorno,

Sto riportando una mia applicazione su Django, che ho ripreso a mano dopo un po' di tempo...

Ho tre classi:

Team
LineUp (formazione)
Player


Team è in relazione 1-m con Player
Team è in relazione 1-m con LineUp
LineUp è in relazione m2m con Player (perchè come ovvio, una formazione schiera più giocatori
e lo stesso giocatore apparirà durante l'anno, in più formazioni.

Il mio problema sta nel rappresentare questa cosa nell'Admin.


Mi spiego meglio ho creato i models in questo modo:

[codice]class Team(models.Model):
    name = models.CharField(max_length=50)
    trainer = models.CharField(max_length=50)
    budget = models.IntegerField()
    pts = models.FloatField()

    class Meta:
        verbose_name_plural = 'Squadre'

    def __unicode__(self):
        return '{} [{}]'.format(self.name, self.trainer)


class Player(models.Model):
    team = models.ForeignKey(Team, null=True, related_name='players')
    code = models.IntegerField()
    name = models.CharField(max_length=30)
    real_team = models.CharField(max_length=3)
    value = models.IntegerField()

    class Meta:
        verbose_name_plural = 'Giocatori'

    def __unicode__(self):
        return '%s  - %s [%s]' % (self.code, self.name, self.real_team)

class LineUp (models.Model):
    team = models.ForeignKey(Team, related_name='formazioni')
    regular_players = models.ManyToManyField(Player, related_name='titolari')
    substitutes = models.ManyToManyField(Player, related_name='panchinari')
    day = models.IntegerField()

    class Meta:
        verbose_name_plural = 'Formazioni'

    def __unicode__(self):
        return '%s day: %s' %(self.team.name, self.day)[/codice]


qui l'admin.py


[codice]class LineUpOption(admin.ModelAdmin):
    filter_horizontal = ['regular_players', 'substitutes']
...

admin.site.register(LineUp, LineUpOption)[/codice]

Se inserisco da shell i dati, quando devo popolare una formazione, mi ricavo i giocatori
da

<squadra>.players.all()

e poi popolo, quindi ho accesso alla rosa dei giocatori di quella singola squadra,
se voglio farlo da admin, giustamente con il filter_horizontal ho la scelta su tutto il bacino di giocatori
disponibili

[codice]regular_players = models.ManyToManyField(Player, related_name='titolari')[/codice]

e non dalla rosa disponibile per quella squadra.

Come posso filtrare i dati prima che essi vengano mostrati nel filter?
Ho provato nella classe LineUp di models.py, a creare un metodo che mi filtri i dati, ma le callable le
si visualizzano con list_display di admin e non con il filter, o almeno non ci sono riuscito.

Grazie per i preziosi suggerimenti. Ciao

9
Buongiorno!

Ho un programmino che prende in ingresso una distinta componenti, legge il codice in ogni riga e, accedendo ad un db MSAccess con pyodbc, estrae dati.
Il tutto funziona ma è eccessivamente lento, circa 1.3s a SELECT.

[codice]    def open_odbc_connection(self):
        ...
        ACCESS_DATABASE_FILE = 'k:/begapi/gestio32/DB/anagrafica.accdb'
        ODBC_CONN_STR = 'DRIVER={Microsoft Access Driver (*.mdb, *.accdb)};DBQ=%s;' % ACCESS_DATABASE_FILE
        self.datab = pyodbc.connect(ODBC_CONN_STR)
        self.cur = self.datab.cursor()
        ....
    def query_anag(self, codice):
        sql = "SELECT Anagrafica FROM Ana_Cod WHERE Codice=?"
        anag = self.cur.execute(sql, codice).fetchone()
        return anag[/codice]

estrarre dati su distinte di 50 righe è abbastanza noioso.
Se dal db estraggo tutti i dati in una lista e poi itero sulla stessa i tempi si abbattono, ma questo comincia a perdere senso nel momento in cui il db dal quale attingo i dati, diventa di dimensioni notevoli.

Domanda:
esiste qualche modo per velocizzare la questione?

P.S. Inizialmente utilizzavo il DSN per accedere al db, ma avevo dei problemi su un'altra macchina con SEVEN 64bit...

ciao

10
ForumPython.it cafè / Stasera ore 18
« il: Giugno 24, 2014, 10:27 »
Allora?
Tutti sulla tastiera fino a notte fonda, o qualcuno si svagherà un po' seguendo la Nazionale?

Ce la faremo contro il pistolero o i nostri ca**oni viziatelli verranno sbattuti a casa senza passare il girone, come 4 anni fa?

11
Tkinter / [RISOLTO] KDE: Combobox visualizzazione alterata
« il: Marzo 18, 2014, 11:36 »
Buongiorno,
mi servirebbe una cortesia da un qualche possessore di KDE.
Vorrei una conferma sull'errata visualizzazione di una lista di oggetti in una combobox su ambiente KDE.
Per l'esattezza il codice che posto di seguito, funziona alla perfezione su GNOME, sul meraviglioso mondo di XP, ma non sul mio Kubuntu casalingo.
In pratica passando alla combobox una lista di oggetti (ho simulato una query di Flask), con il proprio metodo __repr__, ottengo una visualizzazione splittata su più linee...
Se passo una lista di stringhe, invece tutto ok.
Se qualche cavia mi confermasse la cosa, mi farebbe una cortesia.

Ciao:

codice:

[codice]import Tkinter as tk
import ttk


CENTER = tk.N + tk.S + tk.E + tk.W


class A(object):

    def __init__(self, num):
        self.num = num

    def __repr__(self):
        return '<object %r>' % (self.num)


class Model(object):

    def __init__(self):
        self.values = []

    def get_objects(self):
        self.values = [A(n) for n in range(3)]
        return self.values


class View(object):
    def __init__(self):
        self.root = tk.Tk()
        self.root.title('test')
        self.cvar = tk.StringVar()

    def build_gui(self):
        self.frame = tk.Frame(master=self.root)
        self.frame.pack(fill=tk.BOTH, expand=1)
        self.cb = ttk.Combobox(self.frame, height=3, textvariable=self.cvar)
        self.cb.grid(sticky=CENTER, row=0, column=1)

    def show(self):
        self.root.mainloop()


class Controller(object):
    def __init__(self):
        self.gui = View()
        self.model = Model()
        self.values = self.model.get_objects()
        self.v = None

    def bind_widgets(self):
        self.gui.build_gui()
        self.gui.cb.bind("<<ComboboxSelected>>", self.on_combo)
        self.gui.cb.configure(values=self.values)

    def on_combo(self, event):
        obj = self.gui.cb.get()
        self.v = self.gui.cvar.get()

    def get_obj(self):
        for o in self.values:
            if o.__str__() == self.v:
                return o

    def start(self):
        self.gui.show()


if __name__ == '__main__':
    c = Controller()
    c.bind_widgets()
    c.start()
    obj = c.get_obj()
    print c.v, obj, isinstance(obj, A)
[/codice]

12
Ciao a tutti.
Ho un dubbio su come gestire le informazioni che prelevo dal database.

Mi spiego meglio.

Ho una gui con una combobox, un model che gestisce il database tramite Flask
e il solito controller.

In sostanza: interrogo il database ed ottengo una lista di oggetti con il comando

[codice]BlaBla.query.all()[/codice]

la lista la passo al widget che ne visualizza il contenuto (in base al __repr__ che definisco
nella classe di riferimento).

Se scelgo dalla combobox uno degli oggetti che compongono la lista, ottengo una stringa ovviamente,
non l'oggetto stesso.

Se volessi avere tra le mani l'oggetto rappresentato dalla stringa, per poterne
gestire gli attributi, dovrei fare un'altra query con filtro la stringa stessa, ma mi dà l'idea di essere un'operazione doppia.

E' sbagliato questo approccio vero?
Mi converrebbe forse creare una sorta di dizionario con la prima query,
in modo da avere una chiave stringa (che rappresento nella combobox) e un valore oggetto da
recuperare in seguito?

Qual'è il modo corretto di operare in questo caso, voi come fate?

Tra l'altro ho notato che a casa, dove utilizzo kubuntu, passando la lista di oggetti
alla combobox, la visualizzazione degli stessi, viene alterata (cosa che non avviene con Gnome,
nè con XP). Qui aprirò una discussione a parte...

Ciao

13
Tkinter / [RISOLTO] problema Combobox
« il: Marzo 12, 2014, 18:24 »
Ciao a tutti.
Cerco di riassumere al massimo.
Ho una applicazione che da un mainframe, apre tanti subframes.
Se utilizzo i combobox all'interno dei subframes, alla chiusura degli stessi ottengo questa eccezione:

[codice]can't invoke "winfo" command:  application has been destroyed

    while executing

"winfo exists $w"

    (procedure "ttk::entry::AutoScroll" line 3)

    invoked from within

"ttk::entry::AutoScroll .12645800.12646280"

    (in namespace inscope "::" script line 1)

    invoked from within

"::namespace inscope :: {ttk::entry::AutoScroll .12645800.12646280}"

    ("uplevel" body line 1)

    invoked from within

"uplevel #0 $Repeat(script)"

    (procedure "ttk::Repeat" line 3)

    invoked from within

"ttk::Repeat"

    ("after" script)[/codice]

In realtà, se eseguo il programma da IDLE, non vedo nessun errore.
Il codice ridotto all'osso, è il seguente:

[codice]import Tkinter as tk
import ttk


CENTER = tk.N + tk.S + tk.E + tk.W


class MainFrame:
    def __init__(self):
        self.root = tk.Tk()
        self.root.title('Main')
        self.frame = tk.Frame(master=self.root)
        self.frame.pack(fill=tk.BOTH, expand=1)
        self.btn_on = tk.Button(master=self.frame, text='Subframe')
        self.btn_on.grid(sticky=CENTER, row=0, column=0, columnspan=2)
        ttk.Separator(self.frame, orient=tk.HORIZONTAL).grid(
            sticky=CENTER, row=1, padx=10, pady=10)
        tk.Button(master=self.frame, text='Chiudi', command=self.root.destroy
            ).grid(sticky=CENTER, row=2, column=0, columnspan=2)


class Child:
    def __init__(self, parent):
        self.parent = parent
        self.parent.title('Child')
        self.frame = tk.Frame(master=self.parent)
        self.frame.pack(fill=tk.BOTH, expand=1)
        ttk.Separator(self.frame, orient=tk.HORIZONTAL).grid(
            sticky=CENTER, row=0, padx=10, pady=10)
        self.cb = ttk.Combobox(master=self.frame, height=3)
        self.cb.grid(sticky=CENTER, row=1, column=1)
        tk.Button(master=self.frame, text='Chiudi', command=self.parent.destroy
            ).grid(sticky=CENTER, row=2, column=0, columnspan=2)


class Controller:
    def __init__(self):
        self.mf = MainFrame()
        self.bind_w()
        self.mf.root.mainloop()

    def bind_w(self):
        self.mf.btn_on.configure(command=self.on_btn_on)

    def on_btn_on(self):
        self.child = Child(tk.Tk())
        self.child.cb.configure(values=['a', 'b', 'c'])

if __name__ == '__main__':
    Controller()
[/codice]

Ho trovato "forse" una soluzione qui:
ma non riesco a farla funzionare.
Sapete darmi una dritta?
Ciao

EDIT: ho tentato in tutti i modi di mettere un titolo di discussione più esaustivo, ma ricevo un Hacking Attempt... chevvordì?

14
ForumPython.it cafè / E-Learning: Coursera/Pop pareri
« il: Gennaio 10, 2014, 12:34 »
Che ne pensate dell'e-learning?
Mondi come le piattaforme in oggetto, sono valide o sono una perdita di tempo?
Lasciamo stare che gli attestati rilasciati agli esami non contino quali crediti Universitari,
ma può valere la pena perdere tempo sui corsi proposti?
Ad esempio:
https://www.coursera.org/courses?orderby=upcoming&search=python

saluti

15
Buongiorno ragazzi,
sto creando la gui di un programmino che mi serve in ufficio...
Ho una Entry e dovrei catturare il testo, mentre lo scrivo, cioè, raggiunti 9 caratteri, controllo che il codice sia presente in un database.
Facendo il bind con il <KeyPress>, però, rimango sempre indietro di un carattere percui devo fare un certo "maccheggio" per ottenere il testo che mi serve.
Soprattutto dovrei tenere conto di tutti i tasti che non voglio siano controllati.

Posto il codice molto scremato, che faccio prima.

[codice]import Tkinter as tk
import ttk

BADCHARS = ('Insert', 'Delete', 'Next', 'Prior') # piu' gli altri sgraditi
CENTER = tk.N + tk.S + tk.W + tk.E


class ViewTH:
    def __init__(self):
        self.root = tk.Tk()
        self.frame = tk.Frame(self.root)
        self.frame.pack(fill=tk.BOTH)
        self.en_cod = tk.Entry(self.frame)
        self.en_cod.grid(sticky=CENTER, row=0, column=0, padx=2, pady=2)
        btn_quit = tk.Button(self.frame, text='Quit',
                      command=self.root.destroy)
        btn_quit.grid(sticky=CENTER, row=1, column=0, padx=2, pady=2)
        self.en_cod.bind('<KeyPress>', func=self.on_entry)

    def on_entry(self, event):
        text = self.en_cod.get()
        if not text:
            cod = event.keysym
        else:
            if event.keysym == 'BackSpace':
                cod = self.en_cod.get()[:-1]
            elif event.keysym in BADCHARS:
                cod = self.en_cod.get() + ''
            else:
                cod = self.en_cod.get() + event.keysym
        print cod  # debug

    def start(self):
        self.root.mainloop()


if __name__ == '__main__':
    vth = ViewTH()
    vth.start()
[/codice]

In pratica utilizzo event.keysym per recuperare il tasto premuto ed il carattere corrispondente.
Ovviamente con un pulsante che catturi il testo con il metodo get() di Entry, avrei risolto, ma mi
piace di più il controllo mentre scrivo....
mi è sfuggito, o non esiste un metodo che faccia quello che faccio dentro la callback con event?

Ciao.

Pagine: [1] 2 3