Example #1
0
        public override bool acceptProp(ParsedTriple t, WiktCtx ctx)
        {
            int?trId = null;

            if (t.setRefValue <Helper>(ctx, this, predicates.dbnary_isTranslationOf, ref trId))
            {
                WiktIdManager.decodeLowByte((int)trId, out string langId, out string classUri);
                switch (classUri)
                {
                case WiktConsts.NodeTypeNames.Page: pageTransId = trId; break;

                case WiktConsts.NodeTypeNames.LexicalÈntry: entryTransId = trId; break;

                case WiktConsts.NodeTypeNames.LexicalSense: senseTransId = trId; break;
                }
                return(true);
            }
            else
            {
                return(t.setRefValue <Gloss>(ctx, this, predicates.dbnary_gloss, ref glossId) ||
                       t.setValue(ctx, this, predicates.dbnary_targetLanguage, ref trans1.targetLanguage1) ||
                       t.setValue(ctx, this, predicates.dbnary_targetLanguageCode, ref trans1.targetLanguage1) ||
                       t.setValue(ctx, this, predicates.dbnary_usage, ref trans1.usage1) ||
                       t.setValueWithLang(ctx, this, predicates.dbnary_writtenForm, ref trans1.writtenForm1, ref trans1.targetLanguage1) ||
                       base.acceptProp(t, ctx));
            }
        }
Example #2
0
    public static void parseTtlsFirstRun()
    {
        var loggerWrong = new WiktLogger();

        Parallel.ForEach(ttlFiles().Where(f => File.Exists(f.files[0])), new ParallelOptions {
            MaxDegreeOfParallelism = 4
        }, f => {
            var ctx = new WiktCtx(f.lang, WiktConsts.Namespaces, loggerWrong);
            Console.WriteLine($"{f.lang}: START");
            foreach (var fn in f.files)
            {
                VDS.LM.Parser.parse(fn, (t, c) => {
                    var pt = ParsedTriple.firstRun(ctx, t);
                    if (pt == null)
                    {
                        return;
                    }
                    var err = ctx.registerDataId(pt.objDataType, pt.subjDataId);
                    if (err != null)
                    {
                        ctx.log(null, WiktConsts.predicates.no, err + pt.subjDataId);
                    }
                });
            }
            Console.WriteLine($"{f.lang}: END");
            // save IDs to disk
            ctx.designSaveDataIds();
        });
        loggerWrong.save(LowUtilsDirs.logs + "dump-errors1");
        Console.WriteLine("Done...");
        Console.ReadKey();
    }
Example #3
0
 public override bool acceptProp(ParsedTriple t, WiktCtx ctx) =>
 t.setValue(ctx, this, predicates.ontolex_writtenRep, ref writtenRep1) ||
 t.setNymsValue(ctx, this, ref nyms1) ||
 t.setFormInfosValue(ctx, this, ref infos1) ||
 t.setRefValue <Form>(ctx, this, predicates.ontolex_canonicalForm, ref canonicalFormId) ||
 t.setRefValues <Form>(ctx, this, predicates.ontolex_otherForm, ref otherFormIdx) ||
 t.setRefValues <Sense>(ctx, this, predicates.ontolex_sense, ref senseIds) ||
 t.setUriValue(ctx, this, predicates.lexinfo_partOfSpeech, ref partOfSpeech1) ||
 t.setUriValues(ctx, this, predicates.lexinfo_partOfSpeechEx, ref partOfSpeechEx1) ||
 base.acceptProp(t, ctx);
Example #4
0
 public virtual bool acceptProp(ParsedTriple t, WiktCtx ctx)
 {
     if (t.predType == PredicateType.a)
     {
         if (this is Page)
         {
             (this as Page).title = t.subjDataId.Split(':')[1];
         }
     }
     else
     {
         ctx.log(this, t.predicate, $"PROP not accepted {t.objUri}");
     }
     return(true);
 }
Example #5
0
 public override bool acceptProp(ParsedTriple t, WiktCtx ctx) =>
 t.setRefValue <Helper>(ctx, this, predicates.dbnary_gloss, ref glossId) ||
 t.setRefValue <Entry>(ctx, this, predicates.rdf_subject, ref subjectId1) ||
 t.setRefValue <Page>(ctx, this, predicates.rdf_object, ref objectId1) ||
 t.setUriValue(ctx, this, predicates.rdf_predicate, ref predicate1) ||
 base.acceptProp(t, ctx);
