Python write示例

示例#1

文件： is_buhid_unicos.py 项目： Tikubonn/unico

import json
from lib import node
from lib.generator import predicate_function
from lib.generator import predicate_function_declaration

with open("json/buhid.json", "r") as stream:
    data = json.load(stream)

nd = node.RootNode()

for dat in data:
    nd.extend(dat, True)

with open("dist/is_buhid_unicos.h", "w") as stream:
    predicate_function_declaration.write("is_buhid_unicos", stream)

with open("dist/is_buhid_unicos.c", "w") as stream:
    predicate_function.write("is_buhid_unicos", nd, stream)

示例#2

import json
from lib import node
from lib.generator import predicate_function
from lib.generator import predicate_function_declaration

with open("json/osmanya.json", "r") as stream:
    data = json.load(stream)

nd = node.RootNode()

for dat in data:
    nd.extend(dat, True)

with open("dist/is_osmanya_unicos.h", "w") as stream:
    predicate_function_declaration.write("is_osmanya_unicos", stream)

with open("dist/is_osmanya_unicos.c", "w") as stream:
    predicate_function.write("is_osmanya_unicos", nd, stream)

示例#3

文件： is_digits_unicos.py 项目： Tikubonn/unico

import json
from lib import node
from lib.generator import predicate_function
from lib.generator import predicate_function_declaration

with open("json/digits.json", "r") as stream:
    data = json.load(stream)

nd = node.RootNode()

for dat in data:
    nd.extend(dat, True)

with open("dist/is_digits_unicos.h", "w") as stream:
    predicate_function_declaration.write("is_digits_unicos", stream)

with open("dist/is_digits_unicos.c", "w") as stream:
    predicate_function.write("is_digits_unicos", nd, stream)

示例#4

文件： is_grantha_unicos.py 项目： Tikubonn/unico

import json
from lib import node
from lib.generator import predicate_function
from lib.generator import predicate_function_declaration

with open("json/grantha.json", "r") as stream:
    data = json.load(stream)

nd = node.RootNode()

for dat in data:
    nd.extend(dat, True)

with open("dist/is_grantha_unicos.h", "w") as stream:
    predicate_function_declaration.write("is_grantha_unicos", stream)

with open("dist/is_grantha_unicos.c", "w") as stream:
    predicate_function.write("is_grantha_unicos", nd, stream)

示例#5

import json
from lib import node
from lib.generator import predicate_function
from lib.generator import predicate_function_declaration

with open("json/inscriptional_parthian.json", "r") as stream:
    data = json.load(stream)

nd = node.RootNode()

for dat in data:
    nd.extend(dat, True)

with open("dist/is_inscriptional_parthian_unicos.h", "w") as stream:
    predicate_function_declaration.write("is_inscriptional_parthian_unicos",
                                         stream)

with open("dist/is_inscriptional_parthian_unicos.c", "w") as stream:
    predicate_function.write("is_inscriptional_parthian_unicos", nd, stream)

示例#6

文件： is_new_tai_lue_unicos.py 项目： Tikubonn/unico

import json
from lib import node
from lib.generator import predicate_function
from lib.generator import predicate_function_declaration

with open("json/new_tai_lue.json", "r") as stream:
    data = json.load(stream)

nd = node.RootNode()

for dat in data:
    nd.extend(dat, True)

with open("dist/is_new_tai_lue_unicos.h", "w") as stream:
    predicate_function_declaration.write("is_new_tai_lue_unicos", stream)

with open("dist/is_new_tai_lue_unicos.c", "w") as stream:
    predicate_function.write("is_new_tai_lue_unicos", nd, stream)

示例#7

import json
from lib import node
from lib.generator import predicate_function
from lib.generator import predicate_function_declaration

with open("json/thaana.json", "r") as stream:
    data = json.load(stream)

nd = node.RootNode()

for dat in data:
    nd.extend(dat, True)

with open("dist/is_thaana_unicos.h", "w") as stream:
    predicate_function_declaration.write("is_thaana_unicos", stream)

with open("dist/is_thaana_unicos.c", "w") as stream:
    predicate_function.write("is_thaana_unicos", nd, stream)

示例#8

文件： is_ethiopic_unicos.py 项目： Tikubonn/unico

import json
from lib import node 
from lib.generator import predicate_function
from lib.generator import predicate_function_declaration

