Fichier de propriétés en python (similaire aux propriétés Java)

Un fichier de propriétés java est souvent un code Python valide. Vous pouvez renommer votre maconfig.fichier de propriétés à myconfig.py. ensuite, il suffit d'importer votre fichier, comme ceci

import myconfig

Et accéder directement aux propriétés

print myconfig.propertyName1

J'ai pu faire fonctionner cela avec ConfigParser, personne n'a montré d'exemples sur la façon de le faire, alors voici un simple lecteur python d'un fichier de propriété et un exemple du fichier de propriété. Notez que l'extension est toujours .properties, mais j'ai dû ajouter un en-tête de section similaire à ce que vous voyez dans .les fichiers ini... un peu de bâtardisation, mais ça marche.

Le fichier python: PythonPropertyReader.py

#!/usr/bin/python    
import ConfigParser
config = ConfigParser.RawConfigParser()
config.read('ConfigFile.properties')

print config.get('DatabaseSection', 'database.dbname');

Le fichier de propriétés: ConfigFile.properties

[DatabaseSection]
database.dbname=unitTest
database.user=root
database.password=

Pour plus de fonctionnalités, lire: https://docs.python.org/2/library/configparser.html

Je sais que c'est une très vieille question, mais j'en ai besoin tout à l'heure et j'ai décidé d'implémenter ma propre solution, une solution Python pure, qui couvre la plupart des cas d'utilisation (pas tous):

def load_properties(filepath, sep='=', comment_char='#'):
    """
    Read the file passed as parameter as a properties file.
    """
    props = {}
    with open(filepath, "rt") as f:
        for line in f:
            l = line.strip()
            if l and not l.startswith(comment_char):
                key_value = l.split(sep)
                key = key_value[0].strip()
                value = sep.join(key_value[1:]).strip().strip('"') 
                props[key] = value 
    return props

Vous pouvez changer le sep en': 'pour analyser les fichiers avec le format:

key : value

Le code analyse correctement les lignes comme:

url = "http://my-host.com"
name = Paul = Pablo
# This comment line will be ignored

, Vous obtiendrez un dict avec:

{"url": "http://my-host.com", "name": "Paul = Pablo" }

Si vous avez une option de formats de fichiers, je suggère d'utiliser .ini et ConfigParser de Python comme mentionné. Si vous avez besoin de compatibilité avec Java .fichiers de propriétés j'ai écrit une bibliothèque pour cela appelée jprops . Nous utilisions pyjavaproperties, mais après avoir rencontré diverses limitations, j'ai fini par implémenter la mienne. Il a un soutien total pour la .format des propriétés, y compris le support unicode et un meilleur support pour les séquences d'échappement. Jprops peut également analyser n'importe quel objet de type fichier pyjavaproperties ne fonctionne qu'avec des fichiers réels sur le disque.

Ce ne sont pas exactement des propriétés mais Python a une belle bibliothèque pour analyser les fichiers de configuration. Voir Aussi cette recette: un remplacement Python pour java.util.Propriétés .

Voici un lien vers mon projet: https://sourceforge.net/projects/pyproperties/. c'est une bibliothèque avec des méthodes pour travailler avec *.fichiers de propriétés pour Python 3.X.

, Mais il n'est pas basé sur java.util.Propriétés

Ce est un un-à-un remplacement de java.util.Propriétés

De la doc:

  def __parse(self, lines):
        """ Parse a list of lines and create
        an internal property dictionary """

        # Every line in the file must consist of either a comment
        # or a key-value pair. A key-value pair is a line consisting
        # of a key which is a combination of non-white space characters
        # The separator character between key-value pairs is a '=',
        # ':' or a whitespace character not including the newline.
        # If the '=' or ':' characters are found, in the line, even
        # keys containing whitespace chars are allowed.

        # A line with only a key according to the rules above is also
        # fine. In such case, the value is considered as the empty string.
        # In order to include characters '=' or ':' in a key or value,
        # they have to be properly escaped using the backslash character.

        # Some examples of valid key-value pairs:
        #
        # key     value
        # key=value
        # key:value
        # key     value1,value2,value3
        # key     value1,value2,value3 \
        #         value4, value5
        # key
        # This key= this value
        # key = value1 value2 value3

        # Any line that starts with a '#' is considerered a comment
        # and skipped. Also any trailing or preceding whitespaces
        # are removed from the key/value.

        # This is a line parser. It parses the
        # contents like by line.

