Saravanan666/pypi-org huggingface dataset:
Package: cocopp
COmparing Continuous Optimisers (COCO) post-processingThe (cocopp) package takes data generated with theCOCO frameworkto compare continuous opitmizers and produces output figures and tables inhtmlformat and for including into LaTeX-documents.Installationpip install cocoppUsageThe main method of thecocopppackage ismain(currently aliased tococopp.rungeneric.main). Themainmethod also allows basic use of the post-processing through a shell command-line interface. The recommended use is however from an IPython/Jupyter shell or notebook:>>>importcocopp>>>cocopp.main('exdata/my_output another_folder yet_another_or_not')postprocesses data from one or several folders, for example data generated with the help from thecocoexmodule. Each folder should contain data of a full experiment with a single algorithm. (Within the folder the data can be distributed over subfolders). Results can be explored from theppdata/index.htmlfile, unless a a different output folder is specified with the-ooption.Comparative datafrom over 200 full experiments are archived online and can be listed, filtered, and retrieved fromcocopp.archives(of typeOfficialArchives) and processed alone or together with local data. For example>>>cocopp.archives.bbob('bfgs')['2009/BFGS_...lists all data sets run on thebbobtestbed containing'bfgs'in their name. The first in the list can be postprocessed by>>>cocopp.main('bfgs!')All of them can be processed like>>>cocopp.main('bfgs*')Only a trailing*is accepted and any string containing the substring is matched. The postprocessing result of>>>cocopp.main('bbob/2009/*')can be browsed athttps://numbbo.github.io/ppdata-archive/bbob/2009-all. To display algorithms in the background, thegenericsettings.backgroundvariable needs to be set:>>>cocopp.genericsettings.background = {None: cocopp.archives.bbob.get_all('bfgs')}whereNoneinvokes the default color (grey) and line style (solid)genericsettings.background_default_style. Now we could compare our own data with the first'bfgs'-matching archived algorithm where all other archived BFGS data are shown in the background with the command>>>cocopp.main('exdata/my_output bfgs!')
Package: cocopye
CoCoPyECoCoPyE is a fast tool for quality assessment of microbial genomes. It is able to reliably predict
completeness and contamination of bacterial and archaeal genomes. Additionally, it can provide a
taxonomic classification of the input.Background: The classical approach for estimation of quality indices solely relies on a relatively small
number of universal single copy genes. Because these classical markers only cover a small fraction of the
whole genome the quality assessment can be rather unreliable. Our method is based on a novel
two-stage feature extraction and transformation scheme. It first performs a flexible extraction
of genomic markers and then refines the marker-based estimates with a machine learning approach based on
count-ratio histograms. In our simulation studies CoCoPyE showed a more accurate prediction of  quality
indices than existing tools.Getting startedCoCoPyE is available via pip and conda (conda-forge channel). See theproject wikifor installation and usage instructions.QuickstartInstallationUsageOnline DemoYou can test CoCoPyE without installation onour project homepage. Please note that the online demo can process only
one query genome per request and is less performant than a local installation. Therefore it is highly recommended to use the online
version only for evaluation purposes and install CoCoPyE on your own machine for productive use.Additional notesContactFor bug reports, suggestions or questions, please open an issue onGitHubor send an email topmeinic@gwdg.de.API documentationYou can find the API documentation of the CoCoPyE package onhttps://gobics.github.io/cocopye.LicenseCoCoPyE is available under the terms of the GNU General Public License, version 3 or later. SeeCOPYINGfor the full license text.
Package: cocorahs
PyCoCoraHSPyCoCoraHS is a Python package providing a CLI utility and an API for uploading observations toCoCoRaHS.InstallingInstall this package usingpip:python3-mpipinstall--usercocorahsUsing the CLIYou can invoke the CLI viacocorahs. Here is the help output:Usage: cocorahs [OPTIONS] PERCIPITATION

  Report PERCIPITATION amount to CoCoRaHS. Enter T for trace amounts.

Options:
  --station TEXT   The CoCoRaHS station code
  --username TEXT  Your CoCoRaHS username
  --password TEXT  Your CoCoRaHS password
  --help           Show this message and exit.Configuring the CLI via a config file.Create a file at~/.config/cocorahs/config.inicontaining a config like the following but
changing the details to your username, password, & station.[CoCoRaHS]username=DanielScheppassword=hunter2station=VA-RCC-15API UsageHere is a simple example of making a new report via the API:fromcocorahsimportCoCoRaHSapi=CoCoRaHS(username='DanielSchep',password='hunter2')api.new_report(station='VA-RCC-15',percipitation=0.1,trace=False)Thenew_reportfunction also accepts anobservation_timekeyword argument. It should be adatetime.datetimeobject.
Package: coco-rasa
A Toolkit to work with components in rasaInstallation (We recommend using a virtualenv):pip install coco-rasaSetup:Setting up CoCo actionsin actions.pyfromcoco_rasaimportGenericCoCoActionclassOneLiners(GenericCoCoAction):# component name is the component_id from CoCo marketplacecomponent_name="generic_oneliners_vp3"classNamer(GenericCoCoAction):component_name="namer_vp3"in domain.ymlactions:-generic_oneliners_vp3-namer_vp3to enable multi-turn capabilities for CoCo actionsin your rasa bot config.ymlpolicy:-name:"coco_rasa.CoCoContextPolicy"triggering actions (and CoCo actions)MappingPolicy# config.yml:policies:-name:MappingPolicy# domain.ymlintents:-greet:triggers:namer_vp3-someotherintentFallback policy# config.yamlpolicies:-name:"FallbackPolicy"nlu_threshold:0.4core_threshold:0.3fallback_action_name:"generic_oneliners_vp3"using context transferin domain.yml declare the keys you want the use(from CoCo context transfer protocol). data will be transferred automatically between components.slots:user.firstName:type:textuser.lastName:type:text
Package: cocoricofm
AboutA simple radio player implemented in Python3.The currently supported radio stations are:ByteFMDeutschlandfunk NovaDeltaRadioFIPFIP Autour du GrooveFIP Autour du JazzFIP Autour du MondeFIP Autour du RockFIP ElectroFIP ReggaeFIP Tout NouveauFrance MusiqueFrance Musique B.OFrance Musique Classique EasyFrance Musique Classique PlusFrance Musique ConcertsFrance Musique ContemporaineFrance Musique JazzFrance Musique du MondeFranceInterKCSMLeMouvRadio HelsinkiRockFMTripleJDependencies:python3python3-gbulbpython-aiohttppython-gigstreamergst-plugins-basegst-plugins-goodpython-bs4 (BeautifulSoup4)python-chardetOptional dependencies:python-lircpython-gntppygtk (for the graphical user interface)aiohttp_jinja2 and jinja2 for the web remote templatespyobjc (for macOS desktop notifications support)Features:notifications of song with libnotify or via python-gntp over the
network to a Growl daemonscrobbling to lastfm (and/or librefm)optionally dump the stream to local filesmultimedia keys support (stop, playpause)headless mode, when dbus and/or X11 is not availablelimited support for Denon AVR amps, power off/on from remote controloptional Web remote running on HTTP port 5000.optional GTK+ user interfaceDependencies installationOn Linux# apt install gstreamer1.0-plugins-{base,good,bad} libsoup2.4-1 python3-pip gir1.2-gst-plugins-base-1.0 gir1.2-gtk-3.0
# apt install liblirc-dev
$ pip3 install --user .
$ pip3 install --user requirements_linux.txt
$ xdg-user-dirs-updateOn macOSSome of the dependencies can be installed with Homebrew:$ brew install python3 gobject-introspection libsoup gtk+3 gstreamer gst-plugins-{base,good,bad} gst-pythonAnd the remaining Python packages using pip, optionally inside a dedicated virtualenv:$ pip3 install -r .
$ pip3 install -r requirements_macOS.txtRunning the appTo run without installing, from the project root directory:$ python3 -m cocoricofm [options]To install:Use gen_pylast_md5sum.py to get your password hashes for libre.fm/last.fmCopy cocoricofm.cfg.sample to ~/.config/cocoricofm.cfg and edit accordinglyRun either one of these commands:$ sudo python3 setup.py develop
$ sudo python3 setup.py installA cocoricofm executable script should now be available in your $PATH.
Package: cocos2d
A framework for building 2D games, demos, and other graphical/interactive applications.Draws using OpenGL, which is hardware accelerated.Targets the Operating Systems linux, mac or windows on Pc-like hardware.Provides some conventions and classes to help you structure a “scene based application”.A cocos2d application consists of several scenes, and a workflow connecting the different scenes.It provides you with a “director” (a singleton) which handles that workflow between scenes.Each scene is composed of an arbitrary number of layers;layers take care of drawing to the screen (using the pyglet and OpenGL APIs), handling events and in general contain all of the game/application logic.cocos2d simplifies the game development in these areas:Flow control: Manage the flow control between different scenes in an easy waySprites: Fast and easy spritesActions: Just tell sprites what you want them to do. Composable actions like move, rotate, scale and much moreEffects: Effects like waves, twirl, lens and much moreTiled Maps: Support for rectangular and hexagonal tiled mapsCollision: Basic pure python support for collisionsTransitions: Move from scene to scene with styleMenus: Built in classes to create menusText Rendering: Label and HTMLLabel with action supportBuilt-in Python Interpreter: For debugging purposesAccess to OpenGL functionalityand much more!http://los-cocos.github.io/cocos-site/RequirementsSoftware:python 3.6+pyglet 1.4.10+, < 2.0 (http://pyglet.org)Linux, Windows or Mac OS/XHardware:To execute some effects you will need a video card with the:GL_EXT_framebuffer_object extension.InstallingBeing a pure python package the usual options are available; you
can look at the INSTALL file for some detailsLearning cocos2dGo to the online tutorials / documentation page:http://los-cocos.github.io/cocos-site/doc.htmlYou will find:the Programming Guidethe API Referencesome tutorial videosThe tutorials are included in the source package.Lot of miniprograms that demonstrates the available objects and possible actions.
There are a great starting point while learning and experimenting with cocos:
you find a sample with the object that interest you exercising the features
that you need, read the code, run, modify and re-run to experiment.Also, handy to know what is available in cocos: run all the tests and by
looking at the code you know what to look at in the docs.You can find them at the test directory in the source distribution.
After unpacking, to run the tests you can do:$ cd test
$ python test_*.pyMore complex sample programsYou can find it in the samples directory in the source distribution, and the
most complex in subdirectories there, including a presentation done with
Cocos himself.After unpacking, to run the samples you can do:$ cd samples
$ python sample_name.pyDo you have any doubt?http://groups.google.com/group/cocos-discussDid you find any bug?http://groups.google.com/group/cocos-discusshttps://github.com/los-cocos/cocosCurrent repository is athttps://github.com/los-cocos/cocos
Package: coco-sdk
CoCoHub SDK to use components in python codehttps://www.conversationalcomponents.comInstallationpipinstallcoco-sdkWith async supportpipinstallcoco-sdk[async]Usageimportcocoimportuuidsession_id=str(uuid.uuid4())# generate a random session id# directly calling exchange:response=coco.exchange("namer_vp3",session_id,user_input="hello")# namer_vp3 is CoCoHub component# using ConversationalComponent APIcomp=coco.ConversationalComponent("namer_vp3")response=comp(session_id,"hello")# using ComponentSession APIsession_with_component=coco.ComponentSession("namer_vp3")response=session_with_component("hello")Asyncimportcoco.async_apiascoco# directly calling exchange:response=awaitcoco.exchange("namer_vp3",session_id,user_input="hello")# namer_vp3 is CoCoHub component# using ConversationalComponent APIcomp=coco.ConversationalComponent("namer_vp3")response=awaitcomp(session_id,"hello")# using ComponentSession APIsession_with_component=coco.ComponentSession("namer_vp3")response=awaitsession_with_component("hello")
Package: cocoserver
This Python module provides a modified version of the ThreadingHTTPServer
class from the http.server module in the standard library.  This server
is designed to serve a static web site, such as documentation for a
python project generated by Sphinx and installed with the software.  It
serves the files locally, on a random port of the loopback interface,
and hence works off line.  The server runs in its own daemon thread
of the python process, so it terminates when the python program exits
and thus will not leave zombie processes running.The server has been modified to allow any file in the site to be gzip
compressed and served with a Content-Encoding header set to “gzip”.
The compressed file will be automatically decompressed by the browser,
with no noticeable performance loss.  This is more efficient than the
typical case of serving compressed content over the internet since the
compression is done in advance. It also takes significantly less space
on the user’s disk. (Brotli compression would be even more efficient
in both ways, but web browsers still tend to only support Brotli
compression over https, due to the prevalence of broken proxy servers
on the internet.)Source code is available onGithub.
The git repository includes a script (compress_site.py) for compressing all of
the .html, .css, .js, .woff and .svg files below a given site root directory.
The tool is aware of Sphinx’s tendency to produce many identical copies of the
same (large) _static directory.  So it also collects the contents of all of the
_static subdirectories into one _static directory in the root, replacing the
others by symlinks.The server can be installed by running:python3-mpip install cocoserver.To use the server:>>> from cocoserver import StaticServer
>>> s = StaticServer('my/site/root')
>>> s.visit('mypage')The pip package also installs a console script namedcocowhich can
be used to view your static site, for example by running:coco /usr/local/share/doc/myproject.
Package: cocos-map
COCOSon-the-fly estimation of coastal paramters from videos of a wave fieldFree software: GNU General Public License v3Documentation:https://cocos-map.readthedocs.io.FeaturesTODOCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2021-08-20)First release on PyPI.
Package: cocotb-coverage
cocotb-coverageFunctional Coverage and Constrained Randomization Extensions for CocotbThis package allows you to use constrained randomization and functional coverage techniques known from CRV (constrained random verification) and MDV (metric-driven verification) methodologies, available in SystemVerilog ore. Such extensions enable the implementation of an advanced verification environment for complex projects.The implemented functionality is intended to be easily understandable by SystemVerilog users and provides significant extensions compared to Hardware Verification Languages.There is an option to export coverage database to a readable XML or YML format and a function which allows for merging such files is provided.InstallationThe package can be installed with pip. Version1.1.0is the latest one and recommended.pip install cocotb-coverageReferencescocotb core package -cocotbConstraint Solving Problem resolver used in this project -python-constraintdocumentationPyPI packageDVCon 2017 Paper -New Constrained Random and MDV Methodology using PythonDVCon 2017 Presentation -SLIDESexample advanced verification project -apbi2c_cocotb_exampleRoadmap1.1 released - 7 Aug 2020Planned basic support for UCIS coverage database formatAny suggestions welcome - you are encouraged to open an issue!Code Example# point represented by x and y coordinates in range (-10,10)classPoint(crv.Randomized):def__init__(self,x,y):crv.Randomized.__init__(self)self.x=xself.y=yself.add_rand("x",list(range(-10,10)))self.add_rand("y",list(range(-10,10)))# constraining the space so that x < yself.add_constraint(lambdax,y:x<y)...# create an arbitrary pointp=Point(0,0)for_inrange(10):# cover example arithmetic properties@CoverPoint("top.x_negative",xf=lambdapoint:point.x<0,bins=[True,False])@CoverPoint("top.y_negative",xf=lambdapoint:point.y<0,bins=[True,False])@CoverPoint("top.xy_equal",xf=lambdapoint:point.x==point.y,bins=[True,False])@CoverCross("top.cross",items=["top.x_negative","top.y_negative"])defplot_point(point):...p.randomize()# randomize objectplot_point(p)# call a function which will sample the coverage# export coverage to XMLcoverage_db.export_to_xml(filename="coverage.xml")# export coverage to YAMLcoverage_db.export_to_yaml(filename="coverage.yml")
Package: cocotbext-pcie
PCI express simulation framework for CocotbGitHub repository:https://github.com/alexforencich/cocotbext-pcieIntroductionPCI express simulation framework forcocotb.InstallationInstallation from pip (release version, stable):$ pip install cocotbext-pcieInstallation from git (latest development version, potentially unstable):$ pip install https://github.com/alexforencich/cocotbext-pcie/archive/master.zipInstallation for active development:$ git clone https://github.com/alexforencich/cocotbext-pcie
$ pip install -e cocotbext-pcieDocumentation and usage examplesSee thetestsdirectory,verilog-pcie, andcorundumfor complete testbenches using these modules.Core PCIe simulation frameworkThe core PCIe simulation framework is included incocotbext.pcie.core.  This framework implements an extensive event driven simulation of a complete PCI express system, including root complex, switches, devices, and functions, including support for configuration spaces, capabilities and extended capabilities, and memory and IO operations between devices.  The framework includes code to enumerate the bus, initialize configuration space registers and allocate BARs, route messages between devices, perform memory read and write operations, allocate DMA accessible memory regions in the root complex, and handle message signaled interrupts.  Any module can be connected to a cosimulated design, enabling testing of not only isolated components and host-device communication but also communication between multiple components such as device-to-device DMA and message passing.PCIe IP core modelsXilinx UltraScale and UltraScale+Models of the Xilinx UltraScale and UltraScale+ PCIe hard cores are included incocotbext.pcie.xilinx.us.  These modules can be used in combination with the PCIe BFM to test an HDL design that targets Xilinx UltraScale, UltraScale+, or Virtex 7 series FPGAs, up to PCIe gen 3 x16 or PCIe gen 4 x8.  The models currently only support operation as a device, not as a root port.Intel Stratix 10 H-Tile/L-TileModels of the Intel Stratix 10 H-Tile/L-Tile PCIe hard cores are included incocotbext.pcie.intel.s10.  These modules can be used in combination with the PCIe BFM to test an HDL design that targets Intel Stratix 10 GX, SX, TX, and MX series FPGAs that contain H-Tiles or L-Tiles, up to PCIe gen 3 x16.  The models currently only support operation as a device, not as a root port.Intel P-TileModels of the Intel P-Tile PCIe hard cores are included incocotbext.pcie.intel.ptile.  These modules can be used in combination with the PCIe BFM to test an HDL design that targets Intel Stratix 10 DX or Agilex F series FPGAs that contain P-Tiles, up to PCIe gen 4 x16.  The models currently only support operation as a device, not as a root port.
Package: cocotbext-syncserial
HDLC encoded Synchronous Serial interface modules for CocotbIntroductionSynchronous HDLC simulation models forcocotb.InstallationInstallation from respository:$ git clone https://github.com/cameronweston/cocotbext-syncserial.git
$ pip install cocotbext-syncserialDocumentation and usage examplesSee thetestsdirectory for a testbench using this module.Synchronous SerialTheSyncSerialSourceandSyncSerialSinkclasses can be used to drive, receive, and monitor HDLC encoded synchronous serial data.To use these modules, import the module you need and connect it to the DUT.from cocotbext.syncserial import SyncSerialSource, SyncSerialSink

sync_serial_source = SyncSerialSource(dut.data, dut.clk)

sync_serial_sink = SyncSerialSink(dut.data, dut.clk)To send data withSyncSerialSource, callwrite()orwrite_nowait(). Accepted data types are iterables of 8-bit ints, including lists, bytes, bytearrays, etc.To receive data withSyncSerialSink, callread()orread_nowait().read()will block until at least 1 packet is available.Constructor parameters:data: data signalclock: clock signalclock_rate_mhz: clock rate in megahertz (optional, default = 10)append_crc: appends crc to packet (optional, default = True)crc_polynomial: crc polynomial to use (optional, default = 0x1021)crc_init: crc initial value to use (optional, default = 0xFFFF)crc_final_xor: crc final xor to use (optional, default = 0x0000)validate_crc: validates incoming packet's crc (optional, default = True)strip_crc: Strips off crc after validation on incoming packet (optional, default = True)Methodswrite(): send packet of data (blocking) (source)write_nowait(): send packet of data (non-blocking) (source)read(): read one packet of data (blocking) (sink)read_nowait(): read one packet of data (non-blocking) (sink)count(): returns the number of packets in the queue (all)empty(): returnsTrueif the queue is empty (all)clear(): drop all data from the queue (all)wait(timeout=0, timeout_unit='ns'): wait for packet received (sink)CRC-16TheCrc_16classes can be used to calculate or validate a 16 bit CRC. To use this module:
from cocotbext.syncserial import Crc_16crc = Crc_16(crc_polynomial, crc_init, crc_final_xor)To calculate a CRC, callcalculate_crc(). Accepted data types are iterables of 8-bit ints, including lists, bytes, bytearrays, etc.To validate a CRC, callvalidate_crc(). Accepted data types are iterables of 8-bit ints, including lists, bytes, bytearrays, etc.Constructor parameters:crc_polynomial: CRC polynomial to use (optional, default = 0x1021)crc_init: CRC initial value to use (optional, default = 0xFFFF)crc_final_xor: CRC final XOR value to use (optional, default = 0x0000)Methodsvalidate_crc(data, crc): Calculates a CRC for data and compared to crccalculate_crc(data): Calucalates and returns a CRC for data