Saravanan666/pypi-org huggingface dataset:
Package: capyt
A python3 CLI utility to interface withpastethingExample:https://cpy.ptDependenciespython3requestsInstallationUsing pip is the easiest way to install this
Install from pypi:pip install capytYou can also manually install this from source:install dependencies -pip install -r requirements.txtsymlinkcapyt/capyt.pyto a location of your choiceadjust defaults and options if requiredUsagecapyt -hto see all available optionsPastingpaste a single filecapyt somefilecreate a single paste with many files concatenatedcapyt file1 file2 file3paste from stdinsomestdout | capyt -Deleting a pastecapyt -d DELETE_TOKEN PASTE_IDcapyt -d DELETE_TOKEN https://cpy.pt/PASTE_IDExtra FeaturesTransparently open gzip and bzip compressed filesWarningThe optional encoding flag only serves to open the file, internally everything is handled and converted to utf-8.
Retrieved pastes are utf-8 encoded.
Package: capytaine
Capytaine: a linear potential flow BEM solver with Python.Capytaine is Python package for the simulation of the interaction between water waves and floating bodies in frequency domain.
It is built around a full rewrite of the open source Boundary Element Method (BEM) solver Nemoh for the linear potential flow wave theory.InstallationPackages for Windows, macOS and Linux are available on PyPI:pipinstallcapytaineand Conda-forge:condainstall-cconda-forgecapytaineDocumentationhttps://ancell.in/capytaine/latest/LicenseCopyright (C) 2017-2023, Matthieu AncellinSince April 2022, the development of Capytaine is funded by the Alliance for Sustainable Energy, LLC, Managing and Operating Contractor for the National Renewable Energy Laboratory (NREL) for the U.S. Department of Energy.This program is free software: you can redistribute it and/or modify it under the terms of the GNU 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 General Public License for more details.It is based onNemoh, which has been developed by Gérard Delhommeau, Aurélien Babarit et al., (École Centrale de Nantes) and is distributed under the Apache License 2.0.It includes code frommeshmagickby François Rongère (École
Centrale de Nantes), licensed under the GNU General Public License (GPL).
Package: carabiner
Bravo! You have received a Mercantilism Diploma in "carabiner" from
the Orbital Convergence University International Air and Water Embassy of the Tangerine Planet (the planet that is one ellipse further from the Sun than Earth's ellipse).You are now officially certified to include "carabiner" in your practice.--carabinertaps (OCHLV)taps.season_3.super_hero_trend🎭stats (options)stats.aggregate_break_evenstats.aggregate_PC_ratio🌩️cloudsclouds.Coinbase.API.products.candles
Package: caracal-destruct
adestructionA Destruction of CARACals: Batch runners for CARACalInstallationInstallation fromsource,
working directory where source is checked outpipinstall.This package is available onPYPI, allowingpipinstallcaracal-destructUsagecaracal-destruct--helpUsage:caracal-destruct[OPTIONS]CONFIG_FILEAdestructionofCARACals:BatchrunnersforCARACalCONFIG_FILE:CARACalconfigurationfileOptions:-bc,--batch-configFILEYAMLfilewithbatchconfiguration.Generatedautomaticallyifunspecified.[required]-nb,--nbandINTEGERNumberoffrequencybandstosplitdatainto-b,--bandsTEXTCASA-stylecommaseparatedbands(orspws)toparallizethepipelineover.Overide-nb/--nband.Example,'0:0~1023,0:1024~2048'-s,--skipTEXTSkipthelistedsteps.Specifyasacommaseparatedlistofintegers(startingfromzero)ormsnames/paths.--helpShowthismessageandexit.LicenseThis project is licensed under the GNU General Public License v3.0 - seelicensefor details.ContributeContributions are always welcome! Please ensure that you adhere to our coding
standardspep8.
Package: caracara-filters
Caracara FiltersA new filter system for Caracara.Caracara's previous filter system was inflexible, and tailored too heavily toward the Hosts API module. This project aims to provide an FQL generator that is dialect-aware (i.e., contextual, based on the API module that the request will be sent to).Basic ConceptsInstead of declaring each filter as a class, we now have them defined in a dictionary which is significantly easier to work with. Dynamic functionality is provided by storing (partial) functions into each filter.Each filter derives from the 'default' / base filter, which is configured with identity transforms and validators that return the input value andTrue, respectively, and expects a string input. These settings can be overridden per-filter, and are enforced when a filter is added to theFQLGeneratorobject. We call this process rebasing, as each filter is rebased from a smaller dictionary over the top of the default filter, thus ensuring that all expected values will be present.When a filter is created, the input goes through these processing stages:Validation: the filter's input is passed into a validation function that always returns abool.Truemeans that the input is valid, andFalsewill raise aValueErrorexception. At this stage, we also validate the input type; incorrect input types will result in aTypeError.Transformation: each filter value can be transformed from a human-defined input into something machine-readable, expected by the API. For example, relative timestamps (such as-30m) are transformed to a UTC ISO8601 timestamp ready for the Falcon API, andContainment Pendingis rewritten tocontainment_pendingas expected by the Hosts API.Storage: the validated, transformed input is stored alongside the FQL property name and the operator (e.g., equality,>=, etc.), ready for FQL generation.When FQL is generated, each of the filters are iterated over and converted to FQL individually, and then chained together with+to form anANDcondition.LimitationsWe currently only support a limited subset of FQL. For example:Wecangenerate a condition like "all systems that run Windows or Linux, AND have an IP address in the range 192.168.0.0/16 OR 10.0.0.0/8".Wecannotgenerate a condition like "all systems that run Windows AND have an IP address in the 192.168.0.0/16 range, as well as all Linux systems in the 10.0.0.0/8 range".The latter is out of scope as it requires chaining together multiple filters. You can effectively create this functionality for yourself by creating two FQL generators, wrapping their outputs in parentheses, and chaining them together with a'+'.join().
Package: caramel
Caramel is a certificate management system that makes it easy to use client
certificates in web applications, mobile applications, embedded use and
other places. It solves the certificate signing and certificate
management headache, while attempting to be easy to deploy, maintain and
use in a secure manner.Caramel makes it easier (it’s never completely easy) to run your own
certificate authority and manage and maintain keys and signing periods.Caramel focuses on reliably and continuously updating short-lived certificates
where clients (and embedded devices) continue to “phone home” and fetch
updated certificates.  This means that we do not have to provide OCSP and
CRL endpoints to handle compromised certificates, but only have to stop
updating the certificate. This also means that expired certificates
should be considered broken.
Package: caraml-upi-protos
CaraML UPI ProtosGenerated Python code fromcaraml-dev/universal-prediction-interface.
The intent of this package is to ease creation of Python server / client compatible with CaraML dataplane.Example UsageCreating ServerCreateserver.pycontaining following dummy server codefromconcurrentimportfuturesimportgrpcimportrandomfromcaraml.upi.v1importupi_pb2_grpc,upi_pb2,value_pb2importcaraml.upi.v1.upi_pb2asupiv1classModel(upi_pb2_grpc.UniversalPredictionServiceServicer):defPredictValues(self,request:upi_pb2.PredictValuesRequest,context:grpc.ServicerContext)->upi_pb2.PredictValuesResponse:print(f"request:{request}")# Return random integer for each rowsresult_rows=[]forrowinrequest.prediction_rows:result_row=upi_pb2.PredictionResultRow(row_id=row.row_id,values=[value_pb2.NamedValue(name="result",type=value_pb2.NamedValue.INTEGER_VALUE_FIELD_NUMBER,integer_value=random.randint(0,100))])result_rows.append(result_row)returnupi_pb2.PredictValuesResponse(prediction_result_rows=result_rows,)if__name__=="__main__":server=grpc.server(futures.ThreadPoolExecutor(max_workers=10))upi_pb2_grpc.add_UniversalPredictionServiceServicer_to_server(Model(),server)port=9000print(f"Running upi server at port{port}")server.add_insecure_port(f"[::]:{port}")server.start()server.wait_for_termination()Start the serverpythonserver.py
>Runningupiserveratport9000Creating ClientCreateclient.pycontaining following client codefromcaraml.upi.v1importupi_pb2_grpc,upi_pb2fromcaraml.upi.v1importvalue_pb2importgrpcimporttimedefrun(server_port:9000):withgrpc.insecure_channel(f"localhost:{server_port}")aschannel:stub=upi_pb2_grpc.UniversalPredictionServiceStub(channel)whileTrue:response=stub.PredictValues(upi_pb2.PredictValuesRequest(prediction_rows=[upi_pb2.PredictionRow(row_id="1",model_inputs=[value_pb2.NamedValue(name="feature1",type=value_pb2.NamedValue.DOUBLE_VALUE_FIELD_NUMBER,double_value=1.1),value_pb2.NamedValue(name="feature2",type=value_pb2.NamedValue.DOUBLE_VALUE_FIELD_NUMBER,double_value=2.2),value_pb2.NamedValue(name="feature3",type=value_pb2.NamedValue.DOUBLE_VALUE_FIELD_NUMBER,double_value=3.3),value_pb2.NamedValue(name="feature4",type=value_pb2.NamedValue.DOUBLE_VALUE_FIELD_NUMBER,double_value=4.4),]),upi_pb2.PredictionRow(row_id="2",model_inputs=[value_pb2.NamedValue(name="feature1",type=value_pb2.NamedValue.DOUBLE_VALUE_FIELD_NUMBER,double_value=1.1),value_pb2.NamedValue(name="feature2",type=value_pb2.NamedValue.DOUBLE_VALUE_FIELD_NUMBER,double_value=2.2),value_pb2.NamedValue(name="feature3",type=value_pb2.NamedValue.DOUBLE_VALUE_FIELD_NUMBER,double_value=3.3),value_pb2.NamedValue(name="feature4",type=value_pb2.NamedValue.DOUBLE_VALUE_FIELD_NUMBER,double_value=4.4),]),]))print(response)time.sleep(1)if__name__=="__main__":run(9000)Start client in separate shell as the serverpythonclient.py
Package: carat
carat_  _  __ _ _|_
(_ (_| | (_| |_   computer-aided rhythm analysis toolboxDocumentationSeehttps://carat.readthedocs.iofor a complete reference manual and introductory tutorials.Demonstration notebooksSome demonstrations of what you can do with carat:Rhythmic patterns demo notebook: how to extract rhythmic patterns from an audio recording.Microtiming patterns demo notebook: how to extract microtiming patterns from an audio recording.Onsets detection demo notebook: how to detect onsets from an audio recording.InstallationThe latest stable release is available on PyPI, and you can install it bypip install caratTo build carat from source, usepython setup.py build.
Then, to install carat, saypython setup.py install.
If all went well, you should be able to execute the demo scripts underexamples/(OS X users should follow the installation guide given below).Alternatively, you can download or clone the repository and usepipto handle dependencies:unzip carat.zip
pip install -e caratorgit clone https://github.com/mrocamora/carat.git
pip install -e caratBy callingpip listyou should seecaratnow as an installed pacakge:carat (0.x.x, /path/to/carat)Hints for the Installationcaratuseslibrosato load audio files. The following are the installation hints provided by librosa in order to install the needed dependencies to load audio files.librosausessoundfileandaudioreadto load audio files.
Note thatsoundfiledoes not currently support MP3, which will cause librosa to
fall back on theaudioreadlibrary.soundfileIf you're usingpipon a Linux environment, you may need to installlibsndfilemanually.  Please refer to theSoundFile installation documentationfor details.audioread and MP3 supportTo fuelaudioreadwith more audio-decoding power (e.g., for reading MP3 files),
you may need to install eitherffmpegorGStreamer.Note that on some platforms,audioreadneeds at least one of the programs to work properly.Here are some common commands for different operating systems:Linux (apt-get):apt-get install ffmpegorapt-get install gstreamer1.0-plugins-base gstreamer1.0-plugins-uglyLinux (yum):yum install ffmpegoryum install gstreamer1.0-plugins-base gstreamer1.0-plugins-uglyMac:brew install ffmpegorbrew install gstreamerWindows: download binaries from the websiteFor GStreamer, you also need to install the Python bindings withpip install pygobjectCitingIf you want to cite carat please cite the paper published at AAWM 2019:Rocamora, and Jure. "carat: Computer-Aided Rhythmic Analysis Toolbox." In Proceedings of Analytical Approaches to World Music. 2019.
Package: caravagene
Caravagene (full documentationhere) is a Python library to plot schemas of DNA constructs from a list of parts.InfosCaravagene requiresWkHTMLtoPDFto be installed. On Ubuntu, install it with:apt-getinstallwkhtmltopdfPIP installation:pipinstallcaravageneWeb documentation:https://edinburgh-genome-foundry.github.io/Caravagene/Github pagehttps://github.com/Edinburgh-Genome-Foundry/CaravageneLive demohttps://cuba.genomefoundry.org/sketch_constructsLicense:MIT, Copyright Edinburgh Genome Foundry
Package: caravanassets
why?This Python package will help you implement the Caravan card game.The most important thing it does is add cards to the caravan pile using the "add_card" method. If it is impossible to add a card, the caravan does not change.It also has several auxiliary methods, such as "price" - which allows you to estimate the cost of a caravan, or "direction_check", which allows you to determine the direction of the stack (increasing or descending).Playing cards are implemented using the "Card" class, which contains the name of the card and its suit.So far this package does not contain manipulations with the Joker card, but it will be added in the future. (maybe)jack add instructionYou must enter a list of cards [name1, suit1, name2, suit2...], where name (1-13) are in odd places, and suit (1-4) are in even places. The sequence of cards must be a valid caravan. (there should be no jacks in it, and the number card should come first).You also need to select the card on which you want to place the jack. Jack can only be placed on number cards.For example, you can usepython -m caravanassets -cards "[1, 2, 3, 4, 13, 2, 4, 2]"output:Three Clubs King Diamonds Four Diamondsby default the program uses jack on the first cardbut if you need to use it on other card, you can usepython -m caravanassets -cards "[1, 2, 3, 4, 13, 2, 4, 2]" -addj 2output:Ace Diamonds Four Diamondsthe jack removed the second card, and all the picture cards on it.input-cards / --caravan (necessary)-addj / --addjack (not necessary)installationpip install caravanassets
Package: caravel
# <img src=”caravel/static/caravel.svg” alt=”caravel logo” height=”70” align=”left”/> caravel[![PEP compatible](http://pepkit.github.io/img/PEP-compatible-green.svg)](http://pepkit.github.io)caravelis a local web GUI for [looper](https://looper.readthedocs.io/). Caravel gives you a slick web interface to interact with your projects formatted as [PEPs](http://pepkit.github.io). You can use it to submit jobs to any cluster resource manager, monitor jobs, summarize results, and browse project summary web pages.caravelbasically builds on top oflooper, but uses the lightweightflaskmicroframework to give you a web interface, making it even easier to manage your jobs for those who like pointy-clicky.Documentation is hosted at [caravel.databio.org](http://caravel.databio.org) (source in the [/docs](/docs) folder).## docker[![Build Status](https://travis-ci.org/pepkit/caravel.svg?branch=master)](https://travis-ci.org/pepkit/caravel)A docker image for running caravel is available through the dockerfile in this repository. To build the image:` docker build-tcaravel_demo . `Run the container withcaravel –demo:` docker run-p5000:5000 caravel_demo caravel--demo`
Package: carbatpy
# carbatpyModeling Carnot Batteries (Thermal Energy Storage), a Python package.### THIS is the version with the new directory structure, several files from the previous version are not included yet! (2023-10-23)This is a project aiming to model thermal energy storages using heat pumps for
charging, organic Rankine cycles (ORC) for discharging and different kinds of
storages.
For this, it is planned to use detailed fluid models (as implemented e.g. in
REFPROP, CoolProp, or TREND ) and setting up systems which can either be steady
state or (later) also unsteady.
Since this project just starts, do not expect too much.
It is aimed to have heat exchangers, machines and storages as compounds, which
can be combined to different charging and dicharging configurations. For these,
the energy balance, mass balance and further relations will be applied/solved.
Later on also thermo-economic calculations are planned.For the beginning, the solution of the spatially resolved heat exchanger
profiles, a  boundary value problem, and its irreversibility will be
implemented. An optimization will follow.Burak Atakan, University of Duisburg-Essen, GermanyYou can contact us at: batakan [a t ]uni-duisburg.de or atakan.thermodynamik.duisburg [ a t] gmail.comFree software: MIT licenseDocumentation:https://carbatpy-010.readthedocs.io/en/latest/FeaturesTODOCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.
Package: carbon
CarbonOverviewCarbon is one of three components within the Graphite project:Graphite-Web, a Django-based web application that renders graphs and dashboardsThe Carbon metric processing daemonsTheWhispertime-series database libraryCarbon is responsible for receiving metrics over the network, caching them in memory for "hot queries" from the Graphite-Web application, and persisting them to disk using the Whisper time-series library.Installation, Configuration and UsagePlease refer to the instructions atreadthedocs.LicenseCarbon is licensed under version 2.0 of the Apache License. See theLICENSEfile for details.
Package: carbonado
Bravo!  You have received a Mercantilism Diploma in "carbonado" fromthe Orbital Convergence University International Air and Water
Embassy of the Tangerine Planet (the planet that is one ellipse further from
the Sun than Earth's ellipse).You are now officially certified to include "carbonado" in your practice!Encore! Encore! Encore! Encore!carbonadodescriptionStarted from the shell, "carbonado" presents files in the current workingdirectory (CWD) that have extension ".6.HTML" (case sensitive).obtainment[xonsh] pip install carbonadotutorial[xonsh] carbonado carbonadothe shell interface[xonsh] carbonado"carbonado" starts on port 2345, or the first avaible port after that.Running onhttp://127.0.0.1:2345This is the equivalent of:[xonsh] carbonado start --port 2345--Alternatively you can add--static-portand "carbonado"stops if the port specified is unavailable.[xonsh] carbonado start --port 2345 --static-port--This is an example ".6.HTML" file.<pre>
	<h1>This is an example HTML file.</h1>
	<p>
		It really only needs the "pre" tag to    
		look like a reflection of its contents in a browser.   
	</p>   
	<p>
		Tags like "html" and "body" are actually not   
		necessary for rendering HTML in modern browsers.  
	</p>   
	<p>  
		for text to wrap, instead of extending off the page,    
		style "white-space: pre-wrap" can be utilized instead of 
		a "pre" tag like so:
		
		<div style="white-space: pre-wrap"></div>
	</p>
</pre>However, here is the "CSS1Compat" option,https://developer.mozilla.org/en-US/docs/Web/HTML/Quirks_Mode_and_Standards_Modewith scaling based on the browser screen "viewport" of the screen,https://developer.mozilla.org/en-US/docs/Web/HTML/Viewport_meta_tagand support for UTF-8 characters.http://www.unicode.org/chartshttps://www.w3.org/International/questions/qa-html-encoding-declarations<!doctype html>
<html>
	<head>	
		<meta charset="utf-8" />
		<meta name="viewport" content="width=device-width, initial-scale=1" />
	</head>
	<body>
		<main>
			<article style="white-space: pre-wrap">
				
			
			</article>
		</main>
	</body>
</html>the python3 interfaceimport pathlib
from os.path import dirname, join, normpath
this_folder = pathlib.Path (__file__).parent.resolve ()

import carbonado
carbonado.start ({
	"extensions": [ 
		'.6.HTML',
		'.$.HTML',
		'.S.HTML',
		'.s.HTML', 
		'.jpg', 
		'.png' 
	],
	
	#
	#	This is the node from which the traversal occur.
	#
	"directory": str (this_folder) + "/structures/carbonado",
	
	#
	#	This path is removed from the absolute path of share files found.
	#
	"relative path": str (this_folder) + "/structures/carbonado",
	
	
	#
	#	The first port to check
	#
	"port": 2345,
	
	#
	#	Whether to check more ports if port is unavailable
	#
	"static port": False,
	
	#
	#	0, 1, 2
	#
	"verbose": 1,
})

import time
while True:
	time.sleep (1000)contactsbgrace2345@proton.me
Package: carbonai
CarbonAIThis project aims at creating a python package that allows you to monitor the power consumption of any python function.DocumentationThe complete documentation is availablehere.Getting startedInstallFirst of all you need to install the intel utility allowing you to monitor power consumption (support):WindowsMacOSLinux, no need to install any softwareTo install this package :pipinstallcarbonaiExampleThere are several ways to use this package depending on how you develop.
You just have to import thePowerMeterobject, initialize it and call the function you want to monitor.
Please insert a description of the running function, the dataset, the model, any info would be useful.Function decoratorTo monitor the power consumption of a function, follow this example:fromcarbonaiimportPowerMeterpower_meter=PowerMeter(project_name="MNIST classifier")@power_meter.measure_power(package="sklearn",algorithm="RandomForestClassifier",data_type="tabular",data_shape=<your_data>.shape,algorithm_params="n_estimators=300, max_depth=15",comments="Classifier trained on the MNIST dataset, 3rd test")defmy_func(arg1,arg2,...):# Do somethingUsing the with statementTo monitor the power consumption of some specific inline code, you can use with statementsfromcarbonaiimportPowerMeterpower_meter=PowerMeter(project_name="MNIST classifier")withpower_meter(package="sklearn",algorithm="RandomForestClassifier",data_type="tabular",data_shape=<your_data>.shape,algorithm_params="n_estimators=300, max_depth=15",comments="Classifier trained on the MNIST dataset, 3rd test"):# Do somethingContributeAll contributions, bug reports, bug fixes, documentation improvements, enhancements, and ideas are welcome.You can find details on how to contribute inour guide