Saravanan666/pypi-org huggingface dataset:
Package: clld-markdown-plugin
clld-markdown-pluginRender CLDF markdown in clld appsUsageInclude (and configure the plugin) in your app'smainfunction:defmain(global_config,**settings):settings['clld_markdown_plugin']={'model_map':{'ValueTable':common.ValueSet},'function_map':{}}config=Configurator(settings=settings)config.include('clld.web.app')...config.include('clld_markdown_plugin')Then you can useclld_markdown_plugin.markupas follows in your templates:<%! from clld_markdown_plugin import markdown %>

${markdown(req, '[x](LanguageTable#cldf:abad1241)')|n}Renderer callablesTherenderer_mapconfiguration option forclld_markdown_pluginaccepts adictmapping
CLDF component names to Python callables with the following signature:importclld.web.appdefrenderer(req:clld.web.app.ClldRequest,objid:str,table,session:clld.db.meta.DBSession,ids=None)->str:"""The returned `str` is interpreted as Markdown, so it may also include HTML."""
Package: clld-morphology-plugin
clld-morphology-pluginA plugin for modelling morphology in CLLD apps.ModelsThemodelslargely reflect the structure of the morphological components of thecldf-lddcollection.The basic mechanism of segmentation is implemented such thatWordforms andStems have a list columnpartscontaining the segmentation.
These parts are referenced via indices byWordformParts,StemParts, andWordformStems, so these entities "know" their constituents.
XPartscan in turn be referenced byInflections, meaning thatInflectionalValues (which belong toInflectionalCategories) are associated with part of a wordform.
Wordform structure and inflectional information is rendered as follows:Morphemedetail view withMorphs, inflectional values, and wordforms/corpus tokens:If aWordformPartis not associated with aMorph, this is interpreted as zero marking (usually for inflection):Morphophonological change is modeled byMorphoPhonoInstances connectingMorphoPhonologicalChanges with one or more of the following things: anInflection, aWordformPart, or aStemPart:SinceInflectionalValues are connected viaInflections toWordformParts, their exponents can be easily visualized:Stemscan have aLexeme, andWordformParts +Wordforms+InflectionalValue+InflectionalCategorycontain all the necessary information to automatically generate inflectional paradigms for lexemes:Derivations connectStemswith otherStems (orMorphs, when derived from a root) andDerivationalProcesses.
These derivational links can then be used to render the "derivational lineage" of a stem:Detail views of stems also show all derived (directly or indirectly) stems:DerivationalProcesses know what stems they create (optionally using specific morphs):MarkdownSince this plugin is primarily being developed for aninteractive digital corpus-based grammar, comments on models are rendered using markdown.
However, it is up to the app developer to choose what markdown you want to use; the templates here assume that the parent mako template provides a functionmarkdown(request, content).
If you want to use theclld-markdown-plugin, use the following code in your top-level.mako:<%def name="markdown(request, content)">
    <%from clld_markdown_plugin import markdown%>
    ${markdown(request, content)|n}
</%def>to use plain markdown instead:<%def name="markdown(request, content)">
    <%from markdown import Markdown%>
    ${Markdown(content)|n}
