Saravanan666/pypi-org huggingface dataset:
Package: relations-mysql
relations-mysqlModule for interacting with Relations and MySQL. It generates MySQL compatible SQL from SQL like classes in Python.This is the SQL library used by relations-pymysql, but folks may find it useful. So here's some of the main unittests so you get the general idea.importAll the classes are capitalized to prevent collisions with reserved keywords. Plus it looks like actual SQL. So you can do a full import without worries.fromrelations_mysqlimport*selectquery=SELECT("*").OPTIONS("FAST").FROM("people").WHERE(stuff__gt="things")query.generate()self.assertEqual(query.sql,"""SELECT FAST * FROM `people` WHERE `stuff`>%s""")self.assertEqual(query.args,["things"])query=SELECT("*").OPTIONS("FAST").FROM(people=SELECT("a.b.c").FROM("d.e")).WHERE(stuff__in=SELECT("f").FROM("g").WHERE(things__a__0___1____2_____3__gt=5))query.generate()self.assertEqual(query.sql,"SELECT FAST * FROM (SELECT `a`.`b`.`c` FROM `d`.`e`) ""AS `people` WHERE `stuff` IN ""(SELECT `f` FROM `g` WHERE `things`->>%s>%s)")self.assertEqual(query.args,['$.a[0][-1]."2"."-3"',5])query.GROUP_BY("fee","fie").HAVING(foe="fum").ORDER_BY("yin",yang=DESC).LIMIT(1,2)query.generate()self.assertEqual(query.sql,"SELECT FAST * FROM (SELECT `a`.`b`.`c` FROM `d`.`e`) ""AS `people` WHERE `stuff` IN ""(SELECT `f` FROM `g` WHERE `things`->>%s>%s) ""GROUP BY `fee`,`fie` HAVING `foe`=%s""ORDER BY `yin`,`yang` DESC LIMIT%sOFFSET%s")self.assertEqual(query.args,['$.a[0][-1]."2"."-3"',5,'fum',1,2])insertquery=INSERT("people").VALUES(stuff=1,things=2).VALUES(3,4)query.generate()self.assertEqual(query.sql,"INSERT INTO `people` (`stuff`,`things`) VALUES (%s,%s),(%s,%s)")self.assertEqual(query.args,[1,2,3,4])query=INSERT("people").OPTIONS("FAST")query.SELECT("stuff").FROM("things")query.generate()self.assertEqual(query.sql,"INSERT FAST INTO `people` SELECT `stuff` FROM `things`")self.assertEqual(query.args,[])query=INSERT("people").VALUES(stuff=1,things=2).VALUES(3,4)query.SELECT("stuff").FROM("things")self.assertRaisesRegex(relations_sql.SQLError,"set VALUES or SELECT but not both",query.generate)updatequery=UPDATE("people").SET(stuff="things").WHERE(things="stuff")query.OPTIONS("FAST").ORDER_BY("yin",yang=DESC).LIMIT(5)query.generate()self.assertEqual(query.sql,"""UPDATE FAST `people` SET `stuff`=%sWHERE `things`=%sORDER BY `yin`,`yang` DESC LIMIT%s""")self.assertEqual(query.args,["things","stuff",5])query.LIMIT(10)self.assertRaisesRegex(relations_sql.SQLError,"LIMIT can only be total",query.generate)deletequery=DELETE("people").WHERE(things="stuff")query.OPTIONS("FAST").ORDER_BY("yin",yang=DESC).LIMIT(5)query.generate()self.assertEqual(query.sql,"""DELETE FAST FROM `people` WHERE `things`=%sORDER BY `yin`,`yang` DESC LIMIT%s""")self.assertEqual(query.args,["stuff",5])query.LIMIT(10)self.assertRaisesRegex(relations_sql.SQLError,"LIMIT can only be total",query.generate)
Package: relations-postgresql
relations-postgresqlModule for interacting with Relations and PostgreSQL. It generates PostgreSQL compatible SQL from SQL like classes in Python.This is the SQL library used by relations-psycopg2, but folks may find it useful. So here's some of the main unittests so you get the general idea.importAll the classes are capitalized to prevent collisions with reserved keywords. Plus it looks like actual SQL. So you can do a full import without worries.fromrelations_postgresqlimport*selectquery=SELECT("*").OPTIONS("FAST").FROM("people").WHERE(stuff__gt="things")query.generate()self.assertEqual(query.sql,"""SELECT FAST * FROM "people" WHERE "stuff">%s""")self.assertEqual(query.args,["things"])query=SELECT("*").OPTIONS("FAST").FROM(people=SELECT("a.b.c").FROM("d.e")).WHERE(stuff__in=SELECT("f").FROM("g").WHERE(things__a__0___1____2_____3__gt=5))query.generate()self.assertEqual(query.sql,"""SELECT FAST * FROM (SELECT "a"."b"."c" FROM "d"."e") """"""AS "people" WHERE "stuff" IN """"""(SELECT "f" FROM "g" WHERE ("things"#>>%s)::JSONB>(%s)::JSONB)""")self.assertEqual(query.args,['{a,0,-1,"2","-3"}',"5"])query.GROUP_BY("fee","fie").HAVING(foe="fum").ORDER_BY("yin",yang=DESC).LIMIT(1,2)query.generate()self.assertEqual(query.sql,"""SELECT FAST * FROM (SELECT "a"."b"."c" FROM "d"."e") """"""AS "people" WHERE "stuff" IN """"""(SELECT "f" FROM "g" WHERE ("things"#>>%s)::JSONB>(%s)::JSONB) """"""GROUP BY "fee","fie" HAVING "foe"=%s """"""ORDER BY "yin","yang" DESC LIMIT %s OFFSET %s""")self.assertEqual(query.args,['{a,0,-1,"2","-3"}',"5",'fum',1,2])insertquery=INSERT("people").VALUES(stuff=1,things=2).VALUES(3,4)query.generate()self.assertEqual(query.sql,"""INSERT INTO "people" ("stuff","things") VALUES (%s,%s),(%s,%s)""")self.assertEqual(query.args,[1,2,3,4])query=INSERT("people").OPTIONS("FAST")query.SELECT("stuff").FROM("things")query.generate()self.assertEqual(query.sql,"""INSERT FAST INTO "people" SELECT "stuff" FROM "things\"""")self.assertEqual(query.args,[])query=INSERT("people").VALUES(stuff=1,things=2).VALUES(3,4)query.SELECT("stuff").FROM("things")self.assertRaisesRegex(relations_sql.SQLError,"set VALUES or SELECT but not both",query.generate)updatequery=UPDATE("people").SET(stuff="things").WHERE(things="stuff")query.OPTIONS("FAST").ORDER_BY("yin",yang=DESC).LIMIT(5)query.generate()self.assertEqual(query.sql,"""UPDATE FAST "people" SET "stuff"=%sWHERE "things"=%sORDER BY "yin","yang" DESC LIMIT%s""")self.assertEqual(query.args,["things","stuff",5])query.LIMIT(10)self.assertRaisesRegex(relations_sql.SQLError,"LIMIT can only be total",query.generate)deletequery=DELETE("people").WHERE(things="stuff")query.OPTIONS("FAST").ORDER_BY("yin",yang=DESC).LIMIT(5)query.generate()self.assertEqual(query.sql,"""DELETE FAST FROM "people" WHERE "things"=%sORDER BY "yin","yang" DESC LIMIT%s""")self.assertEqual(query.args,["stuff",5])query.LIMIT(10)self.assertRaisesRegex(relations_sql.SQLError,"LIMIT can only be total",query.generate)
Package: relations-sqlite
relations-sqliteModule for interacting with Relations and SQLite. It generates SQLite compatible SQL from SQL like classes in Python.This is the SQL library used by relations-sqlite3, but folks may find it useful. So here's some of the main unittests so you get the general idea.importAll the classes are capitalized to prevent collisions with reserved keywords. Plus it looks like actual SQL. So you can do a full import without worries.fromrelations_sqliteimport*selectquery=SELECT("*").OPTIONS("FAST").FROM("people").WHERE(stuff__gt="things")query.generate()self.assertEqual(query.sql,"""SELECT FAST * FROM `people` WHERE `stuff`>?""")self.assertEqual(query.args,["things"])query=SELECT("*").OPTIONS("FAST").FROM(people=SELECT("a.b.c").FROM("d.e")).WHERE(stuff__in=SELECT("f").FROM("g").WHERE(things__a__0___1____2_____3__gt=5))query.generate()self.assertEqual(query.sql,"SELECT FAST * FROM (SELECT `a`.`b`.`c` FROM `d`.`e`) ""AS `people` WHERE `stuff` IN ""(SELECT `f` FROM `g` WHERE json_extract(`things`,?)>?)")self.assertEqual(query.args,['$.a[0][-1]."2"."-3"',5])query.GROUP_BY("fee","fie").HAVING(foe="fum").ORDER_BY("yin",yang=DESC).LIMIT(1,2)query.generate()self.assertEqual(query.sql,"SELECT FAST * FROM (SELECT `a`.`b`.`c` FROM `d`.`e`) ""AS `people` WHERE `stuff` IN ""(SELECT `f` FROM `g` WHERE json_extract(`things`,?)>?) ""GROUP BY `fee`,`fie` HAVING `foe`=? ""ORDER BY `yin`,`yang` DESC LIMIT ? OFFSET ?")self.assertEqual(query.args,['$.a[0][-1]."2"."-3"',5,'fum',1,2])insertquery=INSERT("people").VALUES(stuff=1,things=2).VALUES(3,4)query.generate()self.assertEqual(query.sql,"INSERT INTO `people` (`stuff`,`things`) VALUES (?,?),(?,?)")self.assertEqual(query.args,[1,2,3,4])query=INSERT("people").OPTIONS("FAST")query.SELECT("stuff").FROM("things")query.generate()self.assertEqual(query.sql,"INSERT FAST INTO `people` SELECT `stuff` FROM `things`")self.assertEqual(query.args,[])query=INSERT("people").VALUES(stuff=1,things=2).VALUES(3,4)query.SELECT("stuff").FROM("things")self.assertRaisesRegex(relations_sql.SQLError,"set VALUES or SELECT but not both",query.generate)updatequery=UPDATE("people").SET(stuff="things").WHERE(things="stuff")query.OPTIONS("FAST").ORDER_BY("yin",yang=DESC).LIMIT(5)query.generate()self.assertEqual(query.sql,"""UPDATE FAST `people` SET `stuff`=? WHERE `things`=? ORDER BY `yin`,`yang` DESC LIMIT ?""")self.assertEqual(query.args,["things","stuff",5])query.LIMIT(10)self.assertRaisesRegex(relations_sql.SQLError,"LIMIT can only be total",query.generate)deletequery=DELETE("people").WHERE(things="stuff")query.OPTIONS("FAST").ORDER_BY("yin",yang=DESC).LIMIT(5)query.generate()self.assertEqual(query.sql,"""DELETE FAST FROM `people` WHERE `things`=? ORDER BY `yin`,`yang` DESC LIMIT ?""")self.assertEqual(query.args,["stuff",5])query.LIMIT(10)self.assertRaisesRegex(relations_sql.SQLError,"LIMIT can only be total",query.generate)
Package: relation-validator
Relationship validatorValidate ontology relationships usingUbergraphas source of truth. Relationships in this context may be subClassOf axioms between names classes (e.g. 'lymphocyte' subClassOf 'cell') or existential restrictions, (e.g. 'enterocyte' part_of some ‘intestinal epithelium’).Ubergraph is an RDF triplestore with39 OBO ontologiesmerged, precomputed OWL classification and materialised class relationship from existential property restrictions.  Validation therefore works for any directly asserted or inferred/indirect subClassOf relationship or existential restriction.Installpipinstallrelation-validatorConfigure YAML fileIn the config file, it is defined the list of relationships the validation should run on. The order is essential.The yaml file needs to have the keysrelationshipsandfilename. Check an example below:relationships:sub_class_of:rdfs:subClassOfpart_of:BFO:0000050connected_to:RO:0001025has_soma_location:RO:0002100...filename:path/to/filename.csvThe filename should have the following columns:sslabeluser_slabeloolabeluser_olabelthe subject term IDthe label of the term in the column soptional label for the term given by userthe object term IDthe label of the term in the column soptional label for the term given by userRun relation-validator CLIrelation-validatorvalidate--inputpath/to/config.yaml--outputpath/to/output.csvTheoutput.csvfile will be in the same format as thefilename.csv. It will return the cases where a triple (subject, relationship, object) with the relationships listed in the yaml file was not found in Ubergraph.List of ontologies availableTo know which ontologies and their version are available in Ubergraph, use the following CLI:relation-validatorontologies_version--outputfilename.json
Package: relative-addons-system
Relative Addons SystemThis is a special system that allows you to manage your addons in runtime.The library has caching that allows it to work fasterDefinitionsAddon- directory that containsaddon.jsonand__init__.pyaddon.jsonis ajsonfile that describes addon and must containname,author,descriptionandversion(strings)Usage examplesfrompathlibimportPathfromRelativeAddonsSystemimportRelativeAddonsSystem,Addon,AddonMeta# Init addons systemsystem=RelativeAddonsSystem(Path(__file__).parent/"addons",auto_install_requirements=True)# return list of Addon objectsaddons:list[Addon]=system.get_all_addons()iflen(addons)<1:print("No addons found")else:foraddoninaddons:# loaded meta(AddonMeta) from ADDON_DIR/addon.jsonmeta:AddonMeta=addon.metaprint("Working with",meta.name,"at",addon.path.absolute())# Check dependenciesifnotaddon.check_requirements(alert=False):print("Installing addon dependencies")# Install dependenciesinstalled:list[str]=addon.install_requirements()print("Successfully installed addon dependencies (",", ".join(installed),")")else:print("Addon dependencies already satisfied")# Get addon modulemodule=addon.module# ADDON_DIR / __init__.py module...In this example, we have listed all addons and installed their dependencies if they were not already installed.We can also disable or enable addons:frompathlibimportPathfromRelativeAddonsSystemimportRelativeAddonsSystem,Addon# Init addons systemsystem=RelativeAddonsSystem(Path(__file__).parent/"addons",auto_install_requirements=True)addons:list[Addon]=system.get_enabled_addons()# get all enabled addonsiflen(addons)>0:addon:Addon=addons[0]# first addon from listaddon.disable()# disable addon...addon.enable()# enable addonOr import and re-import the module (useful when we have updated your addon):frompathlibimportPathfromRelativeAddonsSystemimportRelativeAddonsSystem,Addon# Init addons systemsystem=RelativeAddonsSystem(Path(__file__).parent/"addons",auto_install_requirements=True)addons:list[Addon]=system.get_enabled_addons()# get all enabled addonsiflen(addons)>0:addon:Addon=addons[0]# first addon from listmodule=addon.module...# Work with module# Reimport modulemodule=addon.reload_module()...# Work with moduleWe can also change the metadata in your code:frompathlibimportPathfromRelativeAddonsSystemimportRelativeAddonsSystem,Addon,AddonMeta# Init addons systemsystem=RelativeAddonsSystem(Path(__file__).parent/"addons",auto_install_requirements=True)addons:list[Addon]=system.get_enabled_addons()# get all enabled addonsiflen(addons)>0:addon:Addon=addons[0]# first addon from listmeta:AddonMeta=addon.metameta.set("version","1.2")meta.save()Or set specific data into the addon's storage:frompathlibimportPathfromRelativeAddonsSystemimportRelativeAddonsSystem,AddonfromRelativeAddonsSystem.utilsimportStorage# Init addons systemsystem=RelativeAddonsSystem(Path(__file__).parent/"addons",auto_install_requirements=True)addons:list[Addon]=system.get_enabled_addons()# get all enabled addonsiflen(addons)>0:addon:Addon=addons[0]# first addon from list# Loaded the ADDON_DIR/ADDON_NAME-storage.json filestorage:Storage=addon.get_storage()storage.set("api_version","1.2")storage.save()
Package: relativedate
Python Package: relativedateDescrição:Biblioteca Python relacionada a datas, onde é criado um objeto "RelativeDate" que possui o atributo datetime, onde é retornado um objeto datetime.O objetivo desta biblioteca é facilitar a manipulação de datas relativas e calculos com datas, em sua primeira versão estamos trabalhando apenas com a data relativa baseado em mês, onde pode se passar o argumento de meses (positivo e negativo) e retornará a data relativa ao mês desejadoLinksDocumentação:https://jmiante.github.io/relativedateGitHub:https://github.com/jmiante/relativedatePyPI (last version):https://pypi.org/project/relativedateInstalação:pip install relativedateExemplo Utilização:from datetime import datetimefrom relativedate import RelativeDatedt = datetime(year=2023, month=5, day=7)rd = RelativeDate(dt)print(rd)rd.addMonth(-9)print(rd)RETURN:>> 2023-05-07 00:00:00>> 2022-08-07 00:00:00Doação:Ajude o Projeto a continuar, qualquer doação é bem vindaCHAVE PIX:d51024a6-4320-4cb6-9241-b0a4d165dfd2PIX Copia e Cola:LinkQRCODE PIX:Nome:Jonathas Henrique Miante -Banco:PicPay
Package: relative-dose-1d
relative_dose_1dPython package to read 1-dimensional dose profile from text file to perform subtraction and gamma analysis.DocumentationFeaturesFor gamma analysisInterpolation between pointsProfile positions does not require to be equal* The gamma analysis algorithm is limited to absolute normalization  relative to the maximum dose.For data importPTW (R) and Varian (R) data formats suported.Format specificationsData should be in a numpy array with two columns, corresponding to positions and
dose values, respectively.The package has been tested with the following examples:File in w2CAD format (used by the TPS Eclipse 16.1, from the Varian(R) company).
In the algorithm, the start of the data is identified by the words: 'STOM' or 'STOD'
Physical unit assumed to be in mm.File in mcc format (used by Verisoft 7.1.0.199 software, from PTW(R) company).
In the algorithm, the beginning of the data is identified by the word: 'BEGIN_DATA'
Physical unit assumed to be in mm.File in text format
The data must be distributed in M ​​rows by 2 columns and separated
for a blank space.
The script ask for a word to identify the beginning of the data in the text file,
a number to add to the positions, and a factor for distance dimension conversion.InstallationLinuxThe easiest method of installation is by typing in a terminal:pipinstallrelative_dose_1dWindowsPrior to installation, it is necessary to have a python package manager. If you are not familiar with Python packages, it is recommended to useANACONDA.
After ANACONDA has been installed, openAnaconda Prompt. Once inside the terminal (window with a black background), follow the indication described for Linux (previous paragraph).UsageOnce the installation is complete, open a terminal (or Anaconda Prompt in the case of Windows) and type the commandpython:pythonFinally, write:importrelative_dose_1d.GUIContributingSubmitting bugsThe easiest way to contribute is to report bugs. Submit bugs via a Github issuehere.Suggesting ideas
Ideas are always welcome (though they might not get implemented). You can submit new ideashere.ChangelogApril-2023  Versión 0.0.3relative_dose_1dis added toPyPiMay-2023 Version 0.1.0It is now possible to perform unit transformation for distance using a multiplication factor, and move the origin of the coordinate system.May-2023 Version 0.1.2New web page for documentation, followingPEP 287 – reStructuredText Docstring Formatandnapoleon extensionMay-2023 Version 0.1.3Interpolation errorsolved.Jul-2023 Version 0.1.4 - 0.1.6Two new functions,build_from_array_and_stepto add physical positions, andplotto show a GUI.New GUI_tool module.Now it is possible to change tolerance parameter for gamma evaluation.Pass rate, total and evaluated points are now displayed on the GUI.gamma_1d function returns the number of evaluated points.Aug-2023 Version 0.1.7The plot function can be called outside relative_dose_1d application.
Package: relativeImp
Relative Importance CalculatorIntroductionKey driver analysis is a popular and powerful tool in marketing research to quantify the relative importance of individual drivers in predicting an outcome variable. For example, marketing researchers conduct key driver analysis using customer experience survey responses to understand which aspects of the customer experience would drive the customer overall satisfaction the most.As drivers are often highly correlated with each other, typical multiple regression analysis would produce flawed indicators of driver importance. Instead, we adopt therelative weight analysisapproach which accurately partitions variance among the correlated drivers.The Relative Importance Calculator produces the raw and normalized relative importance by driver for a specified outcome variable. The sum of the raw relative importance equals R-squared (i.e. the total proportion of variation in the outcome variable that can be explained by all the drivers) and the sum of the normalized relative importance equals one.PrerequisiteTo use the Relative Importance Calculator, you need to have pandas and NumPy installed.InstallationInstall the Relative Importance Calculator fromPyPI:pip install relativeImpInput and OutputThe Relative Importance Calculator takes three mandatory input parameters and returns a pandas DataFrame:Input Parameters:df: pandas.core.frame.DataFrame
    Raw input data, e.g. survey responses