with open("json/ethiopic.json", "r") as stream:
  data = json.load(stream)

nd = node.RootNode()

for dat in data:
  nd.extend(dat, True)

with open("dist/is_ethiopic_unicos.h", "w") as stream:
  predicate_function_declaration.write("is_ethiopic_unicos", stream)

with open("dist/is_ethiopic_unicos.c", "w") as stream:
  predicate_function.write("is_ethiopic_unicos", nd, stream)

示例#9

import json
from lib import node
from lib.generator import predicate_function
from lib.generator import predicate_function_declaration

with open("json/telugu.json", "r") as stream:
    data = json.load(stream)

nd = node.RootNode()

for dat in data:
    nd.extend(dat, True)

with open("dist/is_telugu_unicos.h", "w") as stream:
    predicate_function_declaration.write("is_telugu_unicos", stream)

with open("dist/is_telugu_unicos.c", "w") as stream:
    predicate_function.write("is_telugu_unicos", nd, stream)

示例#10

文件： is_general_symbol_unicos.py 项目： Tikubonn/unico

import json
from lib import node 
from lib.generator import predicate_function
from lib.generator import predicate_function_declaration

with open("json/general_symbol.json", "r") as stream:
  data = json.load(stream)

nd = node.RootNode()

for dat in data:
  nd.extend(dat, True)

with open("dist/is_general_symbol_unicos.h", "w") as stream:
  predicate_function_declaration.write("is_general_symbol_unicos", stream)

with open("dist/is_general_symbol_unicos.c", "w") as stream:
  predicate_function.write("is_general_symbol_unicos", nd, stream)

示例#11

import json
from lib import node 
from lib.generator import predicate_function
from lib.generator import predicate_function_declaration

with open("json/khudawadi.json", "r") as stream:
  data = json.load(stream)

nd = node.RootNode()

for dat in data:
  nd.extend(dat, True)

with open("dist/is_khudawadi_unicos.h", "w") as stream:
  predicate_function_declaration.write("is_khudawadi_unicos", stream)

with open("dist/is_khudawadi_unicos.c", "w") as stream:
  predicate_function.write("is_khudawadi_unicos", nd, stream)

示例#12

import json
from lib import node
from lib.generator import predicate_function
from lib.generator import predicate_function_declaration

with open("json/tamil.json", "r") as stream:
    data = json.load(stream)

nd = node.RootNode()

for dat in data:
    nd.extend(dat, True)

with open("dist/is_tamil_unicos.h", "w") as stream:
    predicate_function_declaration.write("is_tamil_unicos", stream)

with open("dist/is_tamil_unicos.c", "w") as stream:
    predicate_function.write("is_tamil_unicos", nd, stream)

示例#13

import json
from lib import node
from lib.generator import predicate_function
from lib.generator import predicate_function_declaration

with open("json/nushu.json", "r") as stream:
    data = json.load(stream)

nd = node.RootNode()

for dat in data:
    nd.extend(dat, True)

with open("dist/is_nushu_unicos.h", "w") as stream:
    predicate_function_declaration.write("is_nushu_unicos", stream)

with open("dist/is_nushu_unicos.c", "w") as stream:
    predicate_function.write("is_nushu_unicos", nd, stream)

示例#14

import json
from lib import node
from lib.generator import predicate_function
from lib.generator import predicate_function_declaration

with open("json/shavian.json", "r") as stream:
    data = json.load(stream)

nd = node.RootNode()

for dat in data:
    nd.extend(dat, True)

with open("dist/is_shavian_unicos.h", "w") as stream:
    predicate_function_declaration.write("is_shavian_unicos", stream)

with open("dist/is_shavian_unicos.c", "w") as stream:
    predicate_function.write("is_shavian_unicos", nd, stream)

示例#15

文件： is_old_italic_unicos.py 项目： Tikubonn/unico

import json
from lib import node 
from lib.generator import predicate_function
from lib.generator import predicate_function_declaration

with open("json/old_italic.json", "r") as stream:
  data = json.load(stream)

nd = node.RootNode()

for dat in data:
  nd.extend(dat, True)

with open("dist/is_old_italic_unicos.h", "w") as stream:
  predicate_function_declaration.write("is_old_italic_unicos", stream)

