Saravanan666/pypi-org huggingface dataset:
Package: chromadol
chromadolData Object Layer for ChromaDBTo install:pip install chromadolExample usageTo make aChromaClientDOL, you can specify achromadbClient,PersistentClient(etc.)
instance, or specify a string (which will be interpreted as a path to a directory to
save the data to in aPersistentClientinstance).>>> from chromadol import ChromaClient
>>> import tempfile, os 
>>> with tempfile.TemporaryDirectory() as temp_dir:
...     tempdir = os.path.join(temp_dir, "chromadol_test")
...     os.makedirs(tempdir)
>>> client = ChromaClient(tempdir)Removing all contents of client to be able to run a test on a clean slate>>> for k in client:
...     del client[k]There's nothing yet:>>> list(client)
[]Now let's "get" a collection.>>> collection = client['chromadol_test']Note that just accessing the collection creates it (by default)>>> list(client)
['chromadol_test']Here's nothing in the collection yet:>>> list(collection)
[]So let's write something.
Note thatchromadbis designed to operate on multiple documents at once,
so the "chromadb-natural" way of specifying it's keys and contents (and any extras)
would be like this:>>> collection[['piece', 'of']] = {
...     'documents': ['contents for piece', 'contents for of'],
...     'metadatas': [{'author': 'me'}, {'author': 'you'}],
... }Now we have two documents in the collection:>>> len(collection)
2Note, though, that the order of the documents is not guaranteed.>>> sorted(collection)
['of', 'piece']

>>> assert collection['piece'] == {
...     'ids': ['piece'],
...     'embeddings': None,
...     'metadatas': [{'author': 'me'}],
...     'documents': ['contents for piece'],
...     'uris': None,
...     'data': None
... }

>>> assert collection['of'] == {
...     'ids': ['of'],
...     'embeddings': None,
...     'metadatas': [{'author': 'you'}],
...     'documents': ['contents for of'],
...     'uris': None,
...     'data': None
... }You can also read multiple documents at once.
But note that the order of the documents is not guaranteed.>>> collection[['piece', 'of']] == collection[['of', 'piece']]
TrueYou can read or write one document at a time too.>>> collection['cake'] = {
...     "documents": "contents for cake",
... }
>>> sorted(collection)  # sorting because order is not guaranteed
['cake', 'of', 'piece']
>>> assert collection['cake'] == {
...     'ids': ['cake'],
...     'embeddings': None,
...     'metadatas': [None],
...     'documents': ['contents for cake'],
...     'uris': None,
...     'data': None,
... }In fact, see that if you only want to specify the "documents" part of the information,
you can just write a string instead of a dictionary:>>> collection['cake'] = 'a different cake'
>>> assert collection['cake'] == {
...     'ids': ['cake'],
...     'embeddings': None,
...     'metadatas': [None],
...     'documents': ['a different cake'],
...     'uris': None,
...     'data': None,
... }
Package: chroma-feedback
Chroma FeedbackTurn your RGB powered hardware into a status indicator for continuous integration, continuous deployment and infrastructure monitoring.PreviewInstallationInstall Chroma Feedback:pip3 install chroma-feedbackInstall the dependencies for Linux:apt-get install libudev-dev libusb-1.0-0-dev libhidapi-libusb0 libxcb-cursor0add-apt-repository ppa:openrazer/stable
apt-get updateapt install openrazer-metaUsageCombine producers and consumers as needed:chroma-feedback [options]

-p, --producer <producer>
-c, --consumer <consumer>
-i, --background-interval <background-interval>
-b, --background-run
-d, --dry-run
-l, --log-level
-v, --versionDocumentationRead thedocumentationfor a deep dive.
Package: chromaformatter
Chroma FormatterWrapper for Python logging formatter that adds colorInstallationChroma Formatter is on PyPI and can be installed with:pip install chromaformatterUsageChroma Formatter adds two features to the default logging formatter, colors can be added
to the log format string, and formatted arguments in a log message can be colored.
Colors can be inserted info the format string as such:log_format=(f'{Colors.Fore.GREEN}%(asctime)-s 'f'{Colors.LEVEL_COLOR}%(levelname).1s 'f'{Colors.Fore.MAGENTA}%(filename)-s:%(lineno)03d 'f'{Colors.LEVEL_COLOR}- %(message)s')Then, use chromaformatter.ChromaFormatter rather than logging.Formatter.importsysimportloggingfromchromaformatterimportChromaFormatter,Colorslog=logging.getLogger()log_format=(f'{Colors.Fore.GREEN}%(asctime)-s 'f'{Colors.LEVEL_COLOR}%(levelname).1s 'f'{Colors.Fore.MAGENTA}%(filename)-s:%(lineno)03d 'f'{Colors.LEVEL_COLOR}- %(message)s')formatter=ChromaFormatter(fmt=log_format,arg_start_color=Colors.Fore.WHITE,arg_end_color=Colors.LEVEL_COLOR)handler=logging.StreamHandler(stream=sys.stdout)handler.setFormatter(formatter)log.addHandler(handler)Formatted Arguments in a LogBy settingarg_start_colorfor argument colors andarg_end_colorfor the rest of the
string that comes after the argument, those colors will be applied to arguments.log.info('This%swill be colored.','variable')Additional ConfigurationChromaFormatter has a dict calledcolor_mapto determine the colors of each logging
level.By default, the colors are:CategoryColorNOTSETFore.LIGHTBLUE_EXDEBUGFore.BLUEINFOFore.CyanWARNINGFore.YELLOWERRORFore.LIGHTRED_EXCRITICALFore.REDARGSFore.WhiteColor map can be changed as such:formatter.color_map[logging.INFO]=Colors.Fore.WHITEformatter.color_map[logging.DEBUG]=Colors.Fore.MAGENTAApplying to Existing LoggersIf you are using a third party module that uses the standard python logging module you
can apply a ChromaFormatter as such:importsysimportloggingfromchromaformatterimportChromaFormatter,Colorslog_format=(f'{Colors.Fore.GREEN}%(asctime)-s 'f'{Colors.LEVEL_COLOR}%(levelname).1s 'f'{Colors.Fore.MAGENTA}%(filename)-s:%(lineno)03d 'f'{Colors.LEVEL_COLOR}- %(message)s')stream_formatter=ChromaFormatter(log_format)stream_handler=logging.StreamHandler(stream=sys.stdout)flask_logger=logging.getLogger('werkzeug')whileflask_logger.handlers:flask_logger.removeHandler(flask_logger.handlers.pop())flask_logger.addHandler(stream_handler)
Package: chroma-haystack
Chroma Document Store for HaystackTable of ContentsChroma Document Store for HaystackInstallationExamplesLicenseInstallationpip install chroma-haystackExamplesYou can find a code example showing how to use the Document Store and the Retriever under theexample/folder of this repo or inthis Colab.Licensechroma-haystackis distributed under the terms of theApache-2.0license.
Package: chromalog
Chromalog integrates seemlessly in any Python project and allows the use ofcolors in log messages and generic output easily. It is based on colorama andso works on both Windows and *NIX platforms. Chromalog is able to detectwithout any configuration if the associated output stream has colorcapabilities and can fall back to the default monochromatic logging.Chromalog also offer helpers to easily highlight some important parts of a logmessage.
Package: chroma-migrate
Chroma MigrateSchema and data format changes are a necessary evil of evolving software. We take changes seriously and make them infrequently and only when necessary.Chroma's commitment is whenever schema or data format change, we will provide a seamless and easy-to-use migration tool to move to the new schema/format.Specifically we will announce schema changes on:Discord (#migrations channel)Github (here)Email listservSign upWe will aim to provide:a description of the change and the rationale for the change.a CLI migration tool you can runa video walkthrough of using the toolMigration LogMigration from >0.4.0 to 0.4.0 - July 17, 2023We are migrating:metadata store: where metadata is storedindex on disk: how indexes are stored on diskMetadata Store: Previously Chroma used underlying storage enginesDuckDBfor thein-memoryversion of Chroma, andClickhousefor thesingle-node serverversion of Chroma. These decisions were made when Chroma was addressing more batch analytical workloads and are no longer the best choice for users. The new metadata store for thein-memoryandsingle-node serverversion of Chroma will besqlite. (The distributed version of Chroma (forthcoming), will use a different distributed metadata store.)Index store: Previously Chroma saved theentireindex on every write. This because painfully slow when the collection grew to a reasonable amount of embeddings. The new index store savesonly the changeand should scale seamlessly!Here are the 9-possible migration paths, and any notes, if applicable.From 👇     ➡️     To 👉Persistent ChromaLocal Chroma ServerRemote Chroma ServerPersistent Chroma✅✅1️⃣Local Chroma Server✅2️⃣1️⃣Remote Chroma Server✅✅1️⃣ 2️⃣1️⃣ - Make sure to configure any auth headers correctly2️⃣ - Run both the existing version of Chroma and the new0.4.0version of Chroma at same time. Run the new version on a new port if local.Embed video hereHow to use the migration toolpipinstall this utility.pip install chroma_migrateRunning the CLI. In your terminal run:chroma_migrateChoose whether the data you want to migrate is locally on disk (duckdb) on  clickhouse instance used by chroma, or directly from another chroma serverChoose where you want to write the new data to.Developing LocallyRun python main.py to test locally
Package: chromaprint
Python module to facilitate effortless color terminal output.InstallationChromaprint requires Python 3.X.Install via pip withpip install chromaprintUsagefrom chromaprint import print
print('green on magenta', fg='green', bg='magenta')It’s that easy.Chromaprint contains one propertycolorsand two methodsprintandset_default.colorschromaprint.colorsis a tuple containing the names of all available colors. Attempts to use colors not in this tuple will raise an exception.print()Theprint()method functions the same as Python’s built-in print method. Simply pass any strings you wish to print with the foreground color asfg='green'and background color asbg='magenta'. Color selections only apply to a single print, so the nextprintcall will use the default colors. You can change the default colors usingchromaprint.set_default()set_default()A custom set of default colors may be specified and changed at will. Simply callset_default()using the same syntax aschromaprint.print(), iechromaprint.set_default(bg='green',fg='magenta'). You may set eitherbg,fg, or both. To return to the system default color output passbg='default',fg='default'
Package: chromatic
<h1 align="center">chromatic</h1><p align="center">Create monochromatic backgrounds instantly</p><p align="center"><img src="https://i.imgur.com/pNYTBJU.gif" height="500"></p>## Installation#### pip```sh$ pip install chromatic```#### Manual```sh$ git clone https://github.com/prakashdanish/chromatic.git && cd chromatic$ python3 setup.py install```#### Imgur APIIf you wish to use `--imgur` option which uploads the generated file to imgur and copies the image link to the clipboard, you'd need the API keys, namely `client_id` and `client_secret`These are fairly easy to obtain.1. Register [here](https://imgur.com/signin?redirect=https%3A%2F%2Fapi.imgur.com%2Foauth2%2Faddclient)2. Copy your keys to `~/.chromatic.conf````conf[DEFAULT]client_id=<your_id>client_secret=<your_secret>```Your config file should already be present in your home dir `~/.chromatic.conf` and if it's not, then run `chromatic` once without any options or create the file manually.## Usage```shusage: chromatic [-h] [--color COLOR] [--size SIZE] [--imgur] [--nosave] [--open][--path PATH] [--name NAME]optional arguments:-h, --help     show this help message and exit--color COLOR  HEX color code--size SIZE    size of the image in LxB--imgur        upload image to imgur and return URL--nosave       don't save file locally--open         open imgur URL in browser--path PATH    path to the file--name NAME    name of the image file generated```## Why?I've had countless instances wherein I need a solid background image with a given size and color, and after going through the various solid background generators on the web, I end up using photoshop to do the same, which in itself is a tedious task.## ContributingDo you want to make this better? Open an issue and/or a PR on Github. Thanks!## LicenseMIT LicenseCopyright (c) 2018 [Danish Prakash](https://github.com/prakashdanish)---
Package: chromatics
chromaticsis a simple Python library for analyzing chromatographic data.chromaticsis designed to allow for simple analysis of SFC-MS data.
In particular,chromaticssimplifies analysis of overlapped chromatographic peaks
by using modern non-linear curve fitting algorithms (as implemented inlmfit) to fit the observed chromatogram to a linear combination
of parametric peak models.For an example of how to usechromatics, seetutorial/.This library is released under a GPL 3.0 license: seeLICENSE.txtfor more detailsCorin Wagen and Eugene Kwan, 2022
Package: chromatic_tda
chromatic_tdachromatic_tdais a package for computing six-packs of persistent diagrams of colored point clouds. Currently point clouds in R^2 with 2 or 3 colors are supported (see Future).InstallationInstall withpipThe package is uploaded toPyPI, so it can be installed withpip.Runpip install chromatic_tda.Install fromgithub projectThe project usespoetryfor Python dependecy management, which allows you to easily install all you need to run the package:Clone the repositoryInstallpoetryGo to the repository folder in terminalRunpoetry shellRunpoetry install[optional] Runpoetry run pytestto check that the code runsHow to useThe basic use of the package is as follows:import chromatic_tda as chro
points, labels = ... # load points, labels
chro_alpha = chro.ChromaticAlphaComplex(points, labels) simplicial_complex = chro_alpha.get_simplicial_complex(
             sub_complex=‘bi-chromatic’
             complex=‘all’
             relative=‘mono-chromatic’
)  # these options make sense for three colors; for two use, e.g., just sub_complex='mono-chromatic'
six_pack = simplicial_complex.bars_six_pack() chro.plot_six_pack(six_pack)For more details check the docstrings of the methods and the jupyter notebook filemanual(ingithub repo). For more background on the theory, check the resources listed below.FutureThe code is under active developement. The future plans include:Adding support for points in R^3Making persistence computation faster with clearing.ResourcesThe code is based on research done at Institute of Science and Technology by Ranita Biswas, Sebastiano Cultrera di Montesano, Ondřej Draganov, Herbert Edelsbrunner and Morteza Saghafian. A draft write up can be found onarxiv.A presentation about the main concepts used in this package can be viewed on YouTube:AATRN Online Seminar: TDA for Chromatic Point Clouds. A recording of a complementary talk focusing more on the motivations of the work and the combinatorial structures underlying it is accessible throughgoogle drive.ContactIf you have any questions to the code, do not hesitate to contat us. We are also eager to hear from you if you try the code out, and happy to chat about how you can use it on your data. Use, e.g., the mail in mygithub profile.LicenseCopyright ©2023. Institute of Science and Technology Austria (IST Austria). All Rights Reserved.This file is part of chromatic_tda, which is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by the Free Software Foundation, either version 3 of the License, or 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 Affero General Public License for more details.You should have received a copy of the GNU Affero General Public License along with this program. If not, seehttps://www.gnu.org/licenses/.Contact the Technology Transfer Office, ISTA, Am Campus 1, A-3400 Klosterneuburg, Austria, +43-(0)2243 9000,twist@ist.ac.at, for commercial licensing opportunities.
Package: chromatictools
ChromaticToolsThis is a collection of utilities that I often use when writing other softwareInstallYou can install thechromatictoolspackage fromPyPIvia pippip install chromatictoolsDocumentationAPI documentation can be found online here:https://chromaticisobar.github.io/chromatictoolsSource codeSource code is available on GitHubhttps://github.com/chromaticisobar/chromatictools
Package: chromatose
Chromatose is a package for storing and visualizing palettes, constructing new ones via interpolation or extraction. The stored palettes are for personal record, featuring diverging and continuous palettes. The interpolation scheme here can be used to create entirely new ones given only a few intermediary points. The underlying algorithm uses a combination of linear and polynomial splines in customizable color space metrics RGB, HSL, or HSV. Heatmaps are a great way to visualize the results. To extract palettes from images, chromatose employs k-means clustering and median-cut algorithms.
Package: chromawizard
Chromawizard 1.2.0A tool for creating karyotypes of M-FISH images.InstallationDownload or clone Chromawizard:cd chromawizard/Code
git checkout v1.1.8-release
pip3 install .or directly from PyPI:pip3 install chromawizardA Conda package for Windows user is also available:conda install -c nauer chromawizardRun ChromaWizardchromawizardor in debug mode:chromawizard -l Debug
Package: chromax
ChromaXChromaX is a breeding simulator for large-scale experiments. It is based onJAXand can run smoothly on multiple devices. We designed this library for researchers and breeders with the scope of guiding the design choices of breeding programs.InstallationYou can install ChromaX via pip:pip install chromaxQuickstartfromchromaximportSimulatorfromchromax.sample_dataimportgenetic_map,genomesimulator=Simulator(genetic_map=genetic_map)f1=simulator.load_population(genome)f2,parent_ids=simulator.random_crosses(f1,n_crosses=10,n_offspring=20)Citing ChromaX@article{10.1093/bioinformatics/btad691,author={Younis, Omar G and Turchetta, Matteo and Ariza Suarez, Daniel and Yates, Steven and Studer, Bruno and Athanasiadis, Ioannis N and Krause, Andreas and Buhmann, Joachim M and Corinzia, Luca},title="{ChromaX: a fast and scalable breeding program simulator}",journal={Bioinformatics},volume={39},number={12},pages={btad691},year={2023},month={11},abstract="{ChromaX is a Python library that enables the simulation of genetic recombination, genomic estimated breeding value calculations, and selection processes. By utilizing GPU processing, it can perform these simulations up to two orders of magnitude faster than existing tools with standard hardware. This offers breeders and scientists new opportunities to simulate genetic gain and optimize breeding schemes.The documentation is available at https://chromax.readthedocs.io. The code is available at https://github.com/kora-labs/chromax.}",issn={1367-4811},doi={10.1093/bioinformatics/btad691},url={https://doi.org/10.1093/bioinformatics/btad691},eprint={https://academic.oup.com/bioinformatics/article-pdf/39/12/btad691/54143193/btad691.pdf},}
Package: chrome-bookmarks
Installation$[sudo]pipinstallchrome-bookmarksFeaturesOSpathLinux~/.config/google-chrome/Default/BookmarksmacOS~/Library/Application Support/Google/Chrome/Default/BookmarksWindows~\AppData\Local\Google\Chrome\User Data\Default\BookmarksExamplesimportchrome_bookmarksforfolderinchrome_bookmarks.folders:print(folder.name)print(folder.folders)forurlinchrome_bookmarks.urls:print(url.url,url.name)readme42.com
Package: chromecast-volumecontrol
GUI for Chromecast VolumecontrolControl volume of your chromecasts through this little gui on your computer of choice, not through the awful google home app. Based on top of the awesomepychromecastlib.App listens to changes of volume through other apps (e.g. google home) and adjusts sliders.Tested with chromecast audios only, i do not have others.Run itRequirements:TK Python library:sudo apt install python3-tkPIPinstall it frompypipip install chromecast-volumecontrolthen, you can use run$ cc_volumecontrol`to open the guiClone itClone and run gui.py, not yet more available, still under development. Dependencies are python3, python3-tk and pychromecast.FutureAdd REST interface for IOT devices controlling the volume via hardware sliders. Currently, flask_endpoint.py is used to allow for some testing e.g. using arduinos with wifi.
Package: chromecast-volumecontrol-merklel
GUI for Chromecast VolumecontrolControl the volume of your chromecasts through this little gui on your computer of choice, not through the awful google home app. Based on top of the awesomepychromecastlib.App listens to changes of volume through other apps (e.g. google home) and adjusts sliders.Tested with chromecast audios only, i do not have others.Run itClone and run gui.py, not yet more available, still under development. Dependencies are python3 and pychromecast.FutureAdd REST interface for IOT devices controlling the volume via hardware sliders. They could communicate with
some endpoint. Currently, flask_endpoint.py is used to allow for some testing e.g. using arduinos with wifi.
Package: chrome-cookiejar
Chrome CookiejarThis module helps to utilize your Chrome cookies in Python scripts.
It's especially useful when scraping sites that requires login,
as you can test your ideas easily without solving the CAPTCHAs and emulating the whole login process.Supported platformsThis package is only tested on Python 3.Please also note that values of cookies are encrypted with platform specific algorithms since Chrome 33.
The decrypt helper for Windows is already included; however, only older versions of Chrome is currently supported on macOS or Linux.Get startedUse the following code snippet to create an instance ofhttp.cookiejar.CookieJarthat includes all cookies from your Chrome browser:>>>fromchrome_cookiejarimportChromeCookieJar>>>cookiejar=ChromeCookieJar('/path/of/your/Cookies')# doctest: +SKIPThe file path is optional; if omitted, the library will try to read cookies from the default user profile path of Chrom(ium).
If you're not sure, checkchrome://versionand follow theProfile Pathshown here.As theCookiesfile is a SQLite database, you could filter the host domain with SQL wildcards:>>>importrequests,re>>>jar=ChromeCookieJar(host_filter='%gith_b.com')>>>login_user=re.compile(r'<meta name="user-login" content="(.+?)">')>>>login_user.findall(requests.get('https://github.com',cookies=None).text)[]>>>login_user.findall(requests.get('https://github.com',cookies=jar).text)['Arnie97']
Package: chrome-devtools-protocol
PyCDPPython Chrome DevTools Protocol (shortened to PyCDP) is a library that provides
Python wrappers for the types, commands, and events specified in theChrome
DevTools Protocol.The Chrome DevTools Protocol provides for remote control of a web browser by
sending JSON messages over a WebSocket. That JSON format is described by a
machine-readable specification. This specification is used to automatically
generate the classes and methods found in this library.You could write a CDP client by connecting a WebSocket and then sending JSON
objects, but this would be tedious and error-prone: the Python interpreter would
not catch any typos in your JSON objects, and you wouldn't get autocomplete for
any parts of the JSON data structure. By providing a set of native Python
wrappers, this project makes it easier and faster to write CDP client code.This library does not perform any I/O!In order to maximize
flexibility, this library does not actually handle any network I/O, such as
opening a socket or negotiating a WebSocket protocol. Instead, that
responsibility is left to higher-level libraries, for exampletrio-chrome-devtools-protocol.For more information, see thecomplete documentation.