Python Dependency Injection-Framework

Question

Sie haben einen Rahmen entspricht Guice ( http://code.google.com/p/ google-guice ) für Python?

Answer 1

Ich habe es nicht verwendet, aber die Frühling Python Framework basiert auf Frühling und Geräte Inversion of Control .

Es scheint auch ein Guice in Python-Projekt zu sein: schlangen guice

Answer 2

Frühling Python ist ein Ableger des Java-basierten Spring Framework und Spring Security, für Python abgezielt. Dieses Projekt umfasst derzeit die folgenden Funktionen:

• Inversion of Control (Dependency Injection) - entweder klassisch XML oder der Python @Object Dekorateur (ähnlich dem Frühling JavaConfig Teilprojekt) auf Draht Dinge zusammen. Während das @Object Format nicht identisch mit dem Stil Guice ist (zentrale Verdrahtung vs. Verdrahtungsinformationen in jeder Klasse), ist es eine wertvolle Möglichkeit, Ihren Python App verdrahten.
• Aspektorientierte Programmierung - gilt Abfangjäger in einem horizontalen Programmierparadigma (anstelle von vertikalem OOP Vererbung) für Dinge wie Transaktionen, Sicherheit und Caching.
• DatabaseTemplate - aus der Datenbank auszulesen, muss einen monotonen Zyklus Cursor zum Öffnen, Lese Reihen und Cursor zu schließen, zusammen mit Exception-Handler. Mit dieser Template-Klasse, alles, was Sie brauchen, ist die SQL-Abfrage und Zeilen Handling-Funktion. Frühling Python erledigt den Rest.
• Datenbank-Transaktionen - mehrere Datenbank-Wrapping Anrufe mit Transaktionen können Sie den Code schwer zu lesen machen. Dieses Modul bietet mehr Möglichkeiten, um Transaktionen zu definieren, ohne die Dinge kompliziert zu machen.
• Sicherheit -. Plugin Sicherheit Abfangjäger sperren Zugriff auf Ihre Methoden, sowohl die Authentifizierung und Domain-Autorisierung verwendet
• Remoting - Es ist leicht, Ihre lokale Anwendung in einer verteilten umzuwandeln. Wenn Sie bereits Ihre Client- und Server-Stücke mit den IoC-Containern aufgebaut haben, dann von den lokalen zum verteilten gehen ist nur eine Konfigurationsänderung.
• Proben - auf verschiedene Funktionen von Spring Python helfen zu demonstrieren, haben einige Beispielanwendungen erstellt wurde:
  • PetClinic - Spring Framework der Probe Web-App wurde aus dem Boden wieder aufgebaut up mit Python Webcontainern einschließlich: CherryPy . Go check it out, ein Beispiel dafür, wie dies Framework zu nutzen. . (Hinweis: anderes Python Web-Frameworks wird in Zukunft zu dieser Liste hinzugefügt werden)
  • Frühling Wiki - Wikis sind leistungsstarke Möglichkeiten, Inhalte zu speichern und zu verwalten, so haben wir eine einfache als Demo
  !
  • Frühling Bot - Verwenden Sie Python Frühling einen kleinen Bot zu bauen, den IRC-Kanal Ihres Open-Source-Projekt zu verwalten
  .

Answer 3

Ich mag diese einfache und saubere Rahmen.

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

  

Dependency Injection als formales Muster ist weniger nützlich in Python als   in anderen Sprachen, vor allem wegen ihrer Unterstützung für Keyword   Argumente, mit denen die Leichtigkeit Objekte können spotten, und seine dynamische   Natur.

     

sagte, dass ein Rahmen für die in diesem Prozess unterstützen kann viel entfernen   Kessel-Platte aus größeren Anwendungen. Das ist, wo Injektor   Hilfe. Es automatisch und transitively bietet Schlüsselwort-Argumente   mit ihren Werten. Als zusätzlichen Vorteil, Injector ermutigt schön   compartmentalized Code durch die Verwendung des Moduls s.

     

Während von Guice inspiriert, ist es nicht sklavisch replizieren seine   API. eine Pythonic API Bereitstellung Trümpfe Treue.

Answer 4

Als Alternative zu monkeypatching, ich mag DI. Eine im Entstehen begriffene Projekt wie http://code.google.com/p/snake-guice/ kann die Rechnung passen.

oder den Blog-Eintrag finden Sie unter Dependency Injection in Python von Dennis Kempin (Aug '08).

Answer 5

pinject ( https://github.com/google/pinject ) ist eine neuere Alternative. Es scheint, von Google und folgt einem ähnlichen Muster zu Guice ( https://code.google.com/p/ beibehalten werden google-guice / ), es ist Java-Pendant.

Answer 6

Außerdem:

1. Zope Komponente architekture
2. pyContainer

Answer 7

Es ist ein etwas Guicey python-injizieren Projekt. Es ist ziemlich aktiv, und viel weniger Code dann Frühlings-Python, aber dann wieder, ich habe keinen Grund zu verwenden, es noch nicht.

gefunden

Answer 8

Wenn Sie nur Dependency Injection in Python tun wollen, brauchen Sie nicht, einen Rahmen. Hier finden Sie aktuelle Dependency Injection der Python Way . Es ist wirklich schnell und einfach, und nur c. 50 Zeilen Code.

Answer 9

Wird mein 5 Cent lassen sich hier:)

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'}

AKTUALISIERT

Einige Zeit verging und Dependency Injector ist jetzt ein bisschen anders. Es ist besser, von Dependency Injector GitHub Seite zu starten für aktuelle Beispiele bekommen - https: // GitHub. com / ets-labs / python-Abhängigkeit-Injektor

Answer 10

Hier ist ein kleines Beispiel für eine Dependency Injection Container, die Injektion tut Konstruktor basierend auf dem Konstruktor Argument-Namen:

http://code.activestate.com/recipes/576609 -Nicht-invasive Abhängigkeit-Injektion /

Answer 11

Ich habe eine lib, dies zu tun https://github.com/ettoreleandrotognoli/python-cdi Ich hoffe, das hilft

Es ist auf pypi: https://pypi.python.org/pypi/pycdi

Mit ihm können Sie Injektionen mit python2 machen

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)

Und Typ mit einem Hauch von 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

Simpler als ein Rahmen ist der @autowired Dekorateur .

Dieses Dekorateur bietet saubere Dependency Injection und faul Initialisierung Unterstützung.

Es stellt sich Code wie folgt:

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 diesen:

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

Es ist kein Rahmen, so dass Sie es Null-Setup und erzwungen Workflows, obwohl es keine Injektion Kontext Manipulation liefern.

Disclosure: Ich bin der Projektmaintainer

.

Answer 13

Wenn Sie eine wirklich kleine Lösung bevorzugen gibt es eine kleine Funktion, es ist nur eine Abhängigkeit Setter.

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

Answer 14

Es gibt dyject ( http://dyject.com ), einem leichten Rahmen für beide Python 2 und Python 3, die verwendet die eingebaute in ConfigParser

Answer 15

Wenn Sie ein guice wie (die neuen neuen, wie sie sagen), ich etwas in der Nähe in Python vor kurzem 3, die am besten meine einfachen Bedürfnisse für ein Nebenprojekt geeignet.

Alles, was Sie brauchen, ist ein @inject auf eine Methode (__init__ natürlich eingeschlossen). Der Rest wird durch Anmerkungen gemacht.

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

Ich gab vor kurzem eine saubere (IMHO) Mikro-Bibliothek für DI in Python:

https://github.com/suned/serum

Answer 17

Enterprython ist ein kleiner Rahmen geschaffen Abhängigkeitsinjektion, den Aufbau der Objektgraph automatisch basierend auf geben Hinweise .