Saravanan666/pypi-org huggingface dataset:
Package: cold-war-zombies
Cold War ZombiesThis is a package for analyzing and comparing weapons in Cold War Zombies.Weapon stats are current through Season 6 (October 13th).A demo of the package can be found here:DemoInstallationPypi DocumentationThe package can be accessed via pip install.pip install cold-war-zombiesUsageRead the DocsClick for exampleimportzombiefromzombie.health_armourimportHealthfromzombie.processorimportDamageProfilefromzombie.analysisimportAnalyze# Input your weapon class and perk tiers.weapon_class_levels={'Launcher':'5','Special':'5','Smg':'5','Shotgun':'5','Pistol':'5','Marksman':'5','Sniper':'5','Lmg':'5','Assault':'5','Melee':'5'}perk_class_levels={'speed':'5','stamin up':'5','deadshot':'5','death_perception':'5'}# Build Core Classesdamage_profile=DamageProfile(weapon_class_levels=weapon_class_levels,perk_class_levels=perk_class_levels,max_range=100)# Set Zombie Healthzom=Health(level=60,health_cap=55,outbreak=False,multiplier=2)# Set Attachments for weaponsMP5={'Muzzle':'Agency Suppressor','Barrel':'Task Force','Body':'Ember Sighting Point','Underbarrel':'Bruiser Grip','Magazine':'Salvo Fast Mag','Handle':'Serpent Wrap','Stock':'Raider Stock'}PPSH={'Muzzle':'GRU Suppressor','Barrel':'Task Force','Body':'Ember Sighting Point','Underbarrel':'Bruiser Grip','Magazine':'VDV Fast Mag','Handle':'Serpent Wrap','Stock':'KGB Skeletal Stock'}# Returns a Dict with the specific weapon stats, adjusted for attachments.# Accuracy and Critical values (float) can be found in game at# Barracks\\Combat Record\\Zombies\\Weapon Name.gun_lst=[{'weapon':'MP5','nickname':'Temp MP5','equipped_attachments':MP5,'rarity':'common','pap':'0','accuracy':None,'critical':None},{'weapon':'PPSH','nickname':'Temp PPSH','equipped_attachments':PPSH,'rarity':'common','pap':'0','accuracy':None,'critical':None}]# Calculateanalysis=Analyze(damage_profile=damage_profile,zombie_info=zom,weapon_dic_lst=gun_lst)VisualizationsTheAnalyzeclass will return the following plots:Damage Per SecondDamage Per Max AmmoDamage Per ClipTime To KillShots To KillChangelog1.0.0 - Base package.1.0.1 - Add Classes and Viz1.0.2 - Adds Grav, Ironhide, and updates inline with season 6.1.0.3 - Adds Vargo.1.0.4 - Update dependenciesContributingPull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.Please make sure to update tests as appropriate.LicenseMIT
Package: colearn
Welcome to the Fetch.ai Collective LearningColearn is a library that enables privacy-preserving decentralized machine learning tasks on theFET network.This blockchain-mediated collective learning system enables multiple stakeholders to build a shared
machine learning model without needing to rely on a central authority.
This library is currently in development.The collective learning protocol allows learners to collaborate on training a model without requiring trust between the participants. Learners vote on updates to the model, and only updates which pass the quality threshold are accepted. This makes the system robust to attempts to interfere with the model by providing bad updates. For more details on the collective learning system seehereCurrent VersionWe have releasedv0.2.8of the Colearn Machine Learning Interface, the first version of an interface that will
allow developers to prepare for future releases.
Together with the interface we provide a simple backend for local experiments. This is the first backend with upcoming blockchain ledger based backends to follow.Future releases will use similar interfaces so that learners built with the current system will work on a different backend that integrates a distributed ledger and provides other improvements.
The current framework will then be used mainly for model development and debugging.
We invite all users to experiment with the framework, develop their own models, and provide feedback!See the most up-to-date documentation atfetchai.github.io/colearnor the documentation for the latest release atdocs.fetch.ai/colearn.InstallationCurrently we only support macos and unix systems.To use the latest stable release we recommend installing thepackage from PyPiTo install with support for Keras and Pytorch:pipinstallcolearn[all]To install with just support for Keras or Pytorch:pipinstallcolearn[keras]pipinstallcolearn[pytorch]Running the examplesExamples are available in the colearn_examples module. To run the Mnist demo in Keras or Pytorch run:python-mcolearn_examples.ml_interface.keras_mnist
python-mcolearn_examples.ml_interface.pytorch_mnistOr they can be accessed from colearn/colearn_examples by cloning the colearn repoPlease note that although all the examples are always available, which you can run will depend on your installation.
If you installed onlycolearn[keras]orcolearn[pytorch]then only their respective examples will work.For more instructions see the documentation atfetchai.github.io/colearn/installationAfter installation we recommendrunning a demo, or seeingthe examples
Package: colebrook
colebrook.pyCurrent Status:DevelopmentVersion:20190213TABLE OF CONTENTScolebrook.pyTABLE OF CONTENTSTODODISCLAIMERBACKGROUNDHOW TO USEUSE AS MODULEUSE AS STAND ALONE APPLICATIONCOLEBROOK-WHITE APPROXIMATIONSREVISION HISTORYTODOAdd further approximation functions.Add warnings for parameters outside of the range for given formula.DISCLAIMERNo guarantee of accuracy is provided, confirm results with other sources.BACKGROUNDThe Colebrook-White equation is used to solve for theDarcy Friction Factor(f) for use in the determination of friction losses in pipe and open-channel flows.The equation is expressed in terms of:ParametersDescriptionReynolds NumberA dimensionless value that describes the type of flow - As perPipe Relative RoughnessA value which describes the roughness of the pipe material compared to its inner diameter.This module implements various approximations of the function for use in pipe flow calculations.HOW TO USEUSE AS MODULEEach approximation takes the Reynolds Number and Relative Roughness as required arguments, with the number of significant figures as an optional argument, in the format offunction(reynolds, relative roughness, signficant figures)For example:importcolebrookfactor=colebrook.sjFriction(60000,0.0023)print(factor)Which outputs0.027USE AS STAND ALONE APPLICATIONThere is also limited ability to run the script from the command line. The script will run against all available functions.python colebrook.py <reynolds number> <roughness> [Optional Significant figures]$pythoncolebrook.py600000.0023Ensure values are within range of applicability for equations (specifically around transition and laminar region)!|METHOD          | VALUE  |---------------------------|sjFriction      | 0.027  ||bntFriction     | 0.0203 ||fngFriction     | 0.0267 ||akFriction      | 0.0262 ||bkcFriction     | 0.0271 ||eptFriction     | 0.0269 |DISCLAIMER: Use secondary verification. No guarantee of accuracyCOLEBROOK-WHITE APPROXIMATIONSThe following functions are available in this module. They have been adapted from the WikipediaDarcy Friction Factor Formulae Table of Approximationpage.FUNCTIONAMEAUTHORYEARVALIDITY RANGEREFsjFriction()Swamee and Jain1976Re= 5000 to 10^8 and e/D = 0.00001 - 0.05PaperbtnFriction()Bellos, Nalbantis, Tsarkris2018All Flow RegimesPaperfngFriction()Fang et al.2011R>=2300PapereptFriction()Evangelides, Papaevangelou, Tzimopoulos2010R>=2300PaperakFriction()Avci, Kargoz2009R>=2300PaperbkcFriction()Brkic2011R>=2300PaperREVISION HISTORYREVISIONDESCRIPTION20190213Initial Development Version
Package: colego
##################DESCRIPT#######################This is a very simple package that converts a text to have colors in a terminal output.
Available colors: grey, red, green, yellow, blue, purple, cyan, white.
Three methods: txtcolor(), bgcolor(), complrandom() -> all of them returns a string.Note: This package is still being worked on as the colors only works on specific terminals, one of them which is VSC’s terminal.
Note: There is a bug where you can’t use start_index and stop_index with random set to True.##################EXAMPLES#######################Two examples of a txtcolor():# Example 1:print(txtcolor(text=”Hello World!”, random=True)) # each character will have a random color# Example 2:print(txtcolor(text=”Hello World!”, color=”red”, start_index=3, stop_index=7, bold=True))Two examples of bgcolor():# Example 1:print(bgcolor(text=”Hello World!”, random=True))# Example 2:print(txtcolor(text=”Hello World!”, color=”blue”, start_index=3, stop_index=7))One example of complrandom():# Example 1:print(complrandom(text=”Hello World!”))Change Log0.0.1 (2021-12-05)First Release
Package: coleta-dadosjusbr
protoEsquema de dados em Protobuf.Gerar cÃ³digo go e pythongo install google.golang.org/protobuf/cmd/protoc-gen-go// Gerar stub na raiz.
protoc --go_out=./ --go_opt=paths=source_relative coleta.protoprotoc --go_out=./ pacote.protoprotoc --go_out=pipeline/ --go_opt=paths=source_relative --proto_path=coleta --proto_path=pipeline pipeline/pipeline.proto
Package: colette
Colette: Coffee Roulette — pair with a random person for coffeeInstallaitonRequires Python 3.9 or later installed.Open a command line and run:pip install coletteUsageCreate a file called people.csv with at least columns 'name', 'organisation',
'email', and 'active'.Each participating (or previously participating) player should be listed in
each row. The active column should contain 'true' if a player is going to
participate in new rounds.Run, from a command line in the directory of your previously created
'people.csv':colette newNote: you may need to add the path pip installed colette too to your PATH
enviroment variable.Alternativly you can run colette aspython -m coletteThis will generate a newround*.csv, with pairs chosen to minimize the number
of people paired together in the same organisation, and those previously
paired. Players are assigned a role in each round, either "organiser" or
"(coffee) buyer". The method attempts to choose pairs that allow people to swap
roles each round.If you want to mark certain pairs as desired or undesired, create an
"overrides.csv" file in the data directory, listing on each row the name of the two
players and an integer "cost" of adding this pair to the round. This will be
added to the cost of pairing if the players have previously been pair or are in
the same organisation. To prefer a pair, add a negative cost.
Package: colf
Python-ColferA strong typed version ofColferserialization/deserialization for Python.UsageFirst install with PyPipipinstallcolfThen use it to construct a Colfer Object and use it:fromcolfimportColferclassTestType(Colfer):def__init__(self):super(Colfer,self).__init__()self.declareAttribute('radius','float64')self.declareAttribute('test','bool')self.declareAttribute('inner','object')defmarshall(self,byteOutput,offset=0):offset=self.marshallFloat64(self.radius,0,byteOutput,offset)offset=self.marshallBool(self.test,1,byteOutput,offset)offset=self.marshallObject(self.inner,2,byteOutput,offset)returnoffsetdefunmarshall(self,byteInput,offset=0):self.radius,offset=self.unmarshallFloat64(0,byteInput,offset)self.test,offset=self.unmarshallBool(1,byteInput,offset)self.inner,offset=self.unmarshallObject(2,byteInput,offset)returnself,offset# Write to SomewhereexampleObject=TestType()exampleObject.radius=2.5exampleObject.test=TrueexampleObject.inner=TestType()exampleObject.inner.radius=3.0byteOutput=bytearray(30)length=exampleObject.marshall(byteOutput)print(byteOutput[:length])# Read from SomewheredeserializedObject,_=TestType().unmarshall(byteOutput[:length])print(deserializedObject,deserializedObject.inner)Running Unit Testspipinstalltox
toxCall for Testing VolunteersThe code was tested on Python 2.7, 3.6, 3.7, 3.8.This code has been tested on Little-Endian machines only. It
requires to be tested on other architectures such as PowerPC, or those
with unique floating point formats.Also, there may be chances this code may not work on some Python
version due to nuances not previously uncovered.Please volunteer to test it on as many exotic computers, OSes
and send in your patches (or) bug reports.
Package: colibri
Usage examplefrom asyncio import get_event_loop, coroutine
from colibri import Connection, BasicMessage

