Comment puis-je prolonger un module python? L'ajout de nouvelles fonctionnalités à la " python-twitter paquet

Un peu de moyens.

La voie de la facilité:

Ne pas prolonger le module, d'étendre les classes.

exttwitter.py

import twitter

class Api(twitter.Api):
    pass 
    # override/add any functions here.

Inconvénient : Chaque classe de twitter doit être en exttwitter.py même si c'est juste un talon (comme ci-dessus)

Plus difficile (et éventuellement de l'onu-pythonic):

Importation * à partir de python-twitter dans un module, puis l'étendre.

Par exemple :

basemodule.py

 class Ball():
    def __init__(self,a):
        self.a=a
    def __repr__(self):
        return "Ball(%s)" % self.a

def makeBall(a):
    return Ball(a)

def override():
    print "OVERRIDE ONE"

def dontoverride():
    print "THIS WILL BE PRESERVED"

extmodule.py

from basemodule import *
import basemodule

def makeBalls(a,b):
    foo = makeBall(a)
    bar = makeBall(b)
    print foo,bar

def override():
    print "OVERRIDE TWO"

def dontoverride():
    basemodule.dontoverride()
    print "THIS WAS PRESERVED"

runscript.py

import extmodule

#code is in extended module
print extmodule.makeBalls(1,2)
#returns Ball(1) Ball(2)

#code is in base module
print extmodule.makeBall(1)
#returns Ball(1)

#function from extended module overwrites base module
extmodule.override()
#returns OVERRIDE TWO

#function from extended module calls base module first
extmodule.dontoverride()
#returns THIS WILL BE PRESERVED\nTHIS WAS PRESERVED

Je ne sais pas si le double de l'importation dans extmodule.py est pythonic - vous pourrait-il retirer, mais alors vous n'avez pas à traiter le cas d'utilisation de vouloir prolonger une fonction qui a été dans l'espace de noms de basemodule.

Aussi loin que l'étendue des classes, il suffit de créer une nouvelle API(basemodule.API) classe d'étendre l'API Twitter module.

OriginalL'auteur Rizwan Kassim

Voici comment vous pouvez manipuler directement le module de liste au moment de l'exécution – spoiler alert: vous obtenez le type de module de types module:

from __future__ import print_function
import sys
import types
import typing as tx

def modulize(namespace: tx.Dict[str, tx.Any],
             modulename: str,
             moduledocs: tx.Optional[str] = None) -> types.ModuleType:

    """ Convert a dictionary mapping into a legit Python module """

    # Create a new module with a trivially namespaced name:
    namespacedname: str = f'__dynamic_modules__.{modulename}'
    module = types.ModuleType(namespacedname, moduledocs)
    module.__dict__.update(namespace)

    # Inspect the new module:
    name: str = module.__name__
    doc: tx.Optional[str] = module.__doc__
    contents: str = ", ".join(sorted(module.__dict__.keys()))
    print(f"Module name:      {name}")
    print(f"Module contents:  {contents}")
    if doc:
        print(f"Module docstring: {doc}")

    # Add to sys.modules, as per import machinery:
    sys.modules.update({ modulename : module })

    # Return the new module instance:
    return module

... vous pouvez ensuite utiliser cette fonction comme suit:

ns = {
         'func' : lambda: print("Yo Dogg"), # these can also be normal non-lambda funcs
    'otherfunc' : lambda string=None: print(string or 'no dogg.'),
      '__all__' : ('func', 'otherfunc'),
      '__dir__' : lambda: ['func', 'otherfunc'] # usually this’d reference __all__
}

modulize(ns, 'wat', "WHAT THE HELL PEOPLE")
import wat

# Call module functions:
wat.func()
wat.otherfunc("Oh, Dogg!")

# Inspect module:
contents = ", ".join(sorted(wat.__dict__.keys()))
print(f"Imported module name:      {wat.__name__}")
print(f"Imported module contents:  {contents}")
print(f"Imported module docstring: {wat.__doc__}")

... Vous pouvez également créer votre propre module de sous-classe, en précisant types.ModuleType comme l'ancêtre de votre nouvellement déclarée class, bien sûr; je n'ai jamais personnellement trouvé ce nécessaire de le faire.

(Aussi, vous n'avez pas ont pour obtenir le type de module à partir de la types module, vous pouvez toujours faire quelque chose comme ModuleType = type(os) après l'importation os – j'ai souligné cette source unique du type parce qu'il n'est pas évidente; à la différence de beaucoup de ses autres builtin types de Python n'offre pas l'accès au type de module dans l'espace de noms global.)

L'action réelle est dans la sys.modules dict, où (si vous avez la bonne intrepid) vous pouvez remplacer les modules existants ainsi que l'ajout de vos nouvelles.

OriginalL'auteur fish2000

Je suggère de ne pas réinventer la Roue? Je suis en train de construire une >6k ligne Client Twitter pour 2 mois maintenant, j'ai d'abord vérifié python-twitter aussi, mais c'est à la traîne beaucoup derrière les récents changements de l'API, de l', le Développement ne semble pas aussi actif, aussi il y a(au moins la dernière fois que j'ai vérifié) pas de support pour le protocole OAuth/xAuth).

Donc après une recherche un peu plus, j'ai découvert tweepy:

http://github.com/joshthecoder/tweepy

Pour: le développement Actif, OAauth/xAuth et jusqu'à ce jour avec l'API.

Les Chances sont élevées que ce que vous avez besoin est déjà là.

Donc je suggère d'aller avec qui, il est travaillé pour moi, la seule chose que j'ai dû ajouter a xAuth(qui a obtenu de fusion de retour à tweepy 🙂

Oh un un plug sans vergogne, si vous avez besoin d'analyser les Tweets et/ou leur format HTML utiliser ma version de python de la twitter-texte-* bibliothèques:

http://github.com/BonsaiDen/twitter-text-python

Cette chose est unittestetd une garantie pour analyser les Tweets comme Twitter.com n'.

OriginalL'auteur Ivo Wetzel