Python Dependency Injection Framework

Question

Esiste un framework equivalente a Guice ( http://code.google.com/p/ google-guice ) per Python?

Answer 1

Non l'ho usato, ma il Spring Python si basa su Spring e implementa Inversion of Control .

Sembra anche che ci sia un progetto Guice in Python: snake-guice

Answer 2

Spring Python è una derivazione di Spring Framework basata su Java e Spring Security, destinata a Python. Questo progetto contiene attualmente le seguenti funzionalità:

• Inversion Of Control (Iniezione delle dipendenze) - usa l'XML classico o il python @Object decoratore (simile al sottoprogetto Spring JavaConfig) per collegare le cose insieme. Sebbene il formato @Object non sia identico allo stile Guice (cablaggio centralizzato e informazioni sul cablaggio in ogni classe), è un modo prezioso per cablare la tua app Python.
• Programmazione orientata agli aspetti - applicare gli intercettori in un paradigma di programmazione orizzontale (anziché verticale Eredità OOP) per cose come transazioni, sicurezza e memorizzazione nella cache.
• DatabaseTemplate: la lettura dal database richiede un ciclo monotono di apertura di cursori, lettura di righe e chiusura di cursori, insieme a gestori di eccezioni. Con questa classe di modelli, tutto ciò che serve è la query SQL e la funzione di gestione delle righe. Spring Python fa il resto.
• Transazioni di database: il wrapping di più chiamate di database con transazioni può rendere difficile la lettura del codice. Questo modulo offre diversi modi per definire le transazioni senza complicare le cose.
• Sicurezza: plug-in intercettori di sicurezza per bloccare l'accesso ai metodi, utilizzando sia l'autenticazione che l'autorizzazione del dominio.
• Remoting: è facile convertire l'applicazione locale in una distribuita. Se hai già creato i tuoi pezzi client e server utilizzando il contenitore IoC, passare da locale a distribuito è solo una modifica della configurazione.
• Esempi: per aiutare a dimostrare varie funzionalità di Spring Python, sono state create alcune applicazioni di esempio:
  • PetClinic - L'app Web di esempio di Spring Framework è stata ricostruita da zero utilizzando contenitori Web Python tra cui: CherryPy . Vai a dare un'occhiata per un esempio di come utilizzare questo framework. (NOTA: altri framework Web Python verranno aggiunti a questo elenco in futuro).
  • Spring Wiki - I wiki sono modi potenti per archiviare e gestire i contenuti, quindi ne abbiamo creato uno semplice come demo!
  • Spring Bot: usa Spring Python per creare un piccolo bot per gestire il canale IRC del tuo progetto open source.

Answer 3

Mi piace questo framework semplice e pulito.

http://pypi.python.org/pypi/injector/

  

L'iniezione di dipendenza come modello formale è meno utile in Python di   in altre lingue, principalmente grazie al suo supporto per le parole chiave   argomenti, la facilità con cui gli oggetti possono essere derisi e la sua dinamica   la natura.

     

Detto questo, un framework per aiutare in questo processo può rimuovere molto   della piastra della caldaia da applicazioni più grandi. Ecco dove può Injector   Aiuto. Fornisce automaticamente e transitivamente argomenti per parole chiave   con i loro valori. Come ulteriore vantaggio, Injector incoraggia piacevolmente   codice compartimentato attraverso l'uso del Modulo s.

     

Pur essendo ispirato a Guice, non lo replica in modo slavato   API. Fornire un'API Pythonic supera la fedeltà.

Answer 4

In alternativa al monkeypatching, mi piace DI. Un progetto nascente come http://code.google.com/p/snake-guice/ può andare bene il conto.

Oppure vedi il post sul blog Dependency Injection in Python di Dennis Kempin (agosto '08).

Answer 5

pinject ( https://github.com/google/pinject ) è un'alternativa più recente. Sembra essere gestito da Google e segue un modello simile a Guice ( https://code.google.com/p/ google-guice / ), è la controparte Java.

Answer 6

Oltre a ciò:

1. Architekture del componente Zope
2. pyContainer

Answer 7

Esiste un progetto in qualche modo Guicey python-inject . È abbastanza attivo e MOLTO meno codice di Spring-Python, ma non ho ancora trovato un motivo per usarlo.

Answer 8

Se vuoi solo fare l'iniezione di dipendenza in Python, non hai bisogno di un framework. Dai un'occhiata a Iniezione delle dipendenze in Python Way . È davvero semplice e veloce, e solo c. 50 righe di codice.

Answer 9

Lascerò qui i miei 5 centesimi :)

https://pypi.python.org/pypi/dependency_injector

"""Pythonic way for Dependency Injection."""

from dependency_injector import providers
from dependency_injector import injections


@providers.DelegatedCallable
def get_user_info(user_id):
    """Return user info."""
    raise NotImplementedError()


@providers.Factory
@injections.inject(get_user_info=get_user_info)
class AuthComponent(object):
    """Some authentication component."""

    def __init__(self, get_user_info):
        """Initializer."""
        self.get_user_info = get_user_info

    def authenticate_user(self, token):
        """Authenticate user by token."""
        user_info = self.get_user_info(user_id=token + '1')
        return user_info


print AuthComponent
print get_user_info


@providers.override(get_user_info)
@providers.DelegatedCallable
def get_user_info(user_id):
    """Return user info."""
    return {'user_id': user_id}


print AuthComponent().authenticate_user(token='abc')
# {'user_id': 'abc1'}

AGGIORNATO

È passato un po 'di tempo e ora Dependency Injector è un po' diverso. È meglio iniziare dalla pagina GitHub dell'iniettore di dipendenza per ottenere esempi concreti - https: // github. com / ETS-laboratori / python-dipendenza-iniettore

Answer 10

Ecco un piccolo esempio per un contenitore di iniezione di dipendenza che esegue l'iniezione del costruttore in base ai nomi degli argomenti del costruttore:

http://code.activestate.com/recipes/576609 -non-invasiva-dipendenza-iniezione /

Answer 11

Ho fatto una lib per farlo https://github.com/ettoreleandrotognoli/python-cdi Spero che ciò aiuti

È disponibile su pypi: https://pypi.python.org/pypi/pycdi

Con esso puoi fare iniezioni con python2

import logging
from logging import Logger

from pycdi import Inject, Singleton, Producer
from pycdi.shortcuts import call


@Producer(str, _context='app_name')
def get_app_name():
    return 'PyCDI'


@Singleton(produce_type=Logger)
@Inject(app_name=str, _context='app_name')
def get_logger(app_name):
    return logging.getLogger(app_name)


@Inject(name=(str, 'app_name'), logger=Logger)
def main(name, logger):
    logger.info('I\'m starting...')
    print('Hello World!!!\nI\'m a example of %s' % name)
    logger.debug('I\'m finishing...')


call(main)

E usando i suggerimenti sul tipo di python3

import logging
from logging import Logger

from pycdi import Inject, Singleton, Producer
from pycdi.shortcuts import call


@Producer(_context='app_name')
def get_app_name() -> str:
    return 'PyCDI'


@Singleton()
@Inject(logger_name='app_name')
def get_logger(logger_name: str) -> Logger:
    return logging.getLogger(logger_name)


@Inject(name='app_name')
def main(name: str, logger: Logger):
    logger.info('I\'m starting...')
    print('Hello World!!!\nI\'m a example of %s' % name)
    logger.debug('I\'m finishing...')


call(main)

Answer 12

Più semplice di un framework è il @autowired decorator .

Questo decoratore fornisce un'iniezione di dipendenza pulita e supporto per l'inizializzazione lenta.

Trasforma il codice in questo modo:

def __init__(self, *, model: Model = None, service: Service = None):
    if model is None:
        model = Model()

    if service is None:
        service = Service()

    self.model = model
    self.service = service
    # actual code

in questo:

@autowired
def __init__(self, *, model: Model, service: Service):
    self.model = model
    self.service = service
    # actual code

Non è un framework, quindi non ci sono impostazioni e flussi di lavoro forzati, sebbene non fornisca manipolazione dei contesti di iniezione.

Divulgazione: sono il responsabile del progetto.

Answer 13

Se preferisci una soluzione davvero minuscola c'è una piccola funzione, è solo un setter di dipendenze.

https://github.com/liuggio/Ultra-Lightweight-Dependency- iniettore-Python

Answer 14

C'è dyject ( http://dyject.com ), un framework leggero per Python 2 e Python 3 che utilizza ConfigParser integrato

Answer 15

Se vuoi una battuta simile (le nuove novità come si suol dire), di recente ho fatto qualcosa di simile in Python 3 che si adattava meglio alle mie semplici esigenze per un progetto secondario.

Tutto ciò che serve è un @inject su un metodo (__init__ incluso ovviamente). Il resto viene fatto tramite annotazioni.

from py3njection import inject
from some_package import ClassToInject

class Demo:
    @inject
    def __init__(self, object_to_use: ClassToInject):
        self.dependency = object_to_use

demo = Demo()

https://pypi.python.org/pypi/py3njection

Answer 16

Di recente ho rilasciato una micro libreria pulita (IMHO) per DI in Python:

https://github.com/suned/serum

Answer 17

Enterprython è un piccolo framework che fornisce l'iniezione di dipendenza, costruendo automaticamente il grafico degli oggetti in base a suggerimenti sul tipo .