def _testParsePropertiesInput(self, stream):
   properties = Properties()
   properties.load(stream)
   self.assertEquals(23, len(properties.items()))
   self.assertEquals('Value00', properties['Key00'])
   self.assertEquals('Value01', properties['Key01'])
   self.assertEquals('Value02', properties['Key02'])
   self.assertEquals('Value03', properties['Key03'])
   self.assertEquals('Value04', properties['Key04'])
   self.assertEquals('Value05a, Value05b, Value05c', properties['Key05'])
   self.assertEquals('Value06a, Value06b, Value06c', properties['Key06'])
   self.assertEquals('Value07b', properties['Key07'])
   self.assertEquals(
       'Value08a, Value08b, Value08c, Value08d, Value08e, Value08f',
       properties['Key08'])
   self.assertEquals(
       'Value09a, Value09b, Value09c, Value09d, Value09e, Value09f',
       properties['Key09'])
   self.assertEquals('Value10', properties['Key10'])
   self.assertEquals('', properties['Key11'])
   self.assertEquals('Value12a, Value12b, Value12c', properties['Key12'])
   self.assertEquals('Value13 With Spaces', properties['Key13'])
   self.assertEquals('Value14 With Spaces', properties['Key14'])
   self.assertEquals('Value15 With Spaces', properties['Key15'])
   self.assertEquals('Value16', properties['Key16 With Spaces'])
   self.assertEquals('Value17', properties['Key17 With Spaces'])
   self.assertEquals('Value18 # Not a comment.', properties['Key18'])
   self.assertEquals('Value19 ! Not a comment.', properties['Key19'])
   self.assertEquals('Value20', properties['Key20=WithEquals'])
   self.assertEquals('Value21', properties['Key21:WithColon'])
   self.assertEquals('Value22', properties['Key22'])

 def load_configuration(self):
     p = Properties()
     p.load(open(CONFIGURATION_PROPERTIES))
     self.producers_point = p['producers.point']
     # FIXME: auto acquire the name according to the machine's ip
     self.cluster_name = socket.gethostname().split('-')[0]
     self.ip = get_public_ip()

def getFilename():
    p = Properties();
    p.load(open('../../build.number.properties'));
    minor = p['build.minor'];
    major = p['build.major'];
    point = p['build.point'];
    filename = 'core_' + major + minor + point 
    return filename

def suffixFilename(filename, build):
    p = Properties();
    p.load(open('projects/mtg/build.number.properties'));
    minor = p['build.minor'];
    major = p['build.major'];
    point = p['build.point'];
    name, extension = os.path.splitext(filename)
    filename = name + '-' + major + minor + point + '-' + build + extension
    return filename

def get_dependency_projects():
    if os.path.exists(project_filename):
        with open(project_filename) as fsock:
            properties = Properties()
            properties.load(fsock)

            project  = re.compile(r'android.library.reference.\d+')
            return (value for key, value in properties.items() if project.match(key))
    else:
        return []

def load(filename=DEFAULT_CONFIG_FILENAME):
    p = Properties()
    if os.path.isfile(filename):
        p.load(open('stock.properties'))

    if not p['listed.pricePath'].strip():
        p['listed.pricePath'] = DEFAULT_LISTED_PRICE_PATH
    if not p['listed.instPath'].strip():
        p['listed.instPath'] = DEFAULT_LISTED_INST_PATH
    
    if not p['listed.lastDownload'].strip():
        p['listed.lastDownload'] = DEFAULT_START_DATE
    if p['listed.isDownload'].strip() != 'false':
        p['listed.isDownload'] = 'true'
    
    if not p['listed.lastUpdateDb'].strip():
        p['listed.lastUpdateDb'] = DEFAULT_START_DATE
    if p['listed.isUpdateDb'].strip() != 'false':
        p['listed.isUpdateDb'] = 'true'
    
    if not p['listed.lastUpdateIdx'].strip():
        p['listed.lastUpdateIdx'] = DEFAULT_START_DATE
    if p['listed.isUpdateIdx'].strip() != 'false':
        p['listed.isUpdateIdx'] = 'true'

    if not p['otc.pricePath'].strip():
        p['otc.pricePath'] = DEFAULT_OTC_PRICE_PATH
    if not p['otc.instPath'].strip():
        p['otc.instPath'] = DEFAULT_OTC_INST_PATH
        
    if not p['otc.lastDownload'].strip():
        p['otc.lastDownload'] = DEFAULT_START_DATE
    if p['otc.isDownload'].strip() != 'false':
        p['otc.isDownload'] = 'true'
    
    if not p['otc.lastUpdateDb'].strip():
        p['otc.lastUpdateDb'] = DEFAULT_START_DATE
    if p['otc.isUpdateDb'].strip() !='false':
        p['otc.isUpdateDb'] = 'true'
    
    if not p['otc.lastUpdateIdx'].strip():
        p['otc.lastUpdateIdx'] = DEFAULT_START_DATE
    if p['otc.isUpdateIdx'].strip() !='false':
        p['otc.isUpdateIdx'] = 'true'

    if not p['db.server'].strip():
        p['db.server'] = 'SERVER_NAME'
    if not p['db.username'].strip():
        p['db.username'] = 'USERNAME'
    if not p['db.password'].strip():
        p['db.password'] = 'PASSWORD'
    if not p['db.database'].strip():
        p['db.database'] = 'DATABASE_NAME'

    return p