</%def>
Package: clldmpg
clldmpgPython library providing common functionality for CLLD apps maintained in affiliation
with the MPG.Provides an MPG specific pyramid app scaffold and a pyramid package to be included by
a clld app.Note: Thetemplatesdirectory provided by this package must be specified in an app'sappconf.iniin the correct position to make template lookup work, e.g.[mako]directories_list=concepticon:templates clldmpg:templates clld:web/templates
Package: clld-phylogeny-plugin
clld-phylogeny-pluginPlugin for theclldframework providing
support for phylogenetic trees in clld apps.This plugin includes thephylotreelibrary to render phylogenetic trees in the browser.IntroductionWhile plotting cross-linguistic data on a map serves as quick visualization of the correlation between the data and geography, plotting the data on a phylogenetic tree allows inspection of the correlation between the data and some theory about language relatedness, embodied in the tree.Theclld-phylogeny-pluginpackage supports this kind of visualization byaddingdatabase modelsto store phylogenetic trees (and how the tree labels correspond toLanguageobjects)adding aTreecomponent, allowing simple rendering of a tree on a pageadding support for "plotting"Parameterobjects on a tree, i.e. plotting the value for a given (Parameter,Language) pair next to the language's label on the tree.UsageTODO: Seehttps://github.com/clld/grambank/commit/4101243597c3c95d21786fe8bdcf8cf060da609bfor a minimal example.To makeclld-phylogeny-pluginfunctionality available to aclldapp, it must be included in the app's configuration - typically in<app>:main:config.include('clld_phylogeny_plugin')This will add aResourcePhylogenywith corresponding routes/phylogenys- the index page listing all available phylogenies/phylogenys/<ID>- a phylogeny's details page, by default rendering the associated tree.Plotting parameters on treesTo synchronize plotting of markers for parameter values on maps and trees, theTree.get_markermethod may need to
be adjusted. This can be done by registering a derivedTreeclass asITreeutility:classMyTree(clld_phylogeny_plugin.tree.Tree):defget_marker(self,valueset):# compute marker shape and color from valuesetreturnshape,color....config.registry.registerUtility(MyTree,ITree)
Package: clldutils
clldutilsUtilities for programmatic data curationInstallInstall from PyPI runningpipinstallclldutilsOverviewOriginally,clldutilsstarted out as a library for functionality often used inclldweb apps. Over time, it turned into a toolbox for various data curation tasks, with a focus on cross-linguistic
data (as reflected by modules such asclldutils.iso_639_3orclldutils.sfm).Design goals arewide applicability of the included functionalitysmall number of dependencies, thus wide installabilityAPIDocumentation of the package is athttps://clldutils.readthedocs.io/en/latest/index.html
Package: cllist
cllist is an extension module for CPython providing basic linked list
data structures.Collections implemented in the llist module perform well in problems
which rely on fast insertions, pops, and removal of elements in
the middle of a sequence.For this kind of workload, they can be significantly faster than
collections.deque or standard Python lists.This project was forked fromhttps://github.com/ajakubek/python-llistand adds many features and enhancements to the original, under a new name “cllist”.The cllist version now lives athttps://github.com/kata198/python-cllistIf you were using the previous module, you can change to this new module, it is completely backwards (but not forwards) compatible.Single Linked ListSingly linked lists are provided by the “sllist” module. This is your basic single-linked list, and might be useful for some scenarios.A single linked list is far less efficient at everything than the double-linked list implementation.Double Linked ListA double-linked list is provided by the “dllist” module.This provides great performance when doing pops and insertions at random (in the middle), or at either end.This implementation has been enhanced by implementing a “middle” marker.This “middle” marker is used when the list size exceeds 10 elements, and is used in all operations which involve walking the list,which ensures that AT MOST N/4 elements will need to be walked (so the shortest distance from either start, middle, or end is calculated, and walked from there).This additional feature makes this linked list much more efficient on larger data sets than a standard double-linked list implementation.Why use a linked list?A linked list should be used when you are going to be adding or removing elements in the middle of the dataset. A standard python list forces the entire list
to be reallocated and copied when such happens, whereas this can do so without reallocating.DocumentationDocumentation can be found at:https://pythonhosted.org/cllist/
Package: cLLM-python
cLLMcLLM is an Open-source library that usellama-cpp-pythonandllama.cppand provide a Low and High level API and allow developer to be
more pythonic.Features 🔮C++ Llama.cpp GGML Framework: The program is built using the C++ language and utilizes the Llama.cpp framework for
efficient performance.EasyDeL Platform: if you use the provided open-source models The models have been trained using the EasyDeL
platform,
ensuring high-quality and accurate
assistance.Customized Models: Users can access models customized for their specific needs, such as coding assistance, grammar
correction, and more.OpenAI API: The structure of APIs that will be provided in upcoming version will be OpenAI API like.Installation with Specific Hardware Acceleration (BLAS, CUDA, Metal, etc.)[!TIP]
The default behavior forllama.cppinstallation is to build for CPU only on Linux and Windows and to use
Metal on
macOS. However,llama.cppsupports various hardware acceleration backends such as OpenBLAS, cuBLAS, CLBlast,
HIPBLAS,
and Metal.To install with a specific hardware acceleration backend, you can set theCMAKE_ARGSenvironment variable before
installing. Here are the instructions for different backends:Buildings for OpenBLASCMAKE_ARGS="-DLLAMA_BLAS=ON -DLLAMA_BLAS_VENDOR=OpenBLAS"pipinstallcLLM-pythonBuildings for cuBLASCMAKE_ARGS="-DLLAMA_CUBLAS=on"pipinstallcLLM-pythonBuildings for MetalCMAKE_ARGS="-DLLAMA_METAL=on"pipinstallcLLM-pythonBuildings for CLBlastCMAKE_ARGS="-DLLAMA_CLBLAST=on"pipinstallcLLM-pythonBuildings for hipBLASCMAKE_ARGS="-DLLAMA_HIPBLAS=on"pipinstallcLLM-pythonYou can set theCMAKE_ARGSenvironment variable accordingly based on your specific hardware acceleration requirements
before installingllama.cpp.ContributingIf you would like to contribute to cLLM, please follow the guidelines outlined in the CONTRIBUTING.md file in the
repository.LicensecLLM is licensed under theMIT. See the LICENSE.md file
for more details.SupportFor any questions or issues, please get in touch with me aterfanzare810@gmail.com.Thank you for using cLLM! We hope it will help you have a personal computer experience.
Package: clloader-arthurdouillard
Continual Loader (CLLoader)A library for PyTorch's loading of datasets in the field of Continual LearningAka Continual Learning, Lifelong-Learning, Incremental Learning, etc.Example:fromtorch.utils.dataimportDataLoaderfromclloaderimportCLLoaderfromclloader.datasetsimportMNISTclloader=CLLoader(MNIST("my/data/path",download=True),increment=1,initial_increment=5)print(f"Number of classes:{clloader.nb_classes}.")print(f"Number of tasks:{clloader.nb_tasks}.")fortask_id,(train_dataset,test_dataset)inenumerate(clloader):train_loader=DataLoader(train_dataset)test_loader=DataLoader(test_dataset)# Do your cool stuff hereSupported ScenariosNameAcronymSupportedNew InstancesNI:x:New ClassesNC:white_check_mark:New Instances & ClassesNIC:x:Supported Datasets:Note that the task sizes are fully customizable.NameNb classesImage SizeAutomatic DownloadMNIST1028x28x1:white_check_mark:Fashion MNIST1028x28x1:white_check_mark:KMNIST1028x28x1:white_check_mark:EMNIST1028x28x1:white_check_mark:QMNIST1028x28x1:white_check_mark:MNIST Fellowship3028x28x1:white_check_mark:CIFAR101032x32x3:white_check_mark:CIFAR10010032x32x3:white_check_mark:CIFAR Fellowship11032x32x3:white_check_mark:ImageNet100100224x224x3:x:ImageNet10001000224x224x3:x:Permuted MNIST10 + X * 10224x224x3:white_check_mark:Furthermore some "Meta"-datasets are available:InMemoryDataset: for in-memory numpy arrayPyTorchDataset: for any dataset defined in torchvisionImageFolderDataset: for datasets having a tree-like structure, with one folder per classFellowship: to combine several datasetsSample ImagesMNIST:Task 0Task 1Task 2Task 3Task 4FashionMNIST:Task 0Task 1Task 2Task 3Task 4CIFAR10:Task 0Task 1Task 2Task 3Task 4MNIST Fellowship (MNIST + FashionMNIST + KMNIST):Task 0Task 1Task 2PermutedMNIST:Task 0Task 1Task 2Task 3Task 4
Package: clmgr
A cli tool for easy management of copyright and licenses in source code headers.InstallationpipinstallclmgrFeaturesCurrent supported languagesC#JavaPythonTypeScriptTestingThis project usespytestto run tests, if docstring examples are provided or
included these will be included automatically.Install test dependencies.pipinstall-rrequirements_dev.txtRun tests.pytestDevelopmentThis project usesblackto format code andflake8for linting. To ensure
these actions are runpre-commitis used. A git alias is provided which
will configure the entire environment.Configure environment.gitconfiginclude.path../.gitaliasesgitsetupInstall dev dependencies.pipinstall-rrequirements_dev.txtInstall for developmentpipinstall-e.Format Codepython-mblackclmgr/**Release (Manual)The following action describe the manual release process.Install dev dependencies.pipinstall-rrequirements_dev.txtClean.gitclean-xfdBuild.pythonsetup.pysdistbdist_wheelVerify.twinecheckdist/*Upload.twineuploaddist/*ReleaseReleases are published automatically when a tag is pushed to GitHub.# Set next version numberexportRELEASE=x.x.x# Create tagsgitcommit--allow-empty-m"build: release${RELEASE}"gittag-a${RELEASE}-m"build: release${RELEASE}"# Push - Assume that we are working from a forkgitpushupstream--tags
Package: clname
clnameusage: clname [OPTION]... FILE...

Clean the name(s) of the FILE(s) to make them shell-friendly
(i.e., get rid of characters for which escape characters `\` are necessary.)

optional arguments:
  -h, --help         show this help message and exit
  -e, --extension    also clean the file extension
  -f, --force        do not prompt before overwriting files
  -L, --dereference  follow symbolic links
  -i, --interactive  prompt before renaming 
  -r, --recursive    rename subdirectories and their contents recursively
  -s, --simulate     show what would be done without renaming anything
  -v, --verbose      explain what is being done
  --version          show copyright and version info and exitExample$ ls
'[2021-07-07] - this is a  test    .txt'
$ clname \[2021-07-07\]\ -\ this\ is\ a\ \ test\ \ \ \ .txt
$ ls
2021-07-07_-_this_is_a_test.txtRequirementsPython 3clname is written for GNU/Linux distributions.Installationpip install clname
Package: clnews
Command Line NewsA command line rss news feed reader.Version0.4.0Installationpip install clnewsConfigurationAll you need to do is to add your RSS urls into theconfig.pyunder theCHANNELSdictionary as following:"nbc": {
    "name": "NBC",
    "url": "http://feeds.nbcnews.com/feeds/topstories"
}UsageclnewsOptionsWhen the scripts starts running a command prompt will appear:news>The available commands that you can use are the following:news> .helpdisplays the help message and exitnews> .listlists all the available channelsnews> .getretrieves the news of a given channel, e.g.: .get cnnLicenseMIT
Package: cloack
cloackA Python package to truncate dates and times.ReferencesWolt Python Package CookiecutterrepoDeloreanpackageDevelopmentpoetry installpoetry run isort .orpoetry run isort . --verbosepoetry run black .orpoetry run black . --verboseAdd an entryto theCHANGELOG.mdfile and manually save it in VS Code to format itpoetry run kacl-cli verifyorpoetry run kacl-cli verify --jsonpoetry run pytestorpoetry run pytest --verboseDeploymentpoetry version patchorpoetry version minorpoetry run kacl-cli release $(poetry version --short) --modifyand manually save theCHANGELOG.mdfile in VS Code to format itNotescruft:Alternative to Cookiecuttercruft uses Cookiecutter as the template enginepytest-github-actions-annotate-failuresflake8-logging-formatPoetry:poetry --versionUpdate Poetry:poetry self updateorcurl -sSL https://install.python-poetry.org | python3 - --uninstall+curl -sSL https://install.python-poetry.org | python3 -curl -sSL https://install.python-poetry.org | python3 - --version 1.2.0Check the current configuration:poetry config --listpoetry config virtualenvs.in-project true --localpoetry config virtualenvs.in-project --unsetpoetry new cloackCheckpoetry-coreversion:poetry aboutpoetry shellpoetry publish --helppoetry run black --helppoetry run kacl-cli --helppoetry run kacl-cli add --helppoetry run kacl-cli add added 'Boilerplate to create a Python package.' --modifypoetry run kacl-cli neworpoetry run kacl-cli new | pbcopyhttps://github.com/mschmieder/python-kacl/blob/v0.2.24/kacl/document.py#L426https://python-poetry.org/docs/configuration/#local-configurationGitHub Actions:Relies-onDetect and Tag New Versionactionlint:Online:https://rhysd.github.io/actionlint/https://github.com/rhysd/actionlint/blob/main/docs/install.mdbrew install actionlint+actionlint --help+actionlint .github/workflows/*.ymloractionlint -verbose .github/workflows/*.yml
Package: cloai
CLI OpenAICLI OpenAI (cloai) is a command-line interface for interacting with the OpenAI API. It provides a set of commands to interact with various OpenAI services such as GPT, Speech-to-Text (STT), Text-to-Speech (TTS), and Image Generation.InstallationTo install cloai, you can use the following command:pipinstallcloaiUsageBefore running cloai, make sure the environment variableOPENAI_API_KEYis set to your OpenAI API key.To use the CLI, runcloai --helpin your terminal. This will display a list of available commands and their descriptions.Here is a brief overview of the main commands:cloai gpt --help: Shows the usages of the GPT command. The GPT command is used to generate text with OpenAI's GPT models. As there are several usage
options, the help command is the best way to learn how to use it.cloai dalle <prompt>: Generates images with OpenAI's DALL-E. Thepromptargument is the text prompt to generate the image from.cloai stt <filename>: Transcribes audio files with OpenAI's STT models. Thefilenameargument is the file to transcribe. It can be any format that ffmpeg supports. Use the--clipoption to clip the file if it is too large.cloai tts <text>: Generates audio files with OpenAI's Text to Speech models. Thetextargument is the text to convert to speech.Each command has additional options that can be viewed by runningcloai <command> --help.ContributingContributions are welcome! Please see thecontributing guidelinesfor more information.Licensecloai is licensed under the terms of theL-GPLv2.1 license.SupportIf you encounter any issues or have any questions, please report them on ourissues page.
Package: cloakensdk
Cloaken SDKPython SDK for cloakenresources.py contains the enpoints to use to interact with CloakenExamples:fromcloakensdk.clientimportSyncClientfromcloakensdk.resourcesimportUrlimportosserver=os.environ["SERVER_URL"]username=os.environ["USERNAME"]password=os.environ["PASSWORD"]client=SyncClient(server_url=server,username=username,password=password)resource=Url(client)#unshorten a url#todo(aj)#create a url entry manually in the databaseresource.create(url="http://test.com",unshortened_url="http://long.com")data=resource.full_request()See ./tests/unittests.pyUnit test instructions:set environment variables:a. SERVER_URL =http://servername:port/b. USERNAMEc. PASSWORDpython tests/unittests.pyPackagingupdate version in setup.pypython setup.py sdist bdist_wheeltwine upload dist/*
Package: cloca
cloca - Global Clock Python Librarycloca is a simple Python library that provides a global clock with functionalities to increment time, read the current time, and reset the clock. It is designed to be used across multiple modules, ensuring they all share the same state.FeaturesGlobal clock with manual time incrementation.Read the current time from anywhere in your Python project.Obtain future time after a specified delay.Reset the clock to zero as needed.InstallationYou can install cloca using pip:pip install clocaUsageImporting clocafromclocaimportincrease,now,resetIncreasing TimeUse theincreasefunction to manually increment the global clock time by a specified amount.# Increase time by 5 unitsincrease(5)Reading Current TimeUse thenowfunction to get the current time from anywhere in your project.current_time=now()print(f"Current time:{current_time}")Resetting the ClockYou can reset the global clock to zero using theresetfunction.reset()ExampleHere's a simple example showcasing the usage of cloca:fromclocaimportincrease,now# Increase time by 10 unitsincrease(10)# Read the current timecurrent_time=now()print(f"Current time:{current_time}")# Reset the clock to zeroreset()# Read the time after resettingcurrent_time=now()print(f"Current time after reset:{current_time}")About the NameThe name "cloca" comes from the Latin word "clocca" (also spelled "cloca"), which means "bell." In this context, it represents a bell-like timekeeping mechanism. Just like a bell that rings to mark the passing of time, cloca acts as a global clock to manage time in Python projects.LicenseThis project is licensed under the GNU General Public License v3.0 - see theLICENSEfile for details.ContributingContributions to cloca are welcome! Feel free to open issues and submit pull requests for any bug fixes or new features.IssuesIf you encounter any problems or have questions, please feel free to open an issuehere.AcknowledgmentsThis project was inspired by the need for a simple global clock for Python projects.
Package: clockblocks
clockblocksclockblocksis a python library for controlling the flow of time, designed with musical applications in mind. In particular, it is a central component ofscamp, a Suite for Computer-Assisted Music in Python. It is described in detailin this paper.AClockacts like thread, but with the advantage that when multiple clocks are coordinated under the same master clock they remain precisely coordinated and do not experience drift. Furthermore, processing time is taken into account when "wait" is called in a given Clock. For example, the following program:importclockblocksimporttimeimportmathclock=clockblocks.Clock()start=time.time()whileTrue:print("Current time:{}".format(round(time.time()-start,4)))# do some pointless and time-consuming calculationsforiinrange(1000000):math.log((i+1)**0.7)clock.wait(2)... generates the output:Current time: 0.0Current time: 2.0001Current time: 4.0001Current time: 6.0Current time: 8.0001Current time: 10.0Whereas a traditional thread:importtimeimportmathstart=time.time()whileTrue:print("Current time:{}".format(round(time.time()-start,4)))# do some pointless and time-consuming calculationsforiinrange(1000000):math.log((i+1)**0.7)time.sleep(2)...will gradually drift because of the intensive calculations, outputting:Current time: 0.0Current time: 2.3772Current time: 4.7623Current time: 7.1397Current time: 9.5151Current time: 11.893In addition,clockblocksoffers useful musical functionality, like sudden and gradual changes of tempo. Perhaps the most exciting feature ofclockblocksis that clocks moving at different tempos can be nested within each other. In this case, each clock distorts time for those underneath it: a clock whose tempo is oscillating between slow and fast, nested within a clock that is accelerating, will generate a time stream whose tempo oscillates faster and faster.