Saravanan666/pypi-org huggingface dataset:
Package: carpo-teacher
RequirementsJupyterLab >= 3.0InstallationOpen Jupyter LabOpen TerminalExecute this commandpipinstall--upgradecarpo_teacherClose and restart Jupyter LabConfigure to use with carpo serverTeachers/TAs need to edit theconfig.jsonfile in theExercisesfolder and update the following information:Student nameIP address of the server. The instructor should provide this information.Additional installation informationTo install specific version (e.g. 0.0.8), execute this command in Jupyter Lab's terminal:pipinstallcarpo_teacher==0.0.8To uninstall the exension, execute this command in Jupyter Lab's terminal:pipuninstallcarpo_teacherInstall the extension with Virtual environment [Optional]It is recommended that you install the carpo-teacher extension in a separate python virtual environment. This way, you can isolate the carpo modules from your global jupyterlab server.Install python virtual environmentpipinstallvirtualenvCreate directory to store your virtual environments for projectsmkdir~/my-venvscd~/my-venvsCreate virtual environment for teacher extensionvirtualenvcarpo-teacher-modeThis will create new python virtual environment namedcarpo-teacher-modeActivate the above created virtual environmentsourcecarpo-teacher-mode/bin/activateInstall jupyterlab and carpo extension in your environmentpipinstall--upgradecarpo-teacherNow launch  jupterlabjupyterlabYou will now see all the carpo functionalities when you open Notebook in your jupyter lab server in the browser.
Package: carp-python-api
CARP PYTHON CLIENT APIThe Copenhagen Center for Health Technology (CACHET) Research Platform (CARP) enables researchers to run mobile health (mHealth) studies where data is collected on participant's smartphones and wearable devices. Data is securely uploaded and managed in a hosting infrastructure managed by the Technical University of Denmark.CARP is a platform for running research studies in the health domain – also known as Digital Phenotyping. Such studies range from technical feasibility studies of novel technology to large-scale clinical studies. The platform is very versatile both in terms of support for different types of health domains, as well as in terms of technical support and configuration.CARP PYTHON CLIENT APITo support researchers using theCARP Webservices APIwith the Python programming language, we implemented aCARP PYTHON CLIENT APIto consume all existing endpoints such as authenticating, creating studies, deployments, protocols, consents, data points, documents|collections, summaries, and other endpoints.The repositoryCARP Client API - Flaskprovides a sample project that allows consumingCARP Webservices APIendpoints using theFlask framework.NoteTo use this client with any of the CARP environments listed below,contact usto create a researcher account to use the [CARP Web Services] endpoints.EnvironmentsCARP EnvironmentsPathtesthttps://cans.cachet.dk:443/testdevelopmenthttps://cans.cachet.dk:443/devstaginghttps://cans.cachet.dk:443/stageproductionhttps://cans.cachet.dk:443Local EnvironmentPathlocalhttp://localhost:8091ReferencesCopenhagen Center for Health TechnologyCACHETCARP Webpage.CANS Management Dashboard.CARP Core
Package: carp-python-api-async
CARP PYTHON CLIENT APIThe Copenhagen Center for Health Technology (CACHET) Research Platform (CARP) enables researchers to run mobile health (mHealth) studies where data is collected on participant's smartphones and wearable devices. Data is securely uploaded and managed in a hosting infrastructure managed by the Technical University of Denmark.CARP is a platform for running research studies in the health domain – also known as Digital Phenotyping. Such studies range from technical feasibility studies of novel technology to large-scale clinical studies. The platform is very versatile both in terms of support for different types of health domains, as well as in terms of technical support and configuration.CARP PYTHON CLIENT API - ASYNCTo support researchers using theCARP Webservices APIwith the Python programming language, we implemented aCARP PYTHON CLIENT API - ASYNCto consume all existing endpoints such as authenticating, creating studies, deployments, protocols, consents, data points, documents|collections, summaries, and other endpoints.NoteTo use this client with any of the CARP environments listed below,contact usto create a researcher account to use the [CARP Web Services] endpoints.EnvironmentsCARP EnvironmentsPathtesthttps://cans.cachet.dk:443/testdevelopmenthttps://cans.cachet.dk:443/devstaginghttps://cans.cachet.dk:443/stageproductionhttps://cans.cachet.dk:443Local EnvironmentPathlocalhttp://localhost:8091ReferencesCopenhagen Center for Health TechnologyCACHETCARP Webpage.CANS Management Dashboard.CARP Core
Package: car-price-regression-model
CAR PRICE PREDICTIONA machine learning program that predicts the price of cars as seen in the dataset given. This program uses asimple ensemble regressor algorithmto predict a reasonable Manufacturer suggested retail price for cars.Data set and its descriptionDataDescriptionMakeCompany or brand nameModelCar categoryYearProduction yearEngine fuel typeEngine fuel combustion typeEngine HPHorse power capability of the engineEngine cylindersNumber of cylindersTransmission typeAutomatic, manual etcDriven_wheelstype of wheel driveNumber of doorsAvailable doors attached to the carMarket_categoryTargeted audience for the carVehicle sizedimension of the carVehicle stylecar design appealHighway MPGHighway miles travelledCity MPGCity miles attainablePopularityNumeric figureMSRPManufacturers' recommended pricingDependencies and packagesnumpy>=1.20.0,<1.21.0pandas>=1.3.5,<1.4.0pydantic>=1.8.1,<1.9.0scikit-learn>=1.0.2,<1.1.0strictyaml>=1.3.2,<1.4.0ruamel.yaml==0.16.12feature-engine>=1.0.2,<1.1.0joblib>=1.0.1Source code linkSource code link:Github link
Package: carpy
Consolidated Aircraft Recipes in PythonYaseen RezaCARPy is an open source project for those interested in the methodology and
approach to the conceptual-level design of fixed-wing aircraft. This library
provides its users with access to a variety of design tools for conceptual
analysis - CARPy is designed to complement and not substitute a comprehensive
and detailed study of a vehicle concept.Source CodeJupyter NotebooksContributors GuideUsers will find:Virtual (design) atmospheresHassle-free conversions between systems of unitsConstraint Analysis Methods[WorkInProgress]Propulsion models and Engine Performance Decks...and much more[WorkInProgress]For a detailed description of the library, please consult the documentation. To
get started, follow the instructions below.Continuous Integration Status(CircleCI):✔️ Getting StartedInstallationcarpyis written for (and tested in) Python version 3.9.5.On most systems you should be able to simply open an operating system terminal
and at the command prompt type$ pip install carpyor$ python -m pip install carpyNOTE:pipis a Python package; if it is not available on your system, downloadget-pip.pyand run it in Python by
entering$ python get-pip.pyat the operating system prompt.If you already have a version of carpy installed and are simply trying to
upgrade, use the--upgradeflag:$ pip install --upgrade carpyAn alternative approach to installing carpy is to clone the GitHub repository
usinggit, by typing$ git clone https://github.com/yaseen157/carpy.gitat the command prompt. Following a successful clone of files to your machine,
navigate to the library root (this contains the filepyproject.toml). At this
point, you may enter the following:$ python -m pip install ./Alternatively, adventurous users who want an editable install to make any
customisations in their local build should use the--editableflag:$ python -m pip install -e ./Should you find that your installation requires packages you do not have in your
current Python environment, install them by typing this in the same prompt:$ python -m pip install -r requirements.txtA 'Hello world' example: Atmospheric propertiesThere are several options for running the examples shown here: you could copy
and paste them into a.pyfile, save it and run it in Python, or you could
enter the lines, in sequence, at the prompt of a Python terminal. You could also
copy and paste them into a Jupyter notebook
(.ipynbfile) cell and execute the cell."""'Hello World' example to introduce users to CARPy atmospheres."""fromcarpy.environmentimportISA1975fromcarpy.utilityimportQuantity# Instantiate an atmosphere object:# International Standard Atmosphere with a +10C offsetatm=ISA1975(T_offset=10)# Query the ambient density in this model at 41,000 feet# noinspection PyTypeCheckerprint(f"{atm}density at 41,000 feet:",atm.rho(altitude=Quantity(41_000,"ft")))You should see the following output:ISA1975(+10°C) density at 41,000 feet: 0.28740209 kg m⁻³You can learn more aboutCARPy's capabilities through the exemplarynotebooks.🐍 AcknowledgementsThe library was authored by:Yaseen Reza
Package: carpyncho
Carpyncho client for PythonPython client for Carpyncho VVV dataset collection.This library access as aPandas DataFrameall the data of the web version of
Carpynchohttps://carpyncho.github.io/.CodeThe entire source code of is hosted in GitHubhttps://github.com/carpyncho/carpyncho-py/LicenseCarpyncho is underThe BSD-3 LicenseThe BSD 3-clause license allows you almost unlimited freedom with the software so long as you include the BSD copyright and license notice in it (found in Fulltext).CitationIf you use Carpyncho in a scientific publication, we would appreciate
citations to the following paper:Cabral, J. B., Ramos, F., Gurovich, S., & Granitto, P. (2020).
Automatic Catalog of RRLyrae from ∼ 14 million VVV Light Curves:
How far can we go with traditional machine-learning?https://arxiv.org/abs/2005.00220Bibtex entry@ARTICLE{2020A&A...642A..58C,author={{Cabral}, J.~B. and {Ramos}, F. and {Gurovich}, S. and {Granitto}, P.~M.},title="{Automatic catalog of RR Lyrae from {\ensuremath{\sim}}14 million VVV light curves: How far can we go with traditional machine-learning?}",journal={\aap},keywords={methods: data analysis, methods: statistical, surveys, catalogs, stars: variables: RR Lyrae, Galaxy: bulge, Astrophysics - Instrumentation and Methods for Astrophysics, Astrophysics - Solar and Stellar Astrophysics, Computer Science - Machine Learning, Statistics - Machine Learning},year=2020,month=oct,volume={642},eid={A58},pages={A58},doi={10.1051/0004-6361/202038314},archivePrefix={arXiv},eprint={2005.00220},primaryClass={astro-ph.IM},adsurl={https://ui.adsabs.harvard.edu/abs/2020A&A...642A..58C},adsnote={Provided by the SAO/NASA Astrophysics Data System}}InstallationThis is the recommended way to install carpyncho.Installing  with pipMake sure that the Python interpreter can load carpyncho code.
The most convenient way to do this is to use virtualenv, virtualenvwrapper, and pip.After setting up and activating the virtualenv, run the following command:$pipinstallcarpyncho...That should be it all.Installing the development versionIf you’d like to be able to update your carpyncho code occasionally with the latest bug fixes and improvements, follow these instructions:Make sure that you have Git installed and that you can run its commands from a shell.
(Entergit helpat a shell prompt to test this.)Check out carpyncho main development branch like so:$gitclonehttps://github.com/carpyncho/carpyncho-py.gitcarpyncho...This will create a directorycarpynchoin your current directory.Then you can proceed to install with the commands$cdcarpyncho$pipinstall-e....DocumentationThe full documentation of the project are available inhttps://carpyncho-py.readthedocs.io/ContactFor bugs or question please contactJuan B. Cabral:jbcabral@unc.edu.ar
Package: carreralib
This module provides a Python interface to Carrera® DIGITAL 124/132
slotcar systems connected via a serial (cable) connection, or via
Bluetooth LE using Carrera AppConnect®.>>>fromcarreralibimportControlUnit>>>cu=ControlUnit('/dev/ttyUSB0')>>>cu.version()'5337'>>>cu.poll()Status(fuel=(14, 14, 14, 14, 14, 14, 0, 0), start=0, mode=6,
       pit=(False, False, False, False, False, False, False, False),
       display=8)>>>cu.start()>>>cu.poll()Status(fuel=(14, 14, 14, 14, 14, 14, 0, 0), start=1, mode=6,
       pit=(False, False, False, False, False, False, False, False),
       display=8)>>>cu.start()>>>cu.poll()Timer(address=1, timestamp=105295, sector=1)>>>cu.poll()Timer(address=0, timestamp=105410, sector=1)For demonstration purposes, thecarreralibmodule can also be used
from the command line as a simple race management system (RMS).Please refer to the onlinedocumentationfor more information.Installationcarreralib is available fromPyPIand can be installed by running:pip install carreralibProject ResourcesDocumentationIssue TrackerSource CodeChange LogLicenseCopyright (c) 2015-2023 Thomas Kemmer.Licensed under theMIT License.Carrera® and Carrera AppConnect® are registered trademarks of Carrera
Toys GmbH.carreralibis not an official Carrera® product, and is not
affiliated with or endorsed by Carrera Toys GmbH.Thanks to Stephan Heß (a.k.a.slotbaer) for doing all the hard work.
Package: carrier
Carrier: Warehouse and PyPI SynchronizationCarrier is a BSD Licensed Python application for keeping a Warehouse instance
and PyPI synchronized.Carrier utilizes the xmlrpc and pubhubsubbub API of PyPI to keep a Warehouse
instance up to date with PyPI. It can also utilize webhooks from Warehouse to
propagate changes made in Warehouse to PyPI. It enables a clean separation of
Warehouse and PyPI.Carrier is part of the Crate project, a set of applications, tools, and libraries
for creating, distributing, and installing Python packages in a secure, efficient,
and reliable way.ResourcesDocumentationBug TrackerCodeIRC(irc.freenode.net, #crate)ContributeCheck for open issues or open a new issue to start a discussion around a feature
idea or a bug.Forkthe repositoryon GitHub and create a branch off of the master branch
to make your changes too.Write a test which shows that the bug was fixed or that the feature works as expected.Send a pull request and bug the maintainer until it gets merged and published.
Package: carrier.py
carrier.pycarrier.py is a Python package/module that's used to save time when programming, it helps with functions such as 24 and 12 hour time, Discord webhooks, etc. These are all mainly things that I've been annoyed by because I keep forgetting the code and so I've just bundle it up into carrier.pyInstallationYou will need Python 3.6+# Linux/macOS
python3 -m pip install carrier.py

# Windows
py -3 -m pip install carrier.pyExampleimportcarrierimporttimewhileTrue:ifcarrier.Timecheck("22:30","HM")==True:print("It is 22:30 aka 10:30 PM.")exit()else:print("It is not 22:30 aka 10:30PM.")time.sleep(1)
Package: carrier-services
carrier-servicesGet carrier services from shipping lines.InstallationFromPyPI:python -m pip install carrier-servicesSetupThe following setup must be done before running:Install Google Chrome. Chrome version 109 or newer is required.Create below environment variables in your OS environment:CS_SMTP_HOST: SMTP host for sending notification emailsCS_CONFLUENCE_TOKEN: Token for uploading carrier service master to WikiSpecify the directory path of data files & log files in below lines ofsite-packages/carrier_services/utils/config.toml. For example:[environment]
directory.data = ""    # /home/user1/carrier_services/data"
directory.log = ""     # /home/user1/carrier_services/log"If left unchanged as empty, the defaults <user_home>/carrier_services/data & <user_home>/carrier_services/log will be used:How to Usecarrier-services is a console application, namedcarrier_services.>>> python -m carrier_services
Package: carrot-executor
Camunda external task Robot Framework execution schedulerTechnology preview.carrot-executoris an opinionated decoupled Camunda external task executor concept for orchestrating Robot Framework RPA tasks with Camunda. The concept decouples task locking and execution scheduling from bot execution.In this concept, the Carrot external task client, based oncamunda-external-task-client-js, fetches configured external tasks from Camunda, schedules their execution, and keeps the tasks locked at Camunda until their execution has been completed. Once the execution has started, all interaction with execution and Camunda is done by the executing Robot Framework bot, mostly by using dedicated Robot Framework listener and keyword library.This initial preview provides support for local parallel task execution, but the concept is designed to support also remote executors, like parameterized Nomad tasks, CI systems, Docker or even Robocloud API.Requirements:Docker with Docker Compose for CamundaPython >= 3.8 for executing Robot Framework$python--version
Python3.8.8NodeJS >= 12 for executing the external task client$ node --version
v12.21.0Trying it outWhilecarrot-executoritself can be installed from PyPI, trying out the concept requires setting up Camunda BPM Platform and having the example Robot Framework task suites.The easiest way for all this is to clone or download the project repository and starting the preconfigured Camunda with Docker Compose:$gitclonehttps://github.com/datakurre/carrot-executor
$cdcarrot-executor
$docker-composeupAfter everything is ready, there should be Camunda running athttp://localhost:8080/camundawith usernamedemoand passworddemo.By default, our Camunda container has both theirs and ours demo processes deployed. Let's get rid of their demo processes:Open Camunda Tasklist:http://localhost:8080/camunda/app/tasklist/default/ChooseStart processChooseReset Camunda to clean stateandPressStartThe started process could now be completed with the help ofcarrot-executor. For that we need to create a new Python environment with our package:$python-mvenvmy-carrot-executor
$sourcemy-carrot-executor/bin/activate
$pipinstallcarrot-executorThe executor may now be started with parameterizing it to complete tasks from the process we started:$CAMUNDA_API_BASE_URL=http://localhost:8080/engine-restROBOT_SUITE=robot/reset.robotCAMUNDA_TOPIC="Reset tasklist filters,Reset deployments"carrot-executor
polling
✓subscribedtotopicResettasklistfilters
✓subscribedtotopicResetdeployments
polling
✓polled2tasks
polling
✓polled0tasksBy default, the executor executes the task name matching with the subscribed topic name. This can be overridden with environment variableROBOT_TASK. Setting the variable empty, should execute full suite.
Package: carrot-rpc
CarrotCarrot-RPC it is a python asyncio RPC server/client for RabbitMQ that allows you to make RPC calls.Note:This project in active development and can be unstable.You can see live examples here:http://5.187.4.179:5888/(https://github.com/Sobolev5/Carrot-RPC-Example)http://89.108.77.63:1025/(https://github.com/Sobolev5/LordaeronChat)https://github.com/Sobolev5/carrot-rpcInstallTo install run:pip install carrot-rpcMicroservice A which callimportasynciofromcarrotimportCarrotCallfromsimple_printimportsprint# set amqp connection:AMQP_URI="amqp://admin:password@127.0.0.1/vhost"# defer function which call «MICROSERVICE_SUM»:asyncdefcall_sum_a_and_b():# make dict request:dct={}dct["caller"]="Function on microservice_interface which call RPC in microservice_sum"dct["number_a"]=int(data["number_a"])dct["number_b"]=int(data["number_b"])# defer carrot instance and make rpc call:carrot=awaitCarrotCall(AMQP_URI).connect()response_from_another_microservice=awaitcarrot.call(dct,"microservice_sum:sum_a_and_b",timeout=5)# first arg is dict with data# second arg it routing key (through default AMQP exchange)# third arg is optional (response timeout in seconds, 5 seconds by default)# get response dict from microservice «MICROSERVICE_SUM»sprint(f'Sum a and b:{response_from_another_microservice["sum"]}',c="yellow")# you can send request to another microservice without reply (like standart call):awaitcarrot.call(dct,"microservice_sum:sum_a_and_b",without_reply=True)# in this case «MICROSERVICE_SUM» just calculate sum and do not send response to caller.loop=asyncio.get_event_loop()loop.run_until_complete(call_sum_a_and_b())Microservice B which askimportasyncioimportaiormqfrompydanticimportBaseModelfromcarrotimportcarrot_askfromsimple_printimportsprintfromfastapiimportFastAPIfromfastapiimportAPIRouter# set amqp connection:AMQP_URI="amqp://admin:password@127.0.0.1/vhost"# make pydantic schema:classSumAAndB(BaseModel):caller:strnumber_a:intnumber_b:int# decorate called function with pydantic schema@carrot_ask(SumAAndB)asyncdefsum_a_and_b(incoming_dict:dict)->dict:sprint(incoming_dict,c="green")dct={}dct["caller"]="i am sum_a_and_b function mounted on microservice_sum"dct["sum"]=incoming_dict["number_a"]+incoming_dict["number_b"]returndct# make amqp router:asyncdefamqp_router():connection=awaitaiormq.connect(AMQP_URI)channel=awaitconnection.channel()sprint(f"AMQP:     ready [yes]",c="green")sum_a_and_b__declared=awaitchannel.queue_declare(f"microservice_sum:sum_a_and_b",durable=False)awaitchannel.basic_consume(sum_a_and_b__declared.queue,sum_a_and_b,no_ack=False)classApp(FastAPI):def__init__(self,*args,**kwargs):loop=asyncio.get_event_loop()loop.create_task(amqp_router())super().__init__(*args,**kwargs)app=App()Full working example [1]https://github.com/Sobolev5/Carrot-RPC-ExampleFull working example [2]https://github.com/Sobolev5/LordaeronChatTODOtests, docstrings, extended documentation
Package: carrotscript
CarrotScript Testing ServerThis is an package that create a local testing server so you can test a application or something else on your computer.InstallationTo install this, we reccomend using PIP. Run the following on your terminalpip3 install carrotscriptUsageTo use this package, in a python file, run this:from carrotscript import carrotscriptThen, it should ask a question:What port do you want to create your local server in:Answer a port like:What port do you want to create your local server in: 8080Then it should give something like this:Web Server is running at http://localhost:8080
Close this tab to exit
Logs:Then visithttp://localhost:8080(or whatever yours is) and you got a web serverTIP:cdto a directory and create aindex.htmlfile in there. Then, create a testing server there© Greatly Gravitate
Package: carrot-shell
CarrotShell🥕CarrotShell🥕 is the best shell in python, for developers.Setuppip install carrot-shellPython 3.8 or later is required.UsagectshSwitch virtual environmentCarrotShell🥕 only supports usingcondaas the virtual environment manager.
You can switch virtual environment by usingconda activatecommand.However, because CarrotShell🥕 itself runs in a python
environment, activate/deactivate virtual environment
will cause all variables and states to be lost.Developgit clone https://github.com/blueloveTH/carrot-shell
cd carrot-shell
python -m ctsh