Saravanan666/pypi-org huggingface dataset:
Package: comet-emu
Give a Welcome to theCOMETAuthor:Alex E. et al.Source:Source code at GitLabDocumentation:Documentation at ReadthedocsInstallation:pip install comet-emuReferences:Sanchez 2020,Sanchez et al 2021:dizzy:COMET- Cosmological Observables Modelled by Emulated perturbation Theory.COMET is a Python package that provides emulated predictions of large-scale
structure observables from models that are based on perturbation theory.
COMET substantially speeds up these analytic computations without any
relevant sacrifice in accuracy, enabling an extremely efficient
exploration of large-scale structure likelihoods.At its core, COMET exploits the evolution mapping approach ofSanchez 2020andSanchez et al. 2021, which
gives it a high degree of flexibility and allows it to cover a wide
cosmology parameter space at continuous redshifts up to $z \sim 3$.
Specifically, the  current release of COMET supports the following
parameters (for more details, seehere):Phys. cold dark matter density$\omega_c$Phys. baryon density$\omega_b$Scalar spectral index$n_s$Hubble expansion rate$h$Amplitude of scalar fluctuations$A_s$Constant dark energy equation of state parameter$w_0$Time-evolving equation of state parameter$w_a$Curvature density parameter$\Omega_K$Currently, COMET can be used to obtain the following quantities (the
perturbation theory models are describedhere):the real-space galaxy power spectrum at one-loop ordermultipoles (monopole, quadrupole, hexadecapole) of the redshift-space
power spectrum at one-loop orderthe linear matter power spectrum (with and without infrared resummation)Gaussian covariance matrices for the real-space power spectrum and
redshift-space multipoles$\chi^2$'s for arbitrary combinations of multipolesCOMET provides an easy-to-use interface for all of these computations, and
we give quick-start as well as more in-depth examples on ourtutorial pages.Our package is made publicly available under the MIT licence; please cite
the papers listed above if you are making use of COMET in your own work.Getting startedInstall the code is as easy aspip install comet-emuThen you can follow theJupyter Notebookfor a small example on how to make predictions, compare with data and estimate
the $\chi^2$ of your model.Developer versionIf you want to modify the code and play around with it, we provide a developer
version so that you can make it and test it. Also, could be possible that you
have your own theoretical predictions and you wish to train the emulator
with your own computations. You can install the developer
version as follow.git clone git@gitlab.com:aegge/comet-emu.git
cd comet-emu
pip install -e .Then you can follow theJupyter Notebookto learn how to train theCOMETand make predictions.LicenseMIT LicenseProject status.. note::
The COMET emulator is under constant development and new versions of the
emulator become available as we improve them. Follow ourpublic repository <https://gitlab.com/aegge/comet-emu>_ to make sure you are always up to
date with our latest release.
Package: comet-maths
comet_mathsMathematical algorithms and tools to use within CoMet toolkit.UsageVirtual environmentIt’s always recommended to make a virtual environment for each of your python
projects. Use your preferred virtual environment manager if you want and
activate it for the rest of these commands. If you’re unfamiliar, readhttps://realpython.com/python-virtual-environments-a-primer/. You can set one up
using:python -m venv venvand then activate it on Windows by usingvenv/Scripts/activate.InstallationInstall your package and its dependancies by using:pip install -e .DevelopmentFor developing the package, you’ll want to install the pre-commit hooks as well. Type:pre-commit installNote that from now on when you commit,blackwill check your code for styling
errors. If it finds any it will correct them, but the commit will be aborted.
This is so that you can check its work before you continue. If you’re happy,
just commit again.CompatibilityLicenceAuthorscomet_mathswas written byPieter De Vis.
Package: comet-ml
DocumentationFull documentation and additional training examples are available onhttp://www.comet.com/docs/InstallationSign up (free) on comet.com and obtain an API key athttps://www.comet.comGetting started: 30 seconds to Comet.mlThe core class of Comet.ml is anExperiment, a specific run of a
script that generated a result such as training a model on a single set
of hyper parameters. An Experiment will automatically log scripts output (stdout/stderr), code, and command
line arguments onanyscript and for the supported libraries will
also log hyper parameters, metrics and model configuration.Here is the Experiment object:fromcomet_mlimportExperimentexperiment=Experiment(api_key="YOUR_API_KEY")# Your code.We all strive to be data driven and yet every day valuable experiments
results are just lost and forgotten. Comet.ml provides a dead simple way
of fixing that. Works with any workflow, any ML task, any machine and
any piece of code.For a more in-depth tutorial about Comet.ml, you can check out or docshttp:/www.comet.com/docs/LicenseCopyright (C) 2015-2020 Comet ML INC.This package can not be copied and/or distributed without the express permission of Comet ML Inc.
Package: cometml-api
comet_ml_apiThis is a set ofunofficialPython bindings for the CometML REST API. There are functions for all current endpoints as well as a couple of functions that build on the basic endpoint ones to provide, e.g., simpler output or filtering. I haven't used all of the endpoints myself, so some of the functions haven't been tested at all (e.g.get_html). Documentation is currently limited but the functions provided are generally quite simple.SeeEndpointsfor the official documentation of the REST API.AuthenticationSeethis pagefirst for how to generate your REST API key. There are two possible methods of authentication using that key:Store the key in~/.comet_rest_key. When you import theapiscript, it will automatically load a key that it finds in this file.Call theset_api_keyfunction and pass your key in. The key will be saved in a global variable so that the same key is used for all subsequent requests unless you explicitly set a new key.EndpointsMost of the basic endpoint functions are namedget_<endpoint>where<endpoint>is the corresponding endpoint (e.g.get_workspacesto accesshttps://www.comet.ml/api/rest/v1/workspaces). However, there are a few exceptions.MetricsThere are two endpoints for metrics:metricsandmetrics-raw. I call both of these "raw" because they return data that isn't well-formatted for immediate plotting/analysis. As themetricsendpoint only return the min, max, and most recent data points for a given metric, I call that one a summary, henceget_raw_metric_summaries; the function formetrics-rawisget_raw_metrics. There is also a helper functionget_metricswhich converts the metrics into a better format for visualization or analysis.ParamsSimilarly to metrics, the raw parameters data may not be in the most usable format right away. I thus also call this endpointget_raw_paramsand have a helper functionget_paramswhich provides a more concise output.OtherAs for params except, though the endpoint islog-other, the functions areget_raw_othersandget_others.ImagesTheimagesendpoint doesn't return the images themselves, just the data about them (including the URLs from which the actual images can be downloaded?). I call this endpointget_image_data, but I haven't tested it.Example Usagefromcomet_ml_apiimportapiworkspaces=api.get_workspaces()project_ids=api.get_project_names_and_ids(workspaces[0])# {name: id}experiments=api.get_experiments(project_ids.popitem()[1])api.get_params(experiments[0]["experiment_key"])
Package: cometpy
cometpyComet Domain Specific Compiler for NumPy frontends.Latest Version : v0.1Requirements:python 3 and aboveCOMET Python package v0.1OS support - Linux and macOS"COMET" / Domain specific COMpiler for Extreme TargetsThe COMET compiler consists of a Domain Specific Language (DSL) for sparse and dense tensor algebra computations, a progressive lowering process to map high-level operations to low-level architectural resources, a series of optimizations performed in the lowering process, and various IR dialects to represent key concepts, operations, and types at each level of the multi-level IR. At each level of the IR stack, COMET performs different optimizations and code transformations. Domain-specific, hardware- agnostic optimizations that rely on high-level semantic information are applied at high-level IRs. These include reformulation of high-level operations in a form that is amenable for execution on heterogeneous devices (e.g., rewriting Tensor contraction operations as Transpose-Transpose-GEMM-Transpose) and automatic parallelization of high-level primitives (e.g., tiling for thread- and task-level parallelism).More information about the COMET compiler can be found at:COMET's source code -https://github.com/pnnl/COMETCOMET’s documentation -https://pnnl-comet.readthedocs.io/en/latest/Installation and Testing:Getting COMET pyhton package:Install the COMET python package using pip (or) pip3 python package managers as:For macOS users:
python3 -m pip install cometpyFor Linux users:
python3 -m pip install cometpy-lnxUsing COMET compiler as a backend to lower and execute test methods:Import the Comet Python package in your python script using - "import cometpy as comet"To compile a test method using COMET, add the decorator "@comet.compile(flags=...)"
before the method.The "numpy" keyword in a target method needs to be replace with "comet"
e.g. "comet.einsum" , "comet.multiply"Supported "numpy" methods:.einsum().multiply()For the actual "einsum" computation, follow the convention - "comet.einsum()"
Package: comets
CoMETS, the Cosmo Model Experimentation ToolboxCoMETS is a Python library for experimenting with numerical models and simulators.It offers tools to run, analyze and optimize your models and can be used with both Python models as well as Cosmo Tech simulators.InstallationInstallation is straightforward using pip:pip install comets[all]Getting StartedRead the getting started and the tutorials on theCosmo Tech PortalDocumentationDocumentation is available on theCosmo Tech Portal
Package: comet-toolbox
Comet - A dynamic functional connectivity toolbox for multiverse analysisPlease note: This package is at a very early stage of development, with frequent changes being made. If you intend to use this package at this stage, I kindly ask that you contact me via the email address in thepyproject.tomlfile.InstallationInstallation is possible through the Python Package Index (PyPI) with the pip or pip3 command, depending on your system:pip install comet-toolboxWe further recommend using a dedicatedAnacondaorMinicondaenvironment to mitigate the risk of potential version conflicts.Installation from the source code of this repository is also possible:Download/clone the repositoryOpen a terminal in the folder which contains the pyproject.toml fileInstall the package via pip (or pip3, depending on your environment)If you intend to implement your own modification, installing in editable mode (-e) is a helpful approachpip install -e .UsageGUIAfter installation, you can use the graphical user interface through the terminal by typing:comet-guiIf you want to explore the toolbox with example data, you can load thesrc/comet/resources/simulation.txtfile which should result in two changing connectivity patterns.ScriptingIf you intend to use the toolbox in a standard python script,demo scriptsare provided as a starting point:Demo script for calculating dFC:click hereDemo script for performing multiverse analysis:click hereDemo script for the multiverse analysis as presented preprint (+ additional visualizations):click hereOutlookThe toolbox is under active development, with various features being underway, e.g.:Addition of state-based dFC methodsMultiverse analysis within the GUIVisualization of resultsIf you have any wishes, suggestions, feedback, or encounter any bugs, please don't hesitate to contact me via email or create an issuehere.
Package: comexdown
comexdown: Brazil's foreign trade data downloaderThis package contains functions to download brazilian foreign trade data
published byMinisterio da Economia(ME)/Secretaria de Comercio Exterior (SCE).Installationcomexdownpackage is available on PyPI, so just usepip!pipinstallcomexdownUsageimportcomexdown# Download main NCM table in the directory ./DATAcomexdown.ncm(table="ncm",path="./DATA")# Download 2019 exports data file in the directory ./DATAcomexdown.exp(year=2019,path="./DATA")Command line toolDownload data on Brazilian foreign trade transactions (Exports / Imports).You can specify a range of years to download at once.comexdown trade 2008:2019 -o "./DATA"Download code tables.comexdowntableall# Download all related code filescomexdowntableuf# Download only the UF.csv filecomexdowntablencm_cgce# Download only the NCM_CGCE.csv filecomexdowntablenbm_ncm# Download only the NBM_NCM.csv fileDevelopmentTo setup a development environment clone this repository and install the required packages:gitclonehttps://github.com/dankkom/comexdown.gitcdcomexdown
pipenvinstall--dev# Requires Python 3.9Run testsTo run the tests suite, use the following command:pytest--cov=comexdown--cov-reportterm-missing--cov-reporthtmltests/
Package: comexio-http
comexio-httpPython implementation for the Comexio HTTP APIDocumentationGo to/admin/api/homeon your Comexio server and enable the HTTP API with a chosen user and password. Enable access for the wanted endpoints.Run the demo script as$ python main.pyThis will prompt you to connect to the Comexio server, and guid you through the proces to get and set variables.LegalLicense: MIT -http://opensource.org/licenses/MIT"Comexio" is a trademark owned by Comexio GmbH, seewww.comexio.comfor more information. I am in no way affiliated with the Comexio organization.
Package: comfoairq-homie
ComfoAirQ-HomieHomie4 for Zehnder ComfoAirQ350/450/600 ventilation unitsUses pycomfoconnect (https://github.com/michaelarnauts/comfoconnect/) and Homie4 (https://github.com/mjcumming/homie4).Installation:Preequirements:Python >= 3.6MQTT broker - Tested with mosquittohttps://mosquitto.org/Python  Wheelspycomfoconnect = 0.4.pip3 install wheel

pip3 install comfoairq-homieCreate configuration in comfoairq_homie.yml file. ComfoAirQ-Homie searches this file in directory from which is started or it is possible to specify it by command line option "-c filename.yml".mqtt:
  MQTT_BROKER: "192.168.88.10"
  MQTT_PORT: 1883
  MQTT_USERNAME: null
  MQTT_PASSWORD: null
  MQTT_KEEPALIVE: 60
  MQTT_CLIENT_ID: null
  MQTT_SHARE_CLIENT: False

comfoconnect:
  COMFOCONNECT_HOST : null
  COMFOCONNECT_PIN  : 0
  COMFOCONNECT_NAME : "ComfoConnect Homie Gateway"
  COMFOCONNECT_UUID : "00000000000000000000000000000006"
  COMFOCONNECT_AUTOCONNECT : True
  COMFOCONNECT_MIN_LOW_FLOW : 90 # MIN AIR FLOW AT LOW SPEED - 90 m3/h for Q450. Check  Installer menu in original App
  COMFOCONNECT_MAX_HIGH_FLOW : 450  # MAX AIR FLOW for Q450 

comfoairq_homie:
  HOMIE_ID              : zehnderq450
  HOMIE_NAME            : ZehnderQ450Usage examples:comfoairq-homieorpython3 -m comfoairq_homiespecifying config file, logging to additional filecomfoairq-homie -c config_file.yml -l optional_log_file.logSeting log level using environment variables. Different log level for pycomfoconnect library and other librariesCOMFOAIRQ_LOGLEVEL=ERROR  COMFOAIRQ_COMFOCONNECT_LOGLEVEL=DEBUG comfoairq-homie -c comfoairq_homie.yml -l comfoairq_homie.logSystemd service file example:[Unit]
Description="Homie4 ComfoAirQ Service"
After=syslog.target network.target mosquitto.service openhab2.service


[Service]
WorkingDirectory=/opt/comfoairq/
Environment=COMFOAIRQ_LOGLEVEL=INFO
Environment=COMFOAIRQ_COMFOCONNECT_LOGLEVEL=INFO
Environment=PATH=/opt/comfoairq/virtualenv/bin:$PATH
ExecStart=/opt/comfoairq/virtualenv/bin/comfoairq-homie -c /opt/comfoairq/config/comfoairq_homie.yml -l /opt/comfoairq/log/comfoairq_homie.log
Restart=always

[Install]
WantedBy=multi-user.target
Package: comform
ComForm: Python Comment Conformity FormatterAn auto-formatter for pretty and readable comment formatting in python.WARNING:comformis made for my own usage so it's not been tested in a variety of
environments. Use it on your own code at peril;).Comments are formatted as markdown text using the fantasticmdformatpackage. Treating comments as
markdown has drawbacks, but I've found these to be outweighed.UsageThis package can be installed from PyPI as usual viapip install comformand is meant
to be used as a command line tool. It can also be used as apre-commithook. Whichever
waycomformis used I recommend runningblackfirst; it was mainly developed for
this use-case.The command line interface is:comform[-h][--version][--check][--align][--dividers][--wrapN]paths[paths ...]and inputs can also be configured inpyproject.toml:[tool.comform]# these are the default values:check=falsealign=falsedividers=falsewrap=88check,alignanddividersare considered enabled if they are set in the CLIorthe config. Ifwrapis set in both then the CLI takes priority.To usecomformas apre-commithook add the following to your.pre-commit-config.yaml:-repo:https://github.com/j-hil/comformrev:0.1.1hooks:-id:comformDevelopmentToo see my development process seedevelopment.md.
Package: comforticons
ComforticonsThis package is an identicon generation module for different identicon/icon/gravatar/avatar flavors.Seelibravatar projectandgravatar project.This module is heavly inspired bybitverseio's PHP Identicon Generatorarchitecture/generators andazaghal's pydenticon package(gravatar retro-like identicon generator).SourceLink to source.RequirementsPython 3.8+pillow 9.5+InstallationThis module is available onpypi.org.pip install comforticonsFeaturesModular Identicon factory architecturepreprocessorslist andgeneratorclass powered identicon generationAbstract/Interface implementations for data preprocessor and identicon generatorPillow 9.5+ supportMyPy typings supportRoadmapASCII-denticon generation inthis package.SVG support forring identiconinthis packagewithsvglib project.More programmer-friendly generator architecture (choose return type - PIL.Image, bytes), (direct writing to file).Djangointegration.Self-hosting solution for small ecosystems with FastAPI.Custom error classes implementation.UsageInteractivepython3 -m comforticonsBasicfromcomforticonsimportIdenticon# Customize preprocessors and generator settings heregenerator=Identicon()# This will generate 120x120 with 0 padding PNG identicon# with transparent background 5x5 pixel identicon (retro gravatar)# using PixelGenerator and MD5Preprocessor as defaultidenticon=generator.generate("provide data here")# Save to filewithopen("image.png","wb")asfile:file.write(identicon)AdvancedfromcomforticonsimportIdenticonfromcomforticons.preprocessors.hashimport*# *Preprocessorfromcomforticons.generators.imageimport*# PixelGenerator# Customize preprocessors and generator settings heregenerator=Identicon(# First, process data with md5, then with sha1preprocessors=[MD5Preprocessor(),SHA1Preprocessor],generator=PixelGenerator(size=10,# 10x10 gridforeground_colors=["#ffffff"],# Only use white foregroundbackground="#000000",# black, non-transparent backgroundimage_format="png",# PNG image formatinvert=True,# This will swap bg-fg colors))# Actually generate identiconidenticon=generator.generate("provide data here")# Save to filewithopen("image.png","wb")asfile:file.write(identicon)ExamplesMD5Preprocessor+PixelGenerator"identicon"SHA1Preprocessor+PixelGenerator"identicon"LicensingSeeLICENCE.Also seethis LICENCE.
Package: comfortpy
Package to calculate thermal discomfort severity under several thermal definitions (e.g. traditional PMV and Adaptive thermal comfort, sleep comfort, occupant health and safety limits, etc.).Please cite us if you use this package: Salimi S, Estrella Guillén E, Samuelson H. Exceedance Degree- Hours: A new method for assessing long- term thermal conditions. Indoor Air. 2021;00:1–16.https://doi.org/10.1111/ina.12855Free software: MIT licenseInstallationpip install comfortpyInstructionsWith this package, you can get the discomfort severity associated with a large set of comfort parameters. Please follow these steps:Step 1- After installing the package, please download the following files:mainPMV model_template—->if working with PMV comfort modelAdaptive model_template—->if working with Adaptive comfort modelStep 2- Open the downloaded .csv file relative to your project. For instance, if you are working with adaptive thermal model, openAdaptive model_template.csvfile. Columns represent comfort parameters related to the selected comfort model (i.e., PMV or Adaptive) along with date and time. It’s important that the order of columns remains unchanged. For your reference each template contains some example data, please replace them with your data. If you do not have data for a certain parameter, simply fill the missing data with a representative value. Every row must contain a value for each column.Step 3- Run themainfile. A file nameddiscomfort_severities_PMV.csvordiscomfort_severities_Adaptive.csv(depending on the selected comfort model) will be automatically saved in the same directory as the downloaded files are located. The file contains all the discomfort severities.
Package: comfy-api-simplified
Comfy API SimplifiedThis is a small python wrapper over theComfyUIAPI. It allows you to edit API-format ComfyUI workflows and queue them programmaticaly to the already running ComfyUI.I use it to iterate over multiple prompts and key parameters of workflow and get hundreds of images overnight to cherrypick from.LimitationsOnly Basic auth and no auth (for local server) are supported.Installpip3 install comfy_api_simplifiedUse prerequisitsPrepare workflowYou would like to have your node titles unique. Usually both positive and negative prompts have title "CLIP Text Encode (Prompt)", you would like to at least give them different names in case you would like to change it's parameters from python.Enable "dev options"In ComfyUI settings, check "Enable Dev mode Options":Download your workflow in API-formatHave running ComfyUI serverUsefromcomfy_api_simplifiedimportComfyApiWrapper,ComfyWorkflowWrapper# create api wrapper using your ComfyUI url (add user and password params if needed)api=ComfyApiWrapper("http://127.0.0.1:8188/")# create workflow wrapper using your downloaded in api format workflowwf=ComfyWorkflowWrapper("workflow_api.json")# change anything you like in your workflow# the syntax is "Node Title", then "Input param name", then valuewf.set_node_param("Empty Latent Image","batch_size",2)wf.set_node_param("negative","text","embedding:EasyNegative")# queue your workflow for completionresults=api.queue_and_wait_images(wf,"Save Image")forfilename,image_datainresults.items():withopen(f"{filename}","wb+")asf:f.write(image_data)More examples:Queue prompt and get result imagesexample.Queue many prompts and do not wait for completionexample.Send input image and then call i2i workflowexample.Additional infoThere are some other approaches to use Python with ComfyUI out there.If you are looking to conver your workflows to backend server code, check outComfyUI-to-Python-ExtensionIf you are looking to use running ComfyUI as backend, but declare workflow in Python imperatively, check outComfyScript.Known issuesIf you try to run queue_and_wait_images in async method, it may give you an error since there is already async code inside.
As a workaround, you can useimportnest_asyncionest_asyncio.apply()for now.