C'est ce que je fais dans mon projet: je viens de créer un autre fichier. py appelé properties.py qui inclut toutes les variables/propriétés communes que j'ai utilisées dans le projet, et dans n'importe quel fichier besoin de se référer à ces variables, put

from properties import *(or anything you need)

A utilisé cette méthode pour garder la paix svn quand je changeais fréquemment les emplacements de dev et certaines variables communes étaient assez relatives à l'environnement local. Fonctionne bien pour moi, mais pas sûr que cette méthode serait suggérée pour l'environnement de développement formel, etc.

J'ai créé un module python qui est presque similaire à la classe Properties de Java (en fait c'est comme le PropertyPlaceholderConfigurer au printemps qui vous permet d'utiliser ${variable-reference} pour faire référence à une propriété déjà définie)

EDIT: vous pouvez installer ce paquet en exécutant la commande (actuellement testée pour python 3).
pip install property

, Le projet est hébergé sur GitHub

Exemple : ( documentation Détaillée peut être trouvée ici )

Disons que vous avez les propriétés suivantes définies dans my_file.fichier de propriétés

foo = I am awesome
bar = ${chocolate}-bar
chocolate = fudge

Code pour charger les propriétés ci-dessus

from properties.p import Property

prop = Property()
# Simply load it into a dictionary
dic_prop = prop.load_property_files('my_file.properties')

Si vous avez besoin de lire toutes les valeurs d'une section dans le fichier de propriétés d'une manière simple:

Votre config.properties mise en page du fichier:

[SECTION_NAME]  
key1 = value1  
key2 = value2  

Vous code:

   import configparser

   config = configparser.RawConfigParser()
   config.read('path_to_config.properties file')

   details_dict = dict(config.items('SECTION_NAME'))

Cela vous donnera un dictionnaire où les clés sont les mêmes que dans le fichier de configuration et leurs valeurs correspondantes.

details_dict est :

{'key1':'value1', 'key2':'value2'}

Maintenant pour obtenir la valeur de key1 : details_dict['key1']

Mettre tout dans une méthode qui lit cette section À partir du fichier de configuration une seule fois(la première fois que la méthode est appelée pendant un programme exécuter).

def get_config_dict():
    if not hasattr(get_config_dict, 'config_dict'):
        get_config_dict.config_dict = dict(config.items('SECTION_NAME'))
    return get_config_dict.config_dict

Appelez maintenant la fonction ci-dessus et obtenez la valeur de la clé requise:

config_details = get_config_dict()
key_1_value = config_details['key1'] 

import json
f=open('test.json')
x=json.load(f)
f.close()
print(x)

Contenu de l'essai.json: {"hôte": "127.0.0.1", "utilisateur": "jms"}

Vous pouvez utiliser un objet de type fichier dans ConfigParser.RawConfigParser.readfp défini ici - > https://docs.python.org/2/library/configparser.html#ConfigParser.RawConfigParser.readfp

Définissez une classe qui remplace readline qui ajoute un nom de section avant le contenu réel de votre fichier de propriétés.

Je l'ai empaqueté dans la classe qui renvoie un dict de toutes les propriétés définies.

import ConfigParser

class PropertiesReader(object):

    def __init__(self, properties_file_name):
        self.name = properties_file_name
        self.main_section = 'main'

        # Add dummy section on top
        self.lines = [ '[%s]\n' % self.main_section ]

        with open(properties_file_name) as f:
            self.lines.extend(f.readlines())

        # This makes sure that iterator in readfp stops
        self.lines.append('')

    def readline(self):
        return self.lines.pop(0)

    def read_properties(self):
        config = ConfigParser.RawConfigParser()

        # Without next line the property names will be lowercased
        config.optionxform = str

        config.readfp(self)
        return dict(config.items(self.main_section))

if __name__ == '__main__':
    print PropertiesReader('/path/to/file.properties').read_properties()