def parse_property_file(filename):
    """
    parse java properties file
    :param filename: the path of the properties file
    :return: dictionary loaded from the file
    """
    if not os.path.isfile(filename):
        raise RuntimeError("No file found for parameter at {0}".format(filename))
    p = Properties()
    p.load(open(filename))
    return p

class Config(object):
    def __init__(self, filepath):
        self.filepath = filepath
        self.config = Properties()
        with open(filepath) as file:
            self.config.load(file)

    def get_property(self, key):
        return self.config[key]

    def has_property(self, key):
        return key in self.config.propertyNames()

 def __generate_workload_config(self, extraneous_config):
     # Read base workload properties into a dict if we haven't already
     if self.__base_workload_props is None:
         props = Properties()
         with open(self.workload_path) as wf:
             props.load(wf)
         self.__base_workload_props = props.getPropertyDict()
     if extraneous_config is None:
         extraneous_config = {}
     # Merge base workload properties with extraneous options
     workload_config = dict(self.__base_workload_props)
     workload_config.update(extraneous_config)
     # Merge and return the workload config dict
     return workload_config

    def __init__(self,*args):
        unittest.TestCase.__init__(self, *args)
        index = int(__file__.rfind("/"))
        basedir = __file__[0:index]

        p = Properties()
        p.load(open(basedir + '/gnip_account.properties'))
        p.load(open(basedir + '/test.properties'))
        self.gnip = Gnip(p['gnip.username'], p['gnip.password'], p['gnip.server'])
        self.testpublisher = p['gnip.test.publisher']
        self.testpublisherscope = p['gnip.test.publisher.scope']
        self.success = Result('Success')
        self.filterXml = None
        self.rules = None
        self.filterName = None
        self.filterFullData = None

    def parse(settingsdir=None):
        if settingsdir == None:
            settingsdir = JitsiProperties.path
        p = Properties()
        p.load(open(os.path.join(settingsdir, JitsiProperties.propertiesfile)))
        keydict = dict()
        for item in p.items():
            propkey = item[0]
            name = ""
            if re.match("net\.java\.sip\.communicator\.impl\.protocol\.jabber\.acc[0-9]+\.ACCOUNT_UID", propkey):
                name = JitsiProperties._parse_account_uid(item[1])
                if name in keydict:
                    key = keydict[name]
                else:
                    key = dict()
                    key["name"] = name
                    key["protocol"] = "prpl-jabber"
                    keydict[name] = key

                propkey_base = "net.java.sip.communicator.plugin.otr." + re.sub("[^a-zA-Z0-9_]", "_", item[1])
                private_key = p.getProperty(propkey_base + "_privateKey").strip()
                public_key = p.getProperty(propkey_base + "_publicKey").strip()
                numdict = util.ParsePkcs8(private_key)
                key["x"] = numdict["x"]
                numdict = util.ParseX509(public_key)
                for num in ("y", "g", "p", "q"):
                    key[num] = numdict[num]
                key["fingerprint"] = util.fingerprint((key["y"], key["g"], key["p"], key["q"]))
                verifiedkey = (
                    "net.java.sip.communicator.plugin.otr."
                    + re.sub("[^a-zA-Z0-9_]", "_", key["name"])
                    + "_publicKey_verified"
                )
                if p.getProperty(verifiedkey).strip() == "true":
                    key["verification"] = "verified"
            elif re.match("net\.java\.sip\.communicator\.plugin\.otr\..*_publicKey_verified", propkey):
                name, protocol = JitsiProperties._parse_account_from_propkey(settingsdir, propkey)
                if name != None:
                    if name not in keydict:
                        key = dict()
                        key["name"] = name
                        keydict[name] = key
                    if protocol and "protocol" not in keydict[name]:
                        keydict[name]["protocol"] = protocol
                    keydict[name]["verification"] = "verified"
            # if the protocol name is included in the property name, its a local account with private key
            elif re.match("net\.java\.sip\.communicator\.plugin\.otr\..*_publicKey", propkey) and not re.match(
                "net\.java\.sip\.communicator\.plugin\.otr\.(Jabber_|Google_Talk_)", propkey
            ):
                name, ignored = JitsiProperties._parse_account_from_propkey(settingsdir, propkey)
                if name not in keydict:
                    key = dict()
                    key["name"] = name
                    key["protocol"] = "prpl-jabber"
                    keydict[name] = key
                numdict = util.ParseX509(item[1])
                for num in ("y", "g", "p", "q"):
                    key[num] = numdict[num]
                key["fingerprint"] = util.fingerprint((key["y"], key["g"], key["p"], key["q"]))
        return keydict

    def parse(settingsdir=None):
        if settingsdir == None:
            settingsdir = JitsiProperties.path
        p = Properties()
        p.load(open(os.path.join(settingsdir, JitsiProperties.propertiesfile)))
        keydict = dict()
        for item in p.items():
            propkey = item[0]
            name = ''
            if re.match('net\.java\.sip\.communicator\.impl\.protocol\.jabber\.acc[0-9]+\.ACCOUNT_UID', propkey):
                name = JitsiProperties._parse_account_uid(item[1])
                if name in keydict:
                    key = keydict[name]
                else:
                    key = dict()
                    key['name'] = name
                    key['protocol'] = 'prpl-jabber'
                    keydict[name] = key

                propkey_base = ('net.java.sip.communicator.plugin.otr.'
                                + re.sub('[^a-zA-Z0-9_]', '_', item[1]))
                private_key = p.getProperty(propkey_base + '_privateKey').strip()
                public_key = p.getProperty(propkey_base + '_publicKey').strip()
                numdict = util.ParsePkcs8(private_key)
                key['x'] = numdict['x']
                numdict = util.ParseX509(public_key)
                for num in ('y', 'g', 'p', 'q'):
                    key[num] = numdict[num]
                key['fingerprint'] = util.fingerprint((key['y'], key['g'], key['p'], key['q']))
                verifiedkey = ('net.java.sip.communicator.plugin.otr.'
                               + re.sub('[^a-zA-Z0-9_]', '_', key['name'])
                               + '_publicKey_verified')
                if p.getProperty(verifiedkey).strip() == 'true':
                    key['verification'] = 'verified'
            elif (re.match('net\.java\.sip\.communicator\.plugin\.otr\..*_publicKey_verified', propkey)):
                name, protocol = JitsiProperties._parse_account_from_propkey(settingsdir, propkey)
                if name != None:
                    if name not in keydict:
                        key = dict()
                        key['name'] = name
                        keydict[name] = key
                    if protocol and 'protocol' not in keydict[name]:
                        keydict[name]['protocol'] = protocol
                    keydict[name]['verification'] = 'verified'
            # if the protocol name is included in the property name, its a local account with private key
            elif (re.match('net\.java\.sip\.communicator\.plugin\.otr\..*_publicKey', propkey) and not
                  re.match('net\.java\.sip\.communicator\.plugin\.otr\.(Jabber_|Google_Talk_)', propkey)):
                name, ignored = JitsiProperties._parse_account_from_propkey(settingsdir, propkey)
                if name not in keydict:
                    key = dict()
                    key['name'] = name
                    key['protocol'] = 'prpl-jabber'
                    keydict[name] = key
                numdict = util.ParseX509(item[1])
                for num in ('y', 'g', 'p', 'q'):
                    key[num] = numdict[num]
                key['fingerprint'] = util.fingerprint((key['y'], key['g'], key['p'], key['q']))
        return keydict

    def __init__(self, username, password, gnip_server=None, properties_file=None):
        """Initialize the class.

        @type username string
        @param username Your Gnip account username
        @type password string
        @param password Your Gnip account password
        @type gnip_server string
        @param gnip_server The Gnip server to connect to

        Initializes a Gnip class by setting up authentication
        information, used to log into the Gnip service.

        """

        p = Properties()
        if properties_file is not None:
            p.load(open(properties_file))
        else:
            index = int(__file__.rfind("/"))
            basedir = __file__[0:index]
            p.load(open(basedir + '/gnip.properties'))
        
        # Determine base Gnip URL
        if (gnip_server is None):
            self.base_url = p['gnip.server']
        else:
            self.base_url = gnip_server
        
        self.tunnel_over_post = bool(p['gnip.tunnel.over.post=false'])

        # Configure authentication
        self.client = httplib2.Http(timeout = int(p['gnip.http.timeout']))
        self.client.add_credentials(username, password)

        self.headers = {}
        self.headers['Accept'] = 'gzip, application/xml'
        self.headers['User-Agent'] = 'Gnip-Client-Python/2.1.0'
        self.headers['Content-Encoding'] = 'gzip'
        self.headers['Content-Type'] = 'application/xml'

    sys.stderr.write("Unspecified graph generation model (please use --help for help)\n")
    sys.exit(1)