with open("dist/is_old_italic_unicos.c", "w") as stream:
  predicate_function.write("is_old_italic_unicos", nd, stream)

示例#16

文件： is_meetei_mayek_unicos.py 项目： Tikubonn/unico

import json
from lib import node
from lib.generator import predicate_function
from lib.generator import predicate_function_declaration

with open("json/meetei_mayek.json", "r") as stream:
    data = json.load(stream)

nd = node.RootNode()

for dat in data:
    nd.extend(dat, True)

with open("dist/is_meetei_mayek_unicos.h", "w") as stream:
    predicate_function_declaration.write("is_meetei_mayek_unicos", stream)

with open("dist/is_meetei_mayek_unicos.c", "w") as stream:
    predicate_function.write("is_meetei_mayek_unicos", nd, stream)

示例#17

import json
from lib import node
from lib.generator import predicate_function
from lib.generator import predicate_function_declaration

with open("json/armenian.json", "r") as stream:
    data = json.load(stream)

nd = node.RootNode()

for dat in data:
    nd.extend(dat, True)

with open("dist/is_armenian_unicos.h", "w") as stream:
    predicate_function_declaration.write("is_armenian_unicos", stream)

with open("dist/is_armenian_unicos.c", "w") as stream:
    predicate_function.write("is_armenian_unicos", nd, stream)

示例#18

import json
from lib import node
from lib.generator import predicate_function
from lib.generator import predicate_function_declaration

with open("json/syloti_nagri.json", "r") as stream:
    data = json.load(stream)

nd = node.RootNode()

for dat in data:
    nd.extend(dat, True)

with open("dist/is_syloti_nagri_unicos.h", "w") as stream:
    predicate_function_declaration.write("is_syloti_nagri_unicos", stream)

with open("dist/is_syloti_nagri_unicos.c", "w") as stream:
    predicate_function.write("is_syloti_nagri_unicos", nd, stream)

示例#19

import json
from lib import node 
from lib.generator import predicate_function
from lib.generator import predicate_function_declaration

with open("json/kayah_li.json", "r") as stream:
  data = json.load(stream)

nd = node.RootNode()

for dat in data:
  nd.extend(dat, True)

with open("dist/is_kayah_li_unicos.h", "w") as stream:
  predicate_function_declaration.write("is_kayah_li_unicos", stream)

with open("dist/is_kayah_li_unicos.c", "w") as stream:
  predicate_function.write("is_kayah_li_unicos", nd, stream)

示例#20

文件： is_georgian_unicos.py 项目： Tikubonn/unico

import json
from lib import node
from lib.generator import predicate_function
from lib.generator import predicate_function_declaration

with open("json/georgian.json", "r") as stream:
    data = json.load(stream)

nd = node.RootNode()

for dat in data:
    nd.extend(dat, True)

with open("dist/is_georgian_unicos.h", "w") as stream:
    predicate_function_declaration.write("is_georgian_unicos", stream)

with open("dist/is_georgian_unicos.c", "w") as stream:
    predicate_function.write("is_georgian_unicos", nd, stream)

示例#21

文件： is_lao_unicos.py 项目： Tikubonn/unico

import json
from lib import node
from lib.generator import predicate_function
from lib.generator import predicate_function_declaration

with open("json/lao.json", "r") as stream:
    data = json.load(stream)

nd = node.RootNode()

for dat in data:
    nd.extend(dat, True)

with open("dist/is_lao_unicos.h", "w") as stream:
    predicate_function_declaration.write("is_lao_unicos", stream)

with open("dist/is_lao_unicos.c", "w") as stream:
    predicate_function.write("is_lao_unicos", nd, stream)

示例#22

文件： is_upcase_unicos_in.py 项目： Tikubonn/unico

import io
import json
from lib import node
from lib.generator import predicate_function

try:

    with open("json/unicode-case.json", "r") as stream:
        datas = json.load(stream)

    nd = node.RootNode()

    for data in datas:
        nd.extend(data["upper"], True)

    with open("dist/is_upcase_unicos_in.c", "w") as stream:
        predicate_function.write("is_upcase_unicos_in", nd, stream)

except KeyboardInterrupt:

    pass

示例#23

文件： is_spacing_combining_unico.py 项目： Tikubonn/unico

import json
from lib.generator import predicate_function

with open("json/spacing-combining.json", "r") as stream:
    characters = json.load(stream)