Au-dessous de 2 lignes de code montre comment utiliser la compréhension de la liste Python pour charger le fichier de propriété 'java style'.

split_properties=[line.split("=") for line in open('/<path_to_property_file>)]
properties={key: value for key,value in split_properties }

Veuillez jeter un oeil au poste ci-dessous pour plus de détails https://ilearnonlinesite.wordpress.com/2017/07/24/reading-property-file-in-python-using-comprehension-and-generators/

Si vous n'avez pas de propriétés multi-lignes et un besoin très simple, quelques lignes de code peuvent le résoudre pour vous:

Fichier t.properties:

a=b
c=d
e=f

Code Python:

with open("t.properties") as f:
    l = [line.split("=") for line in f.readlines()]
    d = {key.strip(): value.strip() for key, value in l}

Je l'ai fait en utilisant ConfigParser comme suit. Le code suppose qu'il existe un fichier appelé config.prop dans le même répertoire où BaseTest est placé:

Config.prop

[CredentialSection]
app.name=MyAppName

BaseTest.py:

import unittest
import ConfigParser

class BaseTest(unittest.TestCase):
    def setUp(self):
        __SECTION = 'CredentialSection'
        config = ConfigParser.ConfigParser()
        config.readfp(open('config.prop'))
        self.__app_name = config.get(__SECTION, 'app.name')

    def test1(self):
        print self.__app_name % This should print: MyAppName

C'est ce que j'avais écrit pour analyser le fichier et le Définir comme variables env qui ignore les commentaires et les lignes de valeur non clés ajoutées pour spécifier hg: d

• - h ou --help imprimer le résumé d'utilisation
• - C spécifiez le caractère qui identifie le commentaire
• - S séparateur entre la clé et la valeur dans le fichier prop

• Et spécifiez le fichier de propriétés qui doit être analysé, par exemple: python EnvParamSet.py -C # - S = env.propriétés

  import pipes
  import sys , getopt
  import os.path
  
  class Parsing :
  
          def __init__(self , seprator , commentChar , propFile):
          self.seprator = seprator
          self.commentChar = commentChar
          self.propFile  = propFile
  
      def  parseProp(self):
          prop = open(self.propFile,'rU')
          for line in prop :
              if line.startswith(self.commentChar)==False and  line.find(self.seprator) != -1  :
                  keyValue = line.split(self.seprator)
                  key =  keyValue[0].strip() 
                  value = keyValue[1].strip() 
                          print("export  %s=%s" % (str (key),pipes.quote(str(value))))
  
  
  
  
  class EnvParamSet:
  
      def main (argv):
  
          seprator = '='
          comment =  '#'
  
          if len(argv)  is 0:
              print "Please Specify properties file to be parsed "
              sys.exit()
          propFile=argv[-1] 
  
  
          try :
              opts, args = getopt.getopt(argv, "hs:c:f:", ["help", "seprator=","comment=", "file="])
          except getopt.GetoptError,e:
              print str(e)
              print " possible  arguments  -s <key value sperator > -c < comment char >    <file> \n  Try -h or --help "
              sys.exit(2)
  
  
          if os.path.isfile(args[0])==False:
              print "File doesnt exist "
              sys.exit()
  
  
          for opt , arg  in opts :
              if opt in ("-h" , "--help"):
                  print " hg:d  \n -h or --help print usage summary \n -c Specify char that idetifes comment  \n -s Sperator between key and value in prop file \n  specify file  "
                  sys.exit()
              elif opt in ("-s" , "--seprator"):
                  seprator = arg 
              elif opt in ("-c"  , "--comment"):
                  comment  = arg
  
          p = Parsing( seprator, comment , propFile)
          p.parseProp()
  
      if __name__ == "__main__":
              main(sys.argv[1:])
  

Lightbend a publié la bibliothèque Typesafe Config , qui analyse les fichiers de propriétés et certaines extensions basées sur JSON. La bibliothèque de Lightbend est uniquement pour la JVM, mais elle semble être largement adoptée et il existe maintenant des ports dans de nombreux langages, y compris Python: https://github.com/chimpler/pyhocon