if output_filename is None:
    # output_filename = os.path.join(script_dir, '../../../' + p['bench.datasets.directory'] + '/' + p['bench.graph.barabasi.file'])
    sys.stderr.write("The output file name is not specified (please use --help for help)\n")
    sys.exit(1)

model = string.lower(model)


#
# Load the properties
#

p = Properties()
p.load(open(os.path.join(script_dir, '../resources/com/tinkerpop/bench/bench.properties')))


#
# Model "Barabasi"
#

if model == "barabasi":
    
    if param_m is None:
        param_m = int(p['bench.graph.barabasi.degree'])
    if param_n is None:
        param_n = int(p['bench.graph.barabasi.vertices'])

    sys.stderr.write("Generating a Barabasi graph with n=%d, m=%d\n" % (param_n, param_m))

 def __init__(self, filepath):
     self.filepath = filepath
     self.config = Properties()
     with open(filepath) as file:
         self.config.load(file)

# Convert an edgelist to graphML
# author Sidney Shaw

from igraph import *
from pyjavaproperties import Properties
from random import *

p = Properties()
p.load(open('../java/com/tinkerpop/bench/bench.properties'))

g = Graph.Read_Edgelist("")  # here specify the file to be converted

for v in g.vs:
    g.vs[v.index][p['bench.graph.property.id']] = "node:n" + str(v.index)