with open("dist/is_spacing_combining_unico.c", "w") as stream:
    predicate_function.write("is_spacing_combining_unico", characters, stream)

示例#24

import json
from lib import node
from lib.generator import predicate_function
from lib.generator import predicate_function_declaration

with open("json/imperial_aramaic.json", "r") as stream:
    data = json.load(stream)

nd = node.RootNode()

for dat in data:
    nd.extend(dat, True)

with open("dist/is_imperial_aramaic_unicos.h", "w") as stream:
    predicate_function_declaration.write("is_imperial_aramaic_unicos", stream)

with open("dist/is_imperial_aramaic_unicos.c", "w") as stream:
    predicate_function.write("is_imperial_aramaic_unicos", nd, stream)

示例#25

文件： is_unsupported_unicos.py 项目： Tikubonn/unico

import json
from lib import node
from lib.generator import predicate_function
from lib.generator import predicate_function_declaration

with open("json/unsupported.json", "r") as stream:
    data = json.load(stream)

nd = node.RootNode()

for dat in data:
    nd.extend(dat, True)

with open("dist/is_unsupported_unicos.h", "w") as stream:
    predicate_function_declaration.write("is_unsupported_unicos", stream)

with open("dist/is_unsupported_unicos.c", "w") as stream:
    predicate_function.write("is_unsupported_unicos", nd, stream)

示例#26

文件： is_bopomofo_unicos.py 项目： Tikubonn/unico

import json
from lib import node
from lib.generator import predicate_function
from lib.generator import predicate_function_declaration

with open("json/bopomofo.json", "r") as stream:
    data = json.load(stream)

nd = node.RootNode()

for dat in data:
    nd.extend(dat, True)

with open("dist/is_bopomofo_unicos.h", "w") as stream:
    predicate_function_declaration.write("is_bopomofo_unicos", stream)

with open("dist/is_bopomofo_unicos.c", "w") as stream:
    predicate_function.write("is_bopomofo_unicos", nd, stream)

示例#27

文件： is_rejang_unicos.py 项目： Tikubonn/unico

import json
from lib import node 
from lib.generator import predicate_function
from lib.generator import predicate_function_declaration

with open("json/rejang.json", "r") as stream:
  data = json.load(stream)

nd = node.RootNode()

for dat in data:
  nd.extend(dat, True)

with open("dist/is_rejang_unicos.h", "w") as stream:
  predicate_function_declaration.write("is_rejang_unicos", stream)

with open("dist/is_rejang_unicos.c", "w") as stream:
  predicate_function.write("is_rejang_unicos", nd, stream)

示例#28

文件： is_cyrillic_unicos.py 项目： Tikubonn/unico

import json
from lib import node
from lib.generator import predicate_function
from lib.generator import predicate_function_declaration

with open("json/cyrillic.json", "r") as stream:
    data = json.load(stream)

nd = node.RootNode()

for dat in data:
    nd.extend(dat, True)

with open("dist/is_cyrillic_unicos.h", "w") as stream:
    predicate_function_declaration.write("is_cyrillic_unicos", stream)

with open("dist/is_cyrillic_unicos.c", "w") as stream:
    predicate_function.write("is_cyrillic_unicos", nd, stream)

示例#29

import json
from lib import node
from lib.generator import predicate_function
from lib.generator import predicate_function_declaration

with open("json/avestan.json", "r") as stream:
    data = json.load(stream)

nd = node.RootNode()

for dat in data:
    nd.extend(dat, True)

with open("dist/is_avestan_unicos.h", "w") as stream:
    predicate_function_declaration.write("is_avestan_unicos", stream)

with open("dist/is_avestan_unicos.c", "w") as stream:
    predicate_function.write("is_avestan_unicos", nd, stream)

示例#30

import json
from lib import node
from lib.generator import predicate_function
from lib.generator import predicate_function_declaration

with open("json/manichaean.json", "r") as stream:
    data = json.load(stream)

nd = node.RootNode()

for dat in data:
    nd.extend(dat, True)

with open("dist/is_manichaean_unicos.h", "w") as stream:
    predicate_function_declaration.write("is_manichaean_unicos", stream)

with open("dist/is_manichaean_unicos.c", "w") as stream:
    predicate_function.write("is_manichaean_unicos", nd, stream)