outcomeName: str
    Name of the single outcome variable, e.g. overall satisfaction scores

driverNames: list
    Names of the driver variables, e.g. satisfication drivers such as quality, ease of use etc.Output:pandas.core.frame.DataFrame with three columns:
    driver: names of the driver variables
    rawRelaImpt: the raw relative importance whose sum equals R-squared
    normRelaImpt: the normalized relative importance whose sum equals oneExample CodeimportpandasaspdfromrelativeImpimportrelativeImpdf=pd.read_excel("raw_survey_responses.xlsx")yName='Overall Satisfaction'xNames=['Response Time to the Service Call','Efficiency of Handling the Service Call','Answer/Solution Provided','Knowledge of the Service Personnel','Communication Skills of the Service Personnel','Professionalism of the Service Personnel']df_results=relativeImp(df,outcomeName=yName,driverNames=xNames)CreatorCopyright © 2019 Dan Yang
Package: relativeimport
Addrelativeimportto python##### suppose:# /lib../lib_998/lib_998_1.py# /lib../lib_998/lib_998_2.py# /lib../lib_998/lib_998_3/__init__.py# /lib../lib_999/lib_999_1/lib_999_1_1.py# /lib../lib_999/lib_999_2/lib_999_2_5.py# /lib../lib_999/lib_999_3/lib_999_3_7/__init__.py# /lib../lib_1000.py# /lib../lib_1002.py# /lib../lib_1003/__init__.py# /lib../lib_1006/lib_1006_6.py# and this scripting is in `lib_1006_6.py`####importrelativeimportlib_998_1=relativeimport(__file__,"../lib_998/lib_998_1")lib_998_2=relativeimport(__file__,"../lib_998/lib_998_2.py")lib_998_3=relativeimport(__file__,"../lib_998/lib_998_3")lib_999_1_1=relativeimport(__file__,"../lib_999/lib_999_1/lib_999_1_1")lib_999_2_5=relativeimport(__file__,"../lib_999/lib_999_1/lib_999_2_5.py")lib_999_3_7=relativeimport(__file__,"../lib_999/lib_999_3/lib_999_3_7")lib_1000=relativeimport(__file__,"../lib_1000")lib_1002=relativeimport(__file__,"../lib_1002.py")lib_1003=relativeimport(__file__,"../lib_1003")
Package: relative-include
Relative IncludePython utility that replaces C/C++#includedirectives with relative paths.  It searches for a set of include paths (typically provided by a build system) and searches for the best match and uses a relative path instead. Typically this wouldnt be required if you are using CMake, Meson, Make, etc, but if the build system does not allow to include directories paths, then you can only resort to relative includes.MotivationThe motivation of this script is that theArduinobuild system for librariesdoes nothave an easy way to add include directories.  Instead libraries developed for the Arduino platform require to use relative paths. This should not be a problem if you are developing the library only for Arduino.  However, if you want to port a 3rd party library into Arduino in can be a PITA.If the 3rd party library has a few files it is not a problem but when the number increases, adding the relative paths can take too long or requires to change the original structure of the 3rd party library. If you need to update the library, then you need to repeat this process either because you changed the library structure or the authors of the library changed the place of the headers.InstallationPip installpython-mpipinstallrelative_includeLocal installpython-msetup.pyinstallUsageRun the scriptpython -m relative_include YourCfg.jsonusage:[-h][-s][-d][-V]config_file

positionalarguments:config_fileJSONConfigfiletorunthisscript

optionalarguments:-h,--helpshowthishelpmessageandexit-sSilentoutput-dPrintdebugmessages-V,--versionshowprogram'sversionnumberandexitTo use the script, a JSON configuration file must be provided with the following informationlib_path: String Path where the C++/C project is locatedinclude_paths: string array that represents the relative path with respect tolib_pathof where the include directories are located. Typically these values are passed to the compiler via the-Iflag.include_same_dir: Boolean value that indicates wether include directives are included directly by the name of the file or must refer to the root of their directory.  By default set to true.
For example,  if filefoo.cincludesbar.h, and are located in the directoryFoo,  the include directive can either be#include "bar.h"wheninclude_same_direqualstrue#include "../Foo/bar.h"wheninclude_same_direqualsfalseThe second option might seem unnecessary, but if you have another file namedbar.hthat is included via the compiler flag-I, the incorrect header with the same name might be included. I have seen this behaviour when porting the lwIP project to the Arduino platform and is left as an option for this specific type of edge cases.out: Dictionary Settings for the output of the scriptdir: String path that indicates wheree to write the output of the script with the relative include changes.overwriteBolean value that allows to overwrrite the output directory if it already exists.silent:  Boolean value. Silences the output of the script. By default set to false.debug: Boolean value. Prints debug information from the script. By default set to false.