Saravanan666/pypi-org huggingface dataset:
Package: clt
CLI templater (CLT)===================A simple command-line tool for convenient templates processing. For example, you have a config file for some web service and just want to put there a different host:port bindingdepending on the target server role. Using the tool, you can simply pass the missing variables using syntax like:```bashclt --tpl your_file.conf --out test.out --binding 127.0.0.1:9999```Examples--------Reads infile.tpl template and rewrites its contents to infile.out,substituting "$$$test":```bashclt --tpl infile.tpl --out file.out --delim '$$$' --test 30```Reads infile.tpl template and rewrites its contents to outdir/infile.tpl,substituting "%var1" and "%var2":```bashclt --tpl infile.tpl --out outdir --delim '%' --var1 20 --var2 hello```Reads all files from indir and rewrites them to outdir,substituting "$$$var1" and "$$$var2" ("$$$" is the default delimiter):```bashclt --tpl indir --out outdir --var1 10 --var2 50```Reads all files matching "*.tpl" and rewrites them tooutdir, substituting "$$$var1" and "$$$var2":```bashclt --tpl indir/\*.tpl --out outdir --var1 10 --var 20```Installation------------```bashpip install clt```Python versions supported------------Tested with 2.6.x and 2.7.x
Package: cltcache
cltcache -- A python3 clang-tidy cacheA simple cache which can cache clang-tidy static code analysis results to speed up the build process in large messy codebases.
cltcache is like ccache but for clang-tidy static code analysis results.UsageInstall using pippip3 install cltcachePrefix all of your clang-tidy calls with cltcache in your build system or configuration.set(CMAKE_C_CLANG_TIDY "cltcache" "${CLANG_TIDY_PROGRAM}")
set(CMAKE_CXX_CLANG_TIDY "cltcache" "${CLANG_TIDY_PROGRAM}")cmake -DCLANG_TIDY_PROGRAM="cltcache /usr/bin/clang-tidy" ..Finally you have to manually manage your cache which is stored in~/.cltcache.
If you are using cltcache in CI you need to distribute the cache between builders.
If you are using cltcache locally you will need to manually manage your cltcache because it will grow indefinately.
Here is a useful command which should remove all cache entries older than 60 days:find ~/.cltcache -mtime +60 | xargs rmFor reasonable clang-tidy usage, the cache should be so small, that you will not need to clean it until you upgrade your computer.
Check the disk usage of the cache using this command:du -hd0 ~/.cltcacheConfigurationThere are some configuration options which are loaded from ~/.cltcache/cltcache.cfg by default.
See the example configuration fileherefor more information about them.Why?Static code analysis of C++ code can consume more time and power than compilation while producing a lot smaller output files, especially when no warnings and errors were generated.
The output is also basically never consumed by a customer, which means it is not as important to ensure the correctness of the cache.
For these reasons static code analysis should be a much better match for caching than compilation is.
Because clang-tidy is probably used in tons of CI-pipelines around the world, it should be possible to save tons of energy by caching the results.How?The cache key is generated by computing a sha256-hash of the gcc preprocessor results, the enabled clang-tidy checks and the clang-tidy version string.graph LR;
    clang-tidy_args-->g++_preprocessor;
    clang-tidy_args-->clang-tidy_version;
    clang-tidy_args-->clang-tidy_enabled_checks;
    g++_preprocessor-->preprocessor_sha256;
    clang-tidy_version-->version_sha256;
    clang-tidy_enabled_checks-->enabled_checks_sha256;
    preprocessor_sha256-->sha256;
    version_sha256-->sha256;
    enabled_checks_sha256-->sha256;
    sha256-->cache_key;CaveatsCorrectnesscltcache assumes that identical preprocessor output, clang-tidy version and enabled checks will produce identical results, which is not a guarantee.
One such case is if a filtered header is moved to a path where its warnings and errors would no longer be filtered.
If you are concerned about this, you should probably reconsider your priorities.
Relying upon clang-tidy to the point where its correctness is more important than time, money and the environment, is rarely a sustainable strategy.Ouptut orderThe order of stdout and stderr is not preserved.
The stdout of clang-tidy is printed first and the stderr is printed last.
Package: cl-testlog
CompatibL Platform Integration for Test LogOverviewThis package provides CompatibL Platform integration for the Test Log library
(https://pypi.org/project/testlog/), a lightweight package for regression
testing.CopyrightEach individual contributor holds copyright over their contributions to the
project. The project versioning is the sole means of recording all such
contributions and copyright details. Specifying corporate affiliation or
work email along with the commit shall have no bearing on copyright ownership
and does not constitute copyright assignment to the employer. Submitting a
contribution to this project constitutes your acceptance of these terms.Because individual contributions are often changes to the existing code,
copyright notices in project files must specify The Project Contributors and
never an individual copyright holder.
Package: cl-timer
CL TimerA cubing timer for the terminalInstallation instructions and command documentation:https://lol-cubes.github.io/cl-timerpypi:https://pypi.org/project/cl-timerContributionFeel free to submit pull requests.System Requirements and DependenciesThis currently only works on macOS, though once a level of functionality on par with popular web-based timers such as cs-timer or qq-timer (the latter likely more feasible) is reached, I will consider working first on ubuntu support, and later windows.Once that aforementioned work is done on adapting this to other OSes, I will have exact instructions on how to make this work on each system.As of right now, any modern version of python3 should be good for this, but it is being developed on python3.8.0, so I may use some features that will throw syntax errors in any older versions.
Package: cltk
The Classical Language Toolkit (CLTK) is a Python library offering natural language processing (NLP) for pre-modern languages.InstallationFor the CLTK’s latest version:$pipinstallcltkFor more information, seeInstallation docsor, to install from source,Development.Pre-1.0 software remains available on thebranch v0.1.xand docs athttps://legacy.cltk.org. Install it withpip install "cltk<1.0".DocumentationDocumentation athttps://docs.cltk.org.CitationWhen using the CLTK, please citethe following publication, including the DOI:Johnson, Kyle P., Patrick J. Burns, John Stewart, Todd Cook, Clément Besnier, and William J. B.  Mattingly. “The Classical Language Toolkit: An NLP Framework for Pre-Modern Languages.” InProceedings of the 59th Annual Meeting of the Association for Computational Linguistics and the 11th International Joint Conference on Natural Language Processing: System Demonstrations, pp. 20-29. 2021. 10.18653/v1/2021.acl-demo.3The complete BibTeX entry:@inproceedings{johnson-etal-2021-classical,title="The {C}lassical {L}anguage {T}oolkit: {A}n {NLP} Framework for Pre-Modern Languages",author="Johnson, Kyle P.  and
      Burns, Patrick J.  and
      Stewart, John  and
      Cook, Todd  and
      Besnier, Cl{\'e}ment  and
      Mattingly, William J. B.",booktitle="Proceedings of the 59th Annual Meeting of the Association for Computational Linguistics and the 11th International Joint Conference on Natural Language Processing: System Demonstrations",month=aug,year="2021",address="Online",publisher="Association for Computational Linguistics",url="https://aclanthology.org/2021.acl-demo.3",doi="10.18653/v1/2021.acl-demo.3",pages="20--29",abstract="This paper announces version 1.0 of the Classical Language Toolkit (CLTK), an NLP framework for pre-modern languages. The vast majority of NLP, its algorithms and software, is created with assumptions particular to living languages, thus neglecting certain important characteristics of largely non-spoken historical languages. Further, scholars of pre-modern languages often have different goals than those of living-language researchers. To fill this void, the CLTK adapts ideas from several leading NLP frameworks to create a novel software architecture that satisfies the unique needs of pre-modern languages and their researchers. Its centerpiece is a modular processing pipeline that balances the competing demands of algorithmic diversity with pre-configured defaults. The CLTK currently provides pipelines, including models, for almost 20 languages.",}LicenseCopyright (c) 2014-2023 Kyle P. Johnson under theMIT License.
Package: cltl.backend
cltl-backendBackend services for the Leolani platform.This repository is a component of theLeolani framework.
For usage of the component within the framework see the instructions there.Backend ArchitectureBackend layerThe Backend Container connects to the backend server to retrieve raw signals and processes them to
make them available in the application. This involves:Managing access to the signal resources (e.g. mute mic while speaking).Store raw signal data.Publish events for the incoming signals, pointing to the storage location where the raw data can be retrieved.Subscribe to events that result in outgoing signals and send them to the backend server.Backend ServerThe application is composed of the following components:
The Backend Server is a standalone application that provides a REST API with the basic raw signals.StorageThe Backend stores the signal data separately and provides access to the stored
signals over a REST API.ContributingContributions are what make the open source community such an amazing place to be learn, inspire, and create. Any contributions you make aregreatly appreciated.Fork the ProjectCreate your Feature Branch (git checkout -b feature/AmazingFeature)Commit your Changes (git commit -m 'Add some AmazingFeature')Push to the Branch (git push origin feature/AmazingFeature)Open a Pull RequestLicenseDistributed under the MIT License. SeeLICENSEfor more information.AuthorsTaewoon KimThomas BaierSelene Báez SantamaríaPiek Vossen
Package: cltl.brain
cltl-knowledgerepresentationA knowledge representation service (aka Leolani's Brain). This service expects structures data and outputs an RDF graph.DescriptionThis package contains the necessary functionality for creating an RDF episodic knowledge graph. It features:Representation of experiences and their contextStoring of learned facts, their mentions/references, and the perspectives expressedQuerying of the graph as a way of accessing memories created during previous experiencesTyping of incoming information through querying of external knowledge sources like DBpedia and WikidataLocation reasoning for guessing where a new experience is taking place, based on previous locationsThoughts and drives that arise from new information added to the graph. For exampleconflicts resulting from learned facts,curiosity based on knowledge gaps,generalization via shared characteristics across people or objectsTrust calculation of agents as sources of information. The trust value is based on:the number of interaction with this agent,the number of new content the agent has provided,the number of conflicting information it has providedGetting startedPrerequisitesThis repository uses Python >= 3.7Be sure to run in a virtual python environment (e.g. conda, venv, mkvirtualenv, etc.)InstallationIn the root directory of this repo runpipinstall-e.
python-c"import nltk; nltk.download('wordnet')"Additionally, you need to installGraphDB Freewith a repository namedsandbox. You
will need to launch this before running the package.UsageFor using this repository as a package for different project and on a different virtual environment, you mayinstall a published version from PyPI:pipinstallcltl.brainor, for the latest snapshot, run:pipinstallgit+git://github.com/leolani/cltl-knowledgerepresentation.git@mainThen you can import it in a python script as:import cltl.brainYou can also modify the logger level as such:importloggingfromcltl.brainimportloggerasbrain_loggerbrain_logger.setLevel(logging.ERROR)ExamplesPlease take a look at the example scripts provided to get an idea on how to run and use this package. Each example has a
comment at the top of the script describing the behaviour of the script.For these example scripts, you needA repository onGraphDB Freecalledsandbox. To run any example script you first
have to launch GraphDB, and then you can run the example script.To change your current directory to./examples/Run some examples (e.g.python carl.py)ContributingContributions are what make the open source community such an amazing place to be learn, inspire, and create. Any
contributions you make aregreatly appreciated.Fork the ProjectCreate your Feature Branch (git checkout -b feature/AmazingFeature)Commit your Changes (git commit -m 'Add some AmazingFeature')Push to the Branch (git push origin feature/AmazingFeature)Open a Pull RequestLicenseDistributed under the MIT License.
SeeLICENSEfor more information.AuthorsSelene Báez SantamaríaThomas BaierPiek Vossen
Package: cltl.entity-linking
cltl-knowledgelinkingThe Leolani instance identification package. Module for entity linking.DescriptionThis package takes in a capsule and returns it with assigned URIs for the entities and/or predicates.Getting startedPrerequisitesThis repository uses Python >= 3.7Be sure to run in a virtual python environment (e.g. conda, venv, mkvirtualenv, etc.)InstallationIn the root directory of this repo runpipinstall-e.UsageFor using this repository as a package different project and on a different virtual environment, you mayinstall a published version from PyPI:pipinstallcltl.entity_linkingor, for the latest snapshot, run:pipinstallgit+git://github.com/leolani/cltl-knowledgelinking.git@mainThen you can import it in a python script as:import cltl.entity_linkingExamplesPlease take a look at the example scripts provided to get an idea on how to run and use this package. Each example has a
comment at the top of the script describing the behaviour of the script.For these example scripts, you needTo change your current directory to ./examples/Run some examples (e.g. python label_based.py)ContributingContributions are what make the open source community such an amazing place to be learn, inspire, and create. Any
contributions you make aregreatly appreciated.Fork the ProjectCreate your Feature Branch (git checkout -b feature/AmazingFeature)Commit your Changes (git commit -m 'Add some AmazingFeature')Push to the Branch (git push origin feature/AmazingFeature)Open a Pull RequestLicenseDistributed under the MIT License. SeeLICENSEfor more information.AuthorsSelene Báez SantamaríaThomas BaierPiek Vossen
Package: cltl.reply-generation
cltl-languagegenerationThe natural language generation service (aka Leolani Reply generator) This service expects structured data and outputs
natural language.DescriptionThis package contains the functionality to transform structure data into natural language. Either by replying to
questions or phrasing thoughts.Getting startedPrerequisitesThis repository uses Python >= 3.7Be sure to run in a virtual python environment (e.g. conda, venv, mkvirtualenv, etc.)InstallationIn the root directory of this repo runpipinstall-e.
python-c"import nltk; nltk.download('wordnet')"UsageFor using this repository as a package different project and on a different virtual environment, you mayinstall a published version from PyPI:pipinstallcltl.reply_generationor, for the latest snapshot, run:pipinstallgit+git://github.com/leolani/cltl-languagegeneration.git@mainThen you can import it in a python script as:import cltl.reply_generationExamplesPlease take a look at the example scripts provided to get an idea on how to run and use this package. Each example has a
comment at the top of the script describing the behaviour of the script.For these example scripts, you needTo change your current directory to ./examples/Run some examples (e.g. python test_with_triples.py)ContributingContributions are what make the open source community such an amazing place to be learn, inspire, and create. Any
contributions you make aregreatly appreciated.Fork the ProjectCreate your Feature Branch (git checkout -b feature/AmazingFeature)Commit your Changes (git commit -m 'Add some AmazingFeature')Push to the Branch (git push origin feature/AmazingFeature)Open a Pull RequestLicenseDistributed under the MIT License. SeeLICENSEfor more information.AuthorsSelene Báez SantamaríaThomas BaierPiek VossenThomas Bellucci
Package: cltoolkit
CL ToolKitA Python Library for the Processing of Cross-Linguistic Data.By Johann-Mattis List and Robert Forkel.OverviewWhilepycldfprovides a basic Python API to access cross-linguistic data
encoded inCLDFdatasets,cltoolkitgoes one step further, turning the data into full-fledged Python objects rather than
shallow proxies for rows in a CSV file. Of course, as withpycldf's ORM package, there's a trade-off
involved, gaining convenient access and a more pythonic API at the expense of performance (in particular
memory footprint but also data load time) and write-access. But most of today's CLDF datasets (or aggregations
of these) will be processable withcltoolkiton reasonable hardware in minutes - rather than hours.The main idea behindcltoolkitis making (aggregated) CLDF data easily amenable for computation
oflinguistic featuresin a general sense (e.g. typological features, etc.). This is done byproviding the data for processing codeas Python objects,providinga frameworkthat makes feature computation
as simple as writing a Python function acting on acltoolkit.models.Languageobject.In general, aggregated CLDF Wordlists provide limited (automated) comparability across datasets (e.g. one could
compare the number of words per language in each dataset). A lot more can be done when datasets use CLDF reference
properties to link to reference catalogs, i.e.link language varietiestoGlottologlanguoids,link sensestoConcepticon concept sets,link sound segmentstoCLTS sounds.cltoolkitobjects exploit this extended comparability by distinguishing "senses" and "concepts" and "graphemes"
and "sounds" and providing convenient access to comparable subsets of objects in an aggregation
(seemodels.py).Seeexample.mdfor a walk-through of the typical workflow withcltoolkit.
Package: cltools
Set of decorators of  to create transform a class into a command-line toolImagine, you’ve got a class you want to use from the command line, without having
to explicitly parse the command line and make all the routing stuff.That’s what’scltoolsis doing by proving decorators on class and methods to make your
class runnable, and transform your method into commands.cltoolscreate command tools like git/hg/svn/apt-get/apt-cache/…, that means your
tool will have commandssimple example :Imagine, you’ve got a simple class that make tasks, and you want to make a command line tool
with that. Let’s say, it’s a calculator modulecalclib.py:#!/usr/bin/env pythonclassCalc(object):def__init__(self):passdefadd(self,value1,value2):returnvalue1+value2defmult(self,value1,value2):returnvalue1*value2Then, we will write a simple class and transform into a runnable tool:#!/usr/bin/env pythonimportsysfromcalclibimportCalcfromcltoolsimportCLRunner@CLRunner.runnable()classCalcTool(object):'''A simple command-line wrapper for calclib'''def__init__(self):self._calc=Calc()defget_two_params(self,args):iflen(args)!=2:# errorexit provided by CLRunnable parentself.errorexit("Need two values VALUE1 and VALUE2 as arguments")try:value1=int(args[0])exceptException:self.errorexit("Value [%s] should be a valid number"%(args[0],))try:value2=int(args[1])exceptException:self.errorexit("Value [%s] should be a valid number"%(args[1],))returnvalue1,value2@CLRunner.command()defadd(self,args,kwargs):'''Add two values VALUE1 and VALUE2 given as parameters'''value1,value2=self.get_two_params(args)value=self._calc.add(value1,value2)self.status("Result : [%s]"%(value,))@CLRunner.command()defmult(self,args,kwargs):'''Multiplie two values VALUE1 and VALUE2'''value1,value2=self.get_two_params(args)value=self._calc.mult(value1,value2)self.status("Result : [%s]"%(value,))@CLRunner.command()defhelp(self,args=[],kwargs={}):'''Get this help'''super().help()if__name__=='__main__':calctool=CalcTool()ifnot(calctool.run(sys.argv)):sys.exit(1)Now we can test our command line tool:$ ./calc.py
Usage: calc.py COMMAND_NAME [OPTION] [VALUES]
A simple command-line wrapper for calclib

Commands:
    add                  Add two values VALUE1 and VALUE2 given as parameters
    help                 Get this help
    mult                 Multiplie two values VALUE1 and VALUE2

Error : Need a command name$ ./calc.py add 4 17
Result : [21]$ ./calc.py add 15 66 33
Error : Need two values VALUE1 and VALUE2 as argumentsNote that the help is automatically generate based on commands declared in the class,
and the online doc attached to the class and methods.
Package: clt-py
CLT Calculation for PythonThis packages provides methodes for calculating fiber-reinforced materials.Free software: MIT licenseDocumentation:https://clt-py.readthedocs.io.FeaturesTODOCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.HistoryAll notable changes to this project will be documented in this file.The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).Unreleasedchanges:version numberlong_description_conent_type in setup.py0.0.4 (2020-01-24)changed:requirements_dev.txt to updated packadesrequirements.txtfixed:upload to pypi with API Token0.0.3 (2020-01-24)First release on PyPI.add class Material2D - base class for all materials used in this package.add class IsotropicMaterial - Material2D class for isotropic materials.add class AnisotropicMaterial - Material2D class for anisotropic materials.add class FiberReinforcedMaterialUD - Material2D class that combines two materials.add class Ply - generates defined ply/layer of Material2D.add class Laminate - combines mulitple Ply instances to composite laminate.dev setup:add .pre-commit-config.yaml - formating with blackchanged travis - addblack--checkon ‘before_script’ methodchanged requirements_dev.txtadd requirements.txtadd tests for classesfix tox python 3.8 and flake8 checkingadd flake8 ignore: E501, W503, F841update mail adressdocs:changed usage.rst - new Version update to use package0.0.2 (2020-01-22)setup of packagefirst ideas of structure
Package: cltrier_promptClassify
CLTrier PromptClassifyUsagePython Modulefromcltrier_promptClassifyimportPipeline# init pipeline objectpipeline=Pipeline({# pipeline objects'do_classification':True,'do_evaluation':True,'do_export':True,# path to export dir (only if do_export)'export_path':'./path/dir/',# dataset configuration'dataset':{# path to data file (.csv)'path':'./path/file.csv',# column containing src text'text_column':'text',# column containing gold label (only if do_evaluation)'gold_column':'gold',# (optional) batch size used during classification'batch_size':16,},# classifier configuration'classifiers':[# label for export, slug/url from hugging face hub['model_label','model_huggingface_slug'],# ...],'templates':[# {classes}, {text} are dynamically replaced during runtime['template_label','prompt_template (must include{classes}and{text})'],# ...],# list of classes to use'classes':['class_1','class_2']})# call pipeline objectpipeline()Terminal Scriptpython3-mcltrier_promptClassify./path/to/config.toml# pipeline objectsdo_classification=truedo_evaluation=truedo_export=true# path to export direxport_path='./path/dir/'# dataset configuration[dataset]# path to data file (.csv)path='./path/file.csv'# column containing src texttext_column='text'# column containing gold label (only if do_evaluation)gold_column='gold'# (optional) batch size used during classificationbatch_size=16# classifier configuration[classify]# label for export, slug/url from hugging face hubmodels=[['model_label','model_huggingface_slug'],# ...]# {classes}, {text} are dynamically replaced during runtimetemplates=[['template_label','prompt_template (must include {classes} and {text})'],]# list of classes to useclasses=['class_1','class_2']