for e in g.es:
    g.es[e.index][p['bench.graph.property.id']] = "e" + str(e.index)
for e in g.es:
    g.es[e.index][p['bench.graph.label']] = p['bench.graph.label.friend']

g.write_graphml('../../' + p['bench.datasets.directory'] +
                '/amazon.graphml')

    def get_file_items(self, window, files):        
        #les variables sont ici pour le dynamisme du dossier
        #variables
        
        if len(files) <= 0:
            return
        
        
        listFile=[]
        for i in range(0,len(files)):
            if "video" in files[i].get_mime_type() :
                listFile.append(files[i])
            
        if len(listFile)<=0:
            return
        
        
        menu = Nautilus.Menu()

        mainItem=Nautilus.MenuItem(
            name="MenuExtension::JMita2_Menu",
            label="Lire sur ...",
            tip=""
        )
        
        mainItem.set_submenu(menu)
        
        itemJMita2 = Nautilus.MenuItem(
            name="MenuExtension::JMita2_Item",
            label="Rechercher un appareil...",
            tip=""
        )
        
        itemAbout= Nautilus.MenuItem(
            name="MenuExtencion::JMita2_About",
            label="about JMita 2",
            tip=""
        )
        
        menu.append_item(itemJMita2)
        
        
        itemJMita2.connect('activate', self.menu_activate_cb, listFile)
        count=1
        
        if (os.path.exists(self.favoris)):
        
            allFavoris=os.listdir(self.favoris)
            for file in allFavoris:
                p=Properties()
                p.load(open(self.favoris+file))
                
                item=Nautilus.MenuItem(
                    name="MenuExtension::JMita2_Item_"+str(count),
                    label=p["name"],
                    tip=""
                )
                
                item.connect('activate',self.menu_activate_cb_favoris,listFile,p["identifier"])
                
                menu.append_item(item)
                count=count+1
                
        menu.append_item(itemAbout)
        
        return [mainItem]

"""
Commandline parameter(s):

    first parameter must be the ARFF file

"""

# check commandline parameters
if (not (len(sys.argv) == 3)):
    print "Usage: supervised.py <ARFF-file> <Validation>"
    sys.exit()
crossvalidate = sys.argv[2]
rand = Random()              # seed from the system time

# load properties
p = Properties()
p.load(open('./ml.properties'))

# load data file
print "Loading data..."
trainfile = FileReader(sys.argv[1] + "-train.arff")
print "Loading " + sys.argv[1] + "-train.arff"
testfile = FileReader(sys.argv[1] + "-test.arff")
print "Loading " + sys.argv[1] + "-test.arff"
fulltrainset = Instances(trainfile)
fulltrainset.setClassIndex(fulltrainset.numAttributes() - 1)
testset = Instances(testfile)
testset.setClassIndex(testset.numAttributes() - 1)

# open output files
bufsize=0

# Generate Artificial Graphs
# Alex Averbuch ([email protected])

from igraph import *
from pyjavaproperties import Properties
from random import *

p = Properties()
p.load(open('../resources/com/tinkerpop/bench/bench.properties'))

degree = int(p['bench.graph.barabasi.degree'])
vertices = int(p['bench.graph.barabasi.vertices'])

g = Graph.Barabasi(n=vertices, m=degree, power=1, directed=False, zero_appeal=8)

for v in g.vs:
    g.vs[v.index][p['bench.graph.property.id']] = "v" + str(v.index)
for e in g.es:
    g.es[e.index][p['bench.graph.property.id']] = "e" + str(e.index)
for e in g.es:
    if random() < 0.5:
        g.es[e.index][p['bench.graph.label']] = p['bench.graph.label.friend']
    else:
        g.es[e.index][p['bench.graph.label']] = p['bench.graph.label.family']
g.write_graphml('../../../' + p['bench.datasets.directory'] + 
                '/' + p['bench.graph.barabasi.file'])

 def _testParsePropertiesOutput(self, stream):
   properties = Properties()
   properties.setProperty('Key00', 'Value00')
   properties.setProperty('Key01', 'Value01')
   properties.setProperty('Key02', 'Value02')
   properties.setProperty('Key03', 'Value03')
   properties.setProperty('Key04', 'Value04')
   properties.setProperty('Key05', 'Value05a, Value05b, Value05c')
   properties.setProperty('Key06', 'Value06a, Value06b, Value06c',)
   properties.setProperty('Key07', 'Value07b')
   properties.setProperty('Key08',
       'Value08a, Value08b, Value08c, Value08d, Value08e, Value08f')
   properties.setProperty('Key09',
       'Value09a, Value09b, Value09c, Value09d, Value09e, Value09f')
   properties.setProperty('Key10', 'Value10')
   properties.setProperty('Key11', '')
   properties.setProperty('Key12', 'Value12a, Value12b, Value12c')
   properties.setProperty('Key13', 'Value13 With Spaces')
   properties.setProperty('Key14', 'Value14 With Spaces')
   properties.setProperty('Key15', 'Value15 With Spaces')
   properties.setProperty('Key16 With Spaces', 'Value16')
   properties.setProperty('Key17 With Spaces', 'Value17')
   properties.setProperty('Key18', 'Value18 # Not a comment.')
   properties.setProperty('Key19', 'Value19 ! Not a comment.')
   properties.setProperty('Key20=WithEquals', 'Value20')
   properties.setProperty('Key21:WithColon', 'Value21')
   properties.setProperty('Key22', 'Value22')
   properties.store(stream)