Saravanan666/pypi-org huggingface dataset:
Package: cobacoba
Deskripsi singkat proyek Python yang luar biasa.InstalationpipinstallmecsExample Usage# import packagefrommecsimportStem# Create stemmerst=Stem.Stemmer()# stemterm="romana"st.stemming(term)print("kata Dasar : ",st.lemma)# roma'print("awalan : ",st.prefix)# Noneprint("akhiran : ",st.suffix)# naprint("nasal : ",st.nasal)# NoneDemoLive demo :https://www.demo.com
Package: cobald
Thecobaldis a lightweight framework to balance opportunistic resources:
cloud bursting, container orchestration, allocation scaling and more.
Its lightweight model for resource control and composition
makes it easy to integrate custom resources and manage them at a large scale.Getting StartedIf you want to usecobald, please refer to thedocumentation.
This provides information and examples on how to install, configure and runcobald.
It also covers how to extendcobaldwith plugins,
and how to integratecobaldinto your own infrastructure.If you want to contribute tocobald, please refer to ourgithubrepository.
Feel free to open tickets and pull requests.
Note that thecobaldrepository houses the generic components only.
There are separate repositories for the various resource backends and plugins.If you want to get in touch directly, head over to ourgitterchannel.
Package: cobald-hep-plugins
COBalD/TARDIS Plugins for High Energy PhysicsThis package collects official and third-party plugins
for theCOBalD/TARDISresource manager.How do I use these plugins?The plugins work like the basic COBalD/TARDIS components:
install the package and the plugins are automatically available
in configuration and code.The package is directly available viapipand must be installed
to the samepython3environment as COBalD/TARDIS.$python3-mpipinstallcobald-hep-pluginsConsultthe documentationon how to use individual plugins.Do I have to publish plugins here?You are free to publish and maintain plugins yourself.
All COBalD/TARDIS plugins are just regular Python packages
which set some specific metadata.Plugins in this repository are reviewed by the COBalD/TARDIS team
and maintained with similar standards as the core frameworks.How do I publish a plugin here?Before proposing a plugin, please reach out to us for advise.
This could be for example via email, chats, or just opening a ticket.To add a new plugin,head to our GitHub repositoryand open a pull request that adds your plugin.
Plugins are modules or sub-packages in thecobald_hep_pluginsfolder
that can also come with additional meta-data.
See thecobald_hep_plugins/exampleas a template.In addition to the plugin itself, you should provideunittestsin atestssubfolder, anddocumentationin adocs/pluginsfile or subfolder.
Package: cobalt
CobaltCobalt is a lightweight Python library for working withAkoma Ntosodocuments. It makes it
easy to work with Akoma Ntoso documents, metadata and FRBR URIs.It is lightweight because most operations are done on the XML document directly without intermediate objects. You still
need to understand how Akoma Ntoso works.Read thefull documentation at cobalt.readthedocs.io.QuickstartInstall using:$ pip install cobaltUse it like this:>>> from cobalt import Act
>>> act = Act()
>>> act.title = "Act 10 of 1980"
>>> act.frbr_uri = "/za/act/1980-05-03/10"
>>> act.frbr_uri.year
'1980'
>>> act.frbr_uri.date
'1980-05-03'
>>> act.frbr_uri.number
'10'
>>> act.frbr_uri.doctype
'act'
>>> print act.to_xml()
[ lots of xml ]ContributingClone the repoInstall development dependencies:pip install -e .[dev]Make your changesRun tests:nosetests && flake8 cobaltSend a pull requestReleasing a new versionRun the tests withnosetestsUpdate the version by changing the__version__variable incobalt/__init__.pyCommit your changes and push to the master branch on GitHubCreate a release in GitHub and it will automatically be pushed to PyPiLicenseCobalt is licensed under the LPGL 3.0 license.Copyright 2015-2020 AfricanLII.This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU Lesser General Public License for more details.You should have received a copy of the GNU Lesser General Public License
along with this program.  If not, seehttps://www.gnu.org/licenses/.
Package: cobalt8
cobaltAES encryption with a discord context in mind.Installation instructions:On WindowsPlease open Powershell (NOT as administrator) and run:cmd.exe \c "$(curl -fsSL https://raw.githubusercontent.com/8o-COLLECTIVE/cobalt8/development/install/install.bat)"On UnixRun:python3 -m pip install cobalt8Build instructions:python3 -m buildcreates thedist/directory, containing the wheel for cobalt8.
Package: cobamp
CoBAMPCoBAMP(Constraint-Based Analysis of Metabolic Pathways) is a Python package containing pathway analysis methods
for use with constraint-based metabolic models. The main purpose is to provide a framework that is both modular and
flexible enough to be integrated in other packages (such as cobrapy, framed or cameo) that already implement generic
data structures for metabolic models.CoBAMP depends onoptlang(https://github.com/biosustain/optlang) for solving (mixed-integer) linear programming
problems, and thus, requires a compatible solver and Python dependency installed from the following list:cplex(preferred)gurobi(no explicit indicator variables)glpk(no explicit indicator variables or solution pools)Current methods include:Elementary flux modes: K-Shortest algorithmMinimal cut sets: MCSEnumerator approachElementary flux patterns: K-Shortest algorithmDocumentationDocumentation available athttps://cobamp.readthedocs.io/Instalation from PyPI (stable releases)pip install cobampCredits and LicenseDeveloped at the Centre of Biological Engineering, University of MinhoPlease refer to this work through thispublicationby Vieira and Rocha (2019):CoBAMP: a Python framework for metabolic pathway analysis in constraint-based models,Bioinformatics, btz598Released under the GNU Public License (version 3.0).
Package: cobastem
Deskripsi singkat proyek Python yang luar biasa.InstalationpipinstallmecsExample Usage# import packagefrommecsimportStem# Create stemmerst=Stem.Stemmer()# stemterm="romana"st.stemming(term)print("lemma : ",st.lemma)# roma'print("prefix : ",st.prefix)# Noneprint("suffix : ",st.suffix)# naprint("nasal : ",st.nasal)# NoneDemoLive demo :https://www.demo.comRefrencesRachman, F. H., Ifada, N., Wahyuni, S., Ramadani, G. D., & Pawitra, A. (2022, November). ModifiedECS (mECS) Algorithm for Madurese-Indonesian Rule-Based Machine Translation. InProceedings of The 2022 International Conference of Science and Information Technology in Smart Administration (ICSINTESA)(pp. 51-56). IEEE. DOI:10.1109/ICSINTESA56431.2022.10041470Ifada, N., Rachman, F. H., Syauqy, M. W. M. A., Wahyuni, S., & Pawitra, A. (2023). MadureseSet: Madurese-Indonesian Dataset.Data in Brief, 48,109035. DOI:10.1016/j.dib.2023.109035
Package: cobaya
Author:Jesus TorradoandAntony LewisSource:Source code at GitHubDocumentation:Documentation at ReadthedocsLicence:LGPL+ bug reporting asap +arXiv’ingof publications using it (seeLICENCE.txtfor details and exceptions). The documentation is licensed under theGFDL.E-mail list:https://cosmocoffee.info/cobaya/–sign up for important bugs and release announcements!Support:For general support,CosmoCoffee; for bugs and issues, use theissue tracker.Installation:pip install cobaya--upgrade(see theinstallation instructions; in general donotclone)Cobaya(code forbayesiananalysis, and Spanish forGuinea Pig) is a framework for sampling and statistical modelling: it allows you to explore an arbitrary prior or posterior using a range of Monte Carlo samplers (including the advanced MCMC sampler fromCosmoMC, and the advanced nested samplerPolyChord). The results of the sampling can be analysed withGetDist. It supports MPI parallelization (and very soon HPC containerization with Docker/Shifter and Singularity).Its authors areJesus TorradoandAntony Lewis. Some ideas and pieces of code have been adapted from other codes (e.gCosmoMCbyAntony Lewisand contributors, andMonte Python, byJ. LesgourguesandB. Audren).Cobayahas been conceived from the beginning to be highly and effortlessly extensible: without touchingcobaya’s source code, you can define your own priors and likelihoods, create new parameters as functions of other parameters…Thoughcobayais a general purpose statistical framework, it includes interfaces to cosmologicaltheory codes(CAMBandCLASS) andlikelihoods of cosmological experiments(Planck, Bicep-Keck, SDSS… and more coming soon). Automatic installers are included for all those external modules. You can also usecobayasimply as a wrapper for cosmological models and likelihoods, and integrate it in your own sampler/pipeline.The interfaces to most cosmological likelihoods are agnostic as to which theory code is used to compute the observables, which facilitates comparison between those codes. Those interfaces are also parameter-agnostic, so using your own modified versions of theory codes and likelihoods requires no additional editing ofcobaya’s source.How to cite usIf you usecobaya, please cite its pre-print,arXiv:2005.05290, and its ASCL record,ascl:1910.019.To appropriately cite the packages (samplers, theory codes, likelihoods) that you have used, simply run the scriptcobaya-bibwith your input file(s) as argument(s), and you will getbibtexreferences and a short suggested text snippet for each module mentioned in your input file. You can find a usage examplehere.AcknowledgementsThanks toJ. LesgourguesandW. Handleyfor support on interfacingCLASSandPolyChordrespectively.Thanks too toG. Cañas Herrera,A. Finke,X. Garrido,S. Heimersheim,L. Hergt,C. Hill,P. Lemos,M.S. Madhavacheril,V. Miranda,T. Morton,M. Rashkovetskyi,J. Zunzand many others for extensive and somewhat painful testing.
Package: cobaya-utilities
A set of tools to deal with MCMC chains and a complement tocobayaandgetdist.Installing the codeThe easiest way to install the module ispipinstall[--user]cobaya-utilitiesIf you plan to made some modifications, to improve or to correct some bugs, then you need to clone
the following repositorygitclonehttps://github.com/xgarrido/cobaya_utilities.git/where/to/cloneThen you can install the code and its dependenciesviapipinstall-e[--user]/where/to/cloneRunning/testing the codeYou can test thecobaya_utilitiesmodule (assuming you havepytestinstalled) by doingpytestDocumentationRead the docs atcobaya-utilities.readthedocs.io.
Package: cobble
Cobble is a Python library that allows easy creation of data objects,
including implementations of common methods such as__eq__and__repr__.Examplesimportcobble@cobble.dataclassSong(object):name=cobble.field()artist=cobble.field()album=cobble.field(default=None)song=Song("MFEO",artist="Jack's Mannequin")print(song)# Prints "Song(name='MFEO', artist="Jack's Mannequin", album=None)"classExpression(object):pass@cobble.dataclassLiteral(Expression):value=cobble.field()@cobble.dataclassAdd(Expression):left=cobble.field()right=cobble.field()classEvaluator(cobble.visitor(Expression)):defvisit_literal(self,literal):returnliteral.valuedefvisit_add(self,add):returnself.visit(add.left)+self.visit(add.right)Evaluator().visit(Add(Literal(2),Literal(4)))# 6classExpression(object):pass@cobble.visitableclassLiteral(Expression):def__init__(self,value):self.value=value@cobble.visitableclassAdd(Expression):def__init__(self,left,right):self.left=leftself.right=rightclassEvaluator(cobble.visitor(Expression)):defvisit_literal(self,literal):returnliteral.valuedefvisit_add(self,add):returnself.visit(add.left)+self.visit(add.right)Evaluator().visit(Add(Literal(2),Literal(4)))# 6License2-Clause BSD
Package: cobbler
CobblerCobbler is a Linux installation server that allows for rapid setup of network installation environments. It glues
together and automates many associated Linux tasks so you do not have to hop between lots of various commands and
applications when rolling out new systems, and, in some cases, changing existing ones. It can help with installation,
DNS, DHCP, package updates, power management, configuration management orchestration, and much more.Read more athttps://cobbler.github.ioTo view the man-pages, install the RPM and runman cobbleror runperldoc cobbler.podfrom a source checkout.To build the RPM, runmake rpms. Developers, trymake webtestto do a localmake installthat preserves your
configuration.If you want to contribute you may find more information underCONTRIBUTING.md.The documentation can be found atReadthedocs
Package: cobblr
cobblrThis is a package for simple client-broker and client-client communications
using theZeroMQpackage for python.It is designed for M2M communications and easy passing of data between
software modules. Each client program runs asynchronously in a single
new background thread. Clients are addressed with a unique name and once
registered with a broker can request new communications.This package was built as part of theDigital Manufacturing on a Shoestring
Project.This library is in development.Please check back soon!APIfrom cobblr.cobblr import CobblrBroker
cb = CobblrBrokerCreate and start a brokerfrom cobblr.cobblr import CobblrClient
cl = CobblrClient("cl_test")Create and start a client namedcl_testcl.register()Register clientcl_testwith the running brokerfrom cobblr.cobblr import CobblrClient
cr = CobblrClient("cr_test")
cr.register()Create, start and register clientcr_testcl.request_connection("cr_test")Request a connection to clientcr_testfrom clientcl_testconnection_list = cl.get_connected()Populatesconnection_listwith names of connected clients and broker.
The broker is always namedservice.cl.send_message("cr_test",["string_1", "string_2"])Sends a message from clientcl_testto clientcr_test, consisting of two
strings.msg = ["no_msg"]
while msg == ["no_msg"]:
    msg = cr.get_messages()
print(msg)Loop to read message inbox on clientcr_test. Messages will be returned
as a list, with each entry a list of[<message number>, <from address>,  <message contents>].The inbox is cleared on reading.cr.endEnds clientcr_test.API for pub-sub to be added soonFeatures ListClient name registration at brokerSingle IP spaceMultiple IP and Network supportRequest a connection to another named clientRequest - Response messaging pattern between named clientsPublish - Subscribe messaging patternSimple state machine with task prioritisationAsynchronous background operationSmooth shutdown and restartHeartbeat for network status and awarenessBackup brokerNetwork configuration save and loadMessage encryption
Package: cobcom-talon
Welcome to talon's homepage!talonis a pure Python package that implements Tractograms As Linear
Operators in Neuroimaging.The software provides thetalonPython module, which includes all thefunctions and tools that are necessary for filtering a tractogram.
In particular, specific functions are devoted to:Transforming a tractogram into a linear operator.Solving the inverse problem associated to the filtering of a tractogram.Use GPUs to speed up these operations.The package isavailable at Pypiand can be easily installed from the command line.pipinstallcobcom-talonTalon is a free software released underMIT licenseand the
documentation is available onRead the Docs.Getting helpThe preferred way to get assistance in running code that usestalonis
through the issue system of theGitlab repositorywhere the source
code is available.
Developers and maintainers frequently check newly opened issues and will be
happy to help you.Contributing guidelinesThe development happens in thedevelbranch of theGitlab repositorywhile themasteris kept for the stable releases only.
We will consider only merge requests towards thedevelbranch.How to citeIf you publish works using talon, please cite us as follows:Matteo Frigo, Mauro Zucchelli, Rachid Deriche, Samuel Deslauriers-Gauthier.
"TALON: Tractograms As Linear Operators in Neuroimaging." CoBCoM, 2021.https://hal.archives-ouvertes.fr/hal-03116143
Package: cobhan
Cobhan FFICobhan FFI is a proof of concept system for enabling shared code to be written in Rust or Go and consumed from all major languages/platforms in a safe and effective way, using easy helper functions to manage any unsafe data marshaling.TypesSupported typesint32 - 32bit signed integerint64 - 64bit signed integerfloat64 - double precision 64bit IEEE 754 floating pointCobhan buffer - length delimited 8bit buffer (no null delimiters)utf-8 encoded stringJSONbinary dataCobhan buffer detailsCallers provide the output buffer allocation and capacityCalled functions can transparently return larger values via temporary filesModerntmpfsis entirely memory backedReturn valuesFunctions that return scalar values can return the value directlyFunctionscanuse special case and return maximum positive or maximum negative or zero values to
represent error or overflow conditionsFunctionscanallow scalar values to wrapFunctions should document their overflow / underflow behavior
Package: cobilib
SummaryWe provide a library that enables us to select a number of reference genes to
which codon usage should be optimized. Furthermore, we allow for input of a
variable amount of fitness factors: translation speed of codons, tRNA
abundance, etc.  Given these contributing fitness factors the result is
displayed as the strength of the respective fitness factors that lead to the
best resemblance between simulated and reference codon usage. In a next step,
the strengths can be tuned and a codon usage can be generated that can
afterwards be used to adapt a gene sequence with the help of classic codon
optimization tools as OPTIMIZER.ExampleIn an example workflow you might want to select a fasta file that
contains the genes you want use. You can either select them from a file
or a url. In both cases a histogram of codon usage and amino acid usage
is generated.You can then (optionally) load a list of highly expressed genes, we
support the format from the HEG database.  Visualizing the codon usage
bias for e.g. checking if the CUB as you expect can be done by plotting
various methods of dimensionality reduction.If you do not want to use all the genes you can enter a
number n. The first n genes will only be analysed.You now have to select a fitness matrix which gives the probability of
one amino acid to be represented by another one.Additionally, you can select a number of fitnessfunctions that assign
to each codon a fitness. These functions will be normalized!
If you want to perform a test run you
have to enter the parameters: alpha,beta,selection,t_i for every
testfunction. alpha and beta are parameters for the <todo> model of
codon substitution and are related to transition/transversion bias.
Input is either comma or whitespace/tab separated (or a combination of
those).You can compare the absolute codon usage and relative (normalized for
each amino acid) codon usage by plot comparison.  For optimizing the
distance you can try optimizing the first gene and again regard the
comparison to see if the algorithm works at all.In a last step you can optimize all genes you have read in. Returned
are the optimal parameters, a goodness of fit and the RSCU that you can
use for optimizing with the help of, e.g., OPTIMIZER.Authors and LicenseGPLv3
Jan-Hendrik Trösemeier,
Susanne Lipp,
Christel KampContact: name.lastname at pei.de
Package: coblack
CoBlackCoBlackis aBlack-compliant formatter/rewrapper for Python comments.Example codeBefore:defcare_for(self,favorite_plant):self.sing_a_lullaby_to(favorite_plant)# This should help them grow. Note that this comment is too long to fit on one line, given the recommended line length.favorite_plant.water(100*mL)# Prevent dehydration.After:defcare_for(self,favorite_plant):self.sing_a_lullaby_to(favorite_plant)# This should help them grow. Note that this#                                       # comment is too long to fit on one line,#                                       # given the recommended line length.favorite_plant.water(100*mL)# Prevent dehydration.The extra#'s at the beginning of each line are necessary to be Black-compliant:If they were not there, Black would pull the comments to the start of the line,
destroying the alignment, and making the code look messier.
(Compare to how thenaive wayof wrapping comments looks).Installation$ pip install coblackThis will get you the(Upgrade an existing installation ofCoBlackby adding the--upgrade/-Uflag).UsageIn your terminal:$ coblack my_file.pyThis wraps & fills out multiline comments, and passes the result throughblack.The file is edited in-place.Get info on additional options (such as eg-lto set the line length)
withcoblack -h.IDE integrationFor PyCharm, create a newExternal Tool,
as follows:Then assign a keyboard shortcut to this tool.This enables you to format your files quickly and often during coding sessions.In VS Code, you'd create a newTask, in a similar fashion.Python APIimportcoblackcoblack.format_file("path/to/my_file.py")# You can also pass a `pathlib.Path`.AppendixNaive way of wrapping commentsdefcare_for(self,favorite_plant):self.sing_a_lullaby_to(favorite_plant)# This should help them grow. Note that this# comment is too long to fit on one line, given the recommended line length.favorite_plant.water(100*mL)# Prevent dehydration.(👆 back to top of ReadMe).Other comment stylesOn own line, before code:defcare_for(self,favorite_plant):# This should help them grow. Note that this comment is too long to fit on one line,# given the recommended line length.self.sing_a_lullaby_to(favorite_plant)# Prevent dehydration.favorite_plant.water(100*mL)On own line, after code:defcare_for(self,favorite_plant):self.sing_a_lullaby_to(favorite_plant)# This should help them grow. Note that this comment is too long to fit on one line,# given the recommended line length.favorite_plant.water(100*mL)# Prevent dehydration.These styles don't needCoBlack;
a vanilla rewrapper like any of the following will do:TheWrap to Columnplugin for PyCharm;TheRewrapextension for VS Code;The "Wrap Paragraph at Ruler" command in Sublime Text (Alt-QorAlt-⌘-Q) ;Thefill-paragraphcommand in Emacs; orThegqoperator in Vim.