Example #6
0
 public override bool acceptProp(ParsedTriple t, WiktCtx ctx) =>
 t.setRefValues <Entry>(ctx, this, predicates.dbnary_describes, ref describes) ||
 t.setNymsValue(ctx, this, ref nyms1) ||
 base.acceptProp(t, ctx);
Example #7
0
 public override bool acceptProp(ParsedTriple t, WiktCtx ctx) =>
 t.setValue(ctx, this, predicates.rdf_value, ref gloss1.value1) ||
 t.setValue(ctx, this, predicates.dbnary_senseNumber, ref gloss1.senseNumber1) ||
 t.setIntValue(ctx, this, predicates.dbnary_rank, ref gloss1.rank1) || // 14384x DUPL !!!!
 base.acceptProp(t, ctx);
Example #8
0
 public override bool acceptProp(ParsedTriple t, WiktCtx ctx) =>
 t.setValue(ctx, this, predicates.ontolex_writtenRep, ref form1.writtenRep1) ||
 t.setFormInfosValue(ctx, this, ref form1.infos1) ||
 t.setValue(ctx, this, predicates.skos_note, ref form1.note1) ||
 base.acceptProp(t, ctx);
Example #9
0
 public override bool acceptProp(ParsedTriple t, WiktCtx ctx) =>
 t.setNymsValue(ctx, this, ref nyms1) ||
 t.setValue(ctx, this, predicates.dbnary_senseNumber, ref senseNumber1) ||
 t.setValue(ctx, this, predicates.skos_definition, ref definition1) ||
 t.setValue(ctx, this, predicates.skos_example, ref example1) ||
 base.acceptProp(t, ctx);
Example #10
0
    public static void parseTtlsSecondRun()
    {
        var loggerAll    = new WiktLogger();
        var loggerWrong  = new WiktLogger();
        var dumpAllProps = new Dictionary <string, dynamic[]>();

        Parallel.ForEach(ttlFiles().Where(f => /*f.lang=="la" &&*/ File.Exists(f.files[0])), new ParallelOptions {
            MaxDegreeOfParallelism = 4
        }, f => {
            Console.WriteLine($"{f.lang}: START");
            var ctx = new WiktCtx(f.lang, WiktConsts.Namespaces, loggerWrong);
            // load IDs from disk
            ctx.designLoadDataIds();

            foreach (var fn in f.files.Where(ff => File.Exists(ff)))
            {
                // if (fn.IndexOf("en_dbnary_morpho.ttl") < 0) continue;
                VDS.LM.Parser.parse(fn, (t, c) => {
                    var pt = new ParsedTriple(ctx, t);
                    if (pt.predType == WiktConsts.PredicateType.Ignore)
                    {
                        return;
                    }
                    if (pt.subjDataId != null)
                    {
                        if (pt.objBlankId != null)
                        {
                            if (!ctx.blankValues.TryGetValue(pt.objBlankId, out string value))
                            {
                                ctx.log(null, WiktConsts.predicates.no, "blank obj" + pt.subjBlankId);
                            }
                            else
                            {
                                ctx.blankValues.Remove(pt.objBlankId); pt.objBlankId = null; pt.objValue = value;
                            }
                        }
                        var node = ctx.designGetObj(pt.subjDataId);
                        if (node != null)
                        {
                            loggerAll.add(ctx.iso1Lang, node.GetType().Name, pt.predicateUri, pt.objUri);
                            //if (pt.subjDataId == "eng:__wf_-ZSElg--_lie_to__Verb__1" && pt.predicate == predicates.olia_hasTense) {
                            //  if (pt == null) return;
                            //}
                            node.acceptProp(pt, ctx);
                        }
                    }
                    else if (pt.subjBlankId != null)
                    {
                        if (pt.objValue == null)
                        {
                            ctx.log(null, WiktConsts.predicates.no, "blank subj" + pt.subjBlankId);
                        }
                        ctx.blankValues[pt.subjBlankId] = pt.objValue;
                    }
                });
                if (ctx.blankValues.Count > 0)
                {
                    Console.WriteLine($"{f.lang} blank {ctx.blankValues.First().Key}");
                }
            }
            // finish objects
            ctx.designFinish();

            // save objects to disk
            ctx.designSaveData();
            Console.WriteLine($"{f.lang}: END");
        });

        loggerWrong.save(LowUtilsDirs.logs + "dump-errors2");
        loggerAll.save(LowUtilsDirs.logs + "dump-all");

        Console.WriteLine("Done...");
        Console.ReadKey();
    }