@coroutine
def go():
    c = Connection()
    msg = BasicMessage('test message')
    with (yield from c):
        channel = c.channel()
        with (yield from channel):
            yield from channel.exchange_declare('otherex', type='direct')
            yield from channel.queue_declare('otherqueue')
            yield from channel.queue_bind('otherqueue', 'otherex', 'route')
            yield from channel.basic_publish(msg, 'otherex', 'route')
            res = yield from channel.basic_get('otherqueue')
            print("this is the result: ", res.body)

get_event_loop().run_until_complete(go())InstallationUsing pip:$ pip install colibriFrom the source (requires virtualenv or root):$ setup.py install
Package: colibrie
ColibrieColibrie is a blazing fast tool to extract tables from PDFsWhy Colibrie?Efficient: Colibrie is faster by multiple order of magnitude than any actual existing solutionFidel visual: Colibrie can provide 1:1 HTML representation of any tables it'll findReliable: Colibri will find every valid tables without exception if the PDF is compatible with the core principle of ColibrieOutput: Each table can be export into to multiple formats, which include :Pandas Dataframe.HTML.Benchmark :Some number to compareCamelot(a popular library to extract tables from PDF) and ColibrieTables extractedTimes in secondcamelotcolibriecamelotcolibrievalidfalse positivevalidfalse positivepages countpdf file0.530.0054510101small pdf5.950.02100404011medium pdf105.000.21900621610167big pdf182.000.6900017511770269giant pdfCurrent limitationColibrie only works with text-based PDFs and not scanned documents. (As Tabulaexplains, "If you can click and drag to select text in your table in a PDF viewer, then your PDF is text-based".)For the moment Colibrie doesn't work on PDF with tables that has no structural lines (likethis oneorthis one) but it can handle a few missing lines (likethis oneorthis one)Installationusing sourcepip install poetry

git clone https://github.com/abitoun-42/colibrie.git

cd colibrie

poetry installusing pippip install colibrieUsagePDF used in example :example.pdffrom colibrie.extract_tables import extract_table

tables = extract_table('example.pdf')

for table in tables:
   print(table.to_html())
   df = table.to_df()Output :Classiﬁ cation des associations agréées de surveillancede la qualité de l’airClassiﬁ cation des bureaux d’études techniques,des cabinets d’ingénieurs-conseilset des sociétés de conseilsCatégorieÉchelonCoefﬁ cientSalaireminimalhiérarchiquePositionCoefﬁ cientSalaireminimalhiérarchique71234567891011122552682822963113273443623814014224441 307,13 €1 373,77 €1 445,53 €1 517,30 €1 594,19 €1 676,20 €1 763,34 €1 855,61 €1 953,01 €2 055,53 €2 163,17 €2 275,94 €ETAM1.1.2301 558,80 €1.2.2401 587,50 €1.3.2501 618,50 €61234567891011123103263443633844064304574855155495851 589,06 €1 671,08 €1 763,34 €1 860,74 €1 968,38 €2 081,16 €2 204,18 €2 342,58 €2 486,11 €2 639,89 €2 814,17 €2 998,71 €2.1.2751 683,75 €2.2.3101 786,70 €2.3.3551 922,60 €
Package: colibri-packaging
==Biblioteca geradora de cmpkg==This library allows the generation of Colibri Master Packages, also known as extensions CMPKG.===Main versions released ==2.2.0.1Support only for Python 3.11 or above.2.0.0.1Support removed for super “packages”;Provide errors when executables doesn’t meet certain patterns.1.0.2.0Encoding fixed.1.0.0.0Support to embed multiple database scripts sets.
Package: colicoords
DocumentationPLOS One PaperBioRxiv PaperProject GoalsColiCoords is a python project for analysis of fluorescence microscopy data from rodlike cells. The project is aimed to be an open, well documented platform where users can easily share data through compact hdf5 files and analysis pipelines in the form of Jupyter notebooks.InstallationColiCoordsis available on PyPi and Conda Forge. Currently, python >= 3.6 is required.Installation byConda.:condainstall-cconda-forgecolicoordsFor installation via PyPi a C++ compiler is required for installing the dependencymahotas. Alternatively,mahotascan be installed separately from Conda.To installColiCoordsfrom pypi:pipinstallcolicoordsAlthoughColiCoordsfeatures automated testing, there are likely to be bugs. Users are encouraged to report them via the Issues page on GitHub.Contact:jhsmit@gmail.comExamplesSeveral examples ofColiCoordsusage can be found in the examples directory.CitationIf you you useColiCoordsfor scientific publication, please cite:Smit, J. H., Li, Y., Warszawik, E. M., Herrmann, A. & Cordes, T.ColiCoords: A Python package for the analysis of bacterial fluorescence microscopy data.PLOS ONE 14, e0217524 (2019).If you use theCNNmodule please also cite:Falk, T. et al.U-Net: deep learning for cell counting, detection, and morphometry.Nat Methods 16, 67–70 (2019).
Package: colifrapy
Colifrapy is aCommand Line Framework for Python.Its aim is to provide several tools to build robust and structured command line tools very easily.Its logic is very similar to a MVC framework and is therefore easy to use.DocumentationThe full documentation of the framework can be foundthere.InstallationIt is recommanded to use colifrapy under a python virtualenv. (Use the excellent virtualenvwrapper to spare you some painful operations with classic virtualenvs).Install colifrapy with pip:pip install colifrapyIf you want to use the latest one which is still in development and hosted on github:pip install git+https://github.com/Yomguithereal/colifrapy.gitPhilosophyAs every framework, colifrapy aims at enable you to work immediately on critical and intersting parts of
your code that will tackle the problems you need to solve instead of battling with petty
things such as the console output, your settings and the arguments passed to your tool.However, colifrapy is not a tyrant and does not force you to go its way. As such, every part of colifrapy can
be used on its own and you will remain free to code the way you want to.ConceptWhen using colifrapy, your tool is called through a command line hub which acts more or less like a router which will call upon a controller using one or several models to perform the job.Your hub has therefore the task to load a yaml configuration file containing your command line arguments, name, version and other contextual settings.Once those settings are loaded, every part of your application will remain able to access critical utilities such as argv opts, settings and make use of colifrapy’s logger to ouptut nicely to the console and to log files.So, schematically colifrapy is a YAML configuration file loaded by a command line hub that will call upon a controller and other models.Every bit of colifrapy can be used as a standalone.Logger(outputs to console)Settings(deals with your yml settings)Commander(deals with argv)Cacher(saves data to file)ExamplesThe projectfuruikeyais a good example of the usage
of colifrapy since the framework was originally designed for it.DependenciespyyamlargparseLicenseColifrapy is under a MIT license.
Package: colink
CoLink Python SDKCoLink Python SDK helps both application and protocol developers access the functionalities provided bythe CoLink server.Forapplication developers, CoLink Python SDK allows them to update storage, manage computation requests, and monitor the CoLink server status.Forprotocol developers, CoLink Python SDK allows them to write CoLink Extensions that extend the functionality of CoLink to support new protocols.RequirementsPython 3.9pytestGetting startedYou can use this SDK to run protocols, update storage, developing protocol operators. Here is a tutorial for you about how to start a greetings task between two users.Set up CoLink server.
Please refer tocolinkctl, and run the command below. For the following steps, we assume you are using the default settings in colinkctl.colinkctl enable_dev_envCreate two new terminals and start protocol operator for two users separately.python3 examples/protocol_greetings.py \
  --addr http://127.0.0.1:8080  \
  --jwt $(sed -n "1,1p" ~/.colink/user_token.txt)python3 examples/protocol_greetings.py \
  --addr http://127.0.0.1:8080 \
  --jwt $(sed -n "2,2p" ~/.colink/user_token.txt)Run taskpython3 examples/user_run_task.py \
  http://127.0.0.1:8080 \
  $(cat ~/.colink/user_token.txt)Check the output in protocol operators' terminalsMore examples, for details please refer toherepython3 examples/host_import_user.pypython3 examples/host_import_user_exchange_jwt.py <address> <host_jwt> <number>python3 examples/host_import_users_and_set_registry.py <address> <host_jwt> <number>python3 examples/user_run_task.py <address> <user_jwt A> <user_jwt B> <message> # <message> is optionalpython3 examples/user_greetings_to_multiple_users.py <address> <initiator_jwt> <receiver_jwt A> <receiver_jwt B> <receiver_jwt C> ...python3 examples/auto_confirm.py <address> <user_jwt> <protocol_name>python3 examples/get_next_greeting_message.py <address> <user_jwt>python3 examples/protocol_greetings.py --addr <address> --jwt <user_jwt>python3 examples/protocol_greetings_with_init_func.py --addr <address> --jwt <user_jwt>python3 examples/protocol_test_variable_transfer.py --addr <address> --jwt <user_jwt> # start remote storage to enable this protocolpython3 examples/user_remote_storage.py <address> <user_jwt A> <user_jwt B> <message> # <message> is optionalpython3 examples/user_start_protocol_operator.py <address> <user_jwt> <protocol_name>python3 examples/user_stop_protocol_operator.py <address> <user_jwt> <instance_id>python3 examples/user_lock.py <address> <user_jwt>Running Testspip3 install colink
pip3 install pytest
bash pull-and-build-server.sh
pytest test/test_python.py
Package: colin-mico
MICO: Mutual Information and Conic Optimization for feature selectionMICOis a Python package that implements a conic optimization based feature selection method with mutual information (MI) measure. The idea behind the approach is to measure the features’relevance and redundancy using MI, and then formulate a feature selection problem as a pure-binary quadratic optimization problem, which can be heuristically solved by an efficient randomization algorithm via semidefinite programming. Optimization softwareColinis used for solving the underlying conic optimization problems.This packageimplements three methods for feature selections:MICO: Conic Optimization approachMIFS: Forward Selection approachMIBS: Backward Selection approachsupports three different MI measures:JMI: Joint Mutual InformationJMIM: Joint Mutual Information MaximisationMRMR: Max-Relevance Min-Redundancygenerates feature importance scores for all selected features.provides scikit-learn compatible APIs.InstallationDownloadColindistribution fromhttp://www.colinopt.org/downloads.phpand unpack it into a chosen directory (<CLNHOME>).
Then installColinpackage:cd<CLNHOME>/pythonpipinstall-rrequirements.txtpythonsetup.pyinstallNext, installMICOpackage dependencies:pipinstall-rrequirements.txtTo installMICOpackage, use:pythonsetup.pyinstallorpipinstallcolin-micoTo install the development version, you may use:pipinstall--upgradegit+https://github.com/jupiters1117/micoUsageThis package provides scikit-learn compatible APIs:fit(X, y)transform(X)fit_transform(X, y)ExamplesThe following example illustrates the use of the package:importpandasaspdfromsklearn.datasetsimportload_breast_cancer# Prepare data.data=load_breast_cancer()y=data.targetX=pd.DataFrame(data.data,columns=data.feature_names)# Perform feature selection.mico=MutualInformationConicOptimization(verbose=1,categorical=True)mico.fit(X,y)# Populate selected features.print("Selected features:{}".format(mico.get_support()))# Populate feature importance scores.print("Feature importance scores:{}".format(mico.feature_importances_))# Call transform() on X.X_transformed=mico.transform(X)DocumentationUser guide, examples, and API are availablehere.