Saravanan666/pypi-org huggingface dataset:
Package: heat-desalination
HEATDesalinationSimulation and optimisation of hybrid electric and thermal powered desalination systemsTable Of Contents:link:Dependencies:clap:AcknowledgementsDownloading HEATDesalination🐍Setting up your Python environmentAnaconda methodPip install🌦️PVGIS:memo:Completing input filesLocation-based filesSystem-based files:fire:Running HEATDesalinationFetching weather dataRunning a simulationRunning an optimisationParallel simulation and optimisation🎓Running HEATDesalination on Imperial College London's high-performance computers:memo:ReferencesDependenciesThis module imports libraries from:The open-sourcepvlibPython package developed by Holmgren, Hansen and Mikofski[1].This module integrates with the open-source PVGIS framework, developed by Huld et al.,[2].AcknowledgementsThis repository uses code developed by theCLOVER-energyteam by Winchester et al.(2022). Thanks to all at the@CLOVER-energy/clover-development-teamfor their work.Downloading HEATDesalinationSetting up your Python environmentAnaconda methodPip installPVGISCompleting input filesLocation-based filesSystem-based filesRunning HEATDesalinationFetching weather dataRunning a simulationRunning an optimisationParallel simulation and optimisationRunning HEATDesalination on Imperial College London's high-performance computersReferences[1]Holmgren W.F., Hansen C.W., Mikofski M.A., pvlib python: a python package for modeling solar energy systems. Journal of Open Source Software 2018;3:884.https://doi.org/10.21105/joss.00884[2]Huld, T., Müller, R. and Gambardella, A., 2012. "A new solar radiation database for estimating PV performance in Europe and Africa". Solar Energy, 86, 1803-1815.http://dx.doi.org/10.1016/j.solener.2012.03.006[3]Winchester, B., Beath, H., Nelson, J., & Sandwell, P. (2022). CLOVER (Version v5.0.5) [Computer software].https://doi.org/10.5281/zenodo.6925535
Package: heatequation
heatequation provides a single class HeatEquation to calculate heat transfer in a matrix of heterogeneous materials. It implements an incremental, arithmetic solution to the heat equation[3]. This solution allows you calculate the system state at any point in time by calculating the system state at all increments up to that point.  It only implements a two dimensional solution of the heat equation, though someone could relatively easily extend it to one or three dimensions.The HeatEquation class is initialized with arrays corresponding to physical properties in the physical space of the simulated materials. The required arrays are initial temperature, mass density, thermal conductivity, and specific heat capacity.The source repository at github[4]includes a sample script to help you get started.[3]https://en.wikipedia.org/wiki/Heat_equation[4]https://github.com/worden341/heatequation
Package: heater
heaterheater makes heatmaps.  Inspired by heatmappy but more light weight.Installationpip install heaterUsagefromheaterimportmake_heatmapwithopen("background.png")asf:heatmap=make_heatmap(f,[(1,2),(3,4)])heatmap.save("output.png")Licenseheater is licensed under Apache 2.0.  Please seeLICENSEfor licensing details.
Package: heatfall
Heatfall: Easy to use functions for plotting heat maps of geographic data on static mapsWhat is it?Heatfallis a Python package with easy to use functions for plotting heat maps of geographic data on a static map.Where to get itThe source code is currently hosted on GitHub at:https://github.com/eddiethedean/heatfall# PyPIpipinstallheatfallDependenciespy-staticmaps - A python module to create static map images (PNG, SVG) with markers, geodesic lines, etc.PyGeodesy - A pure Python implementation of geodesy tools for various ellipsoidal and spherical earth models using precision trigonometric, vector-based, exact, elliptic, iterative and approximate methods for geodetic (lat-/longitude), geocentric (ECEF cartesian) and certain triaxial ellipsoidal coordinates.Exampleimportheatfalllats=[27.88,27.92,27.94]lons=[-82.49,-82.49,-82.46]heatfall.plot_heat_hashes(lats,lons,4)
Package: heatgeo
Start with HeatGeoThe Heat-Geodesic embedding preserves the heat-geodesic dissimilarity
defined asd_t(x_i,x_j) = \bigg[ -4t \log (\mathbf{H}_t)_{ij} - \sigma 4 t \log(\mathbf{V})_{ij} \bigg] ^{1/2},where $\mathbf{H}_t$ is a heat kernel on a graph, and $\mathbf{V}$ is
a volume regularization term. This dissimilarity is inspired by
Varadhan’s formula which relates the heat kernel to the geodesic
distance on a manifold. For more details on the heat-geodesic
dissimilarity read our preprintA Heat Diffusion Perspective on
Geodesic Preserving Dimensionality
Reduction.NoteWe are currently updating this repository to provide examples and
improve the documentation.InstallThe package is not yet available with pip or conda. To install it, you
can clone this repo and install fromsetup.py.gitclonehttps://github.com/KrishnaswamyLab/HeatGeo.gitcdHeatGeo
pipinstall-e.To reproduce the results inexperiments/or try the embeddings with
different graph constructions, you need additional packages that can be
installed via the development version. In this case runcdHeatGeo
pipinstall-e'.[dev]'We provide an example below.How to useGoogle colab example on the swiss rollThe directoryexperimentscontains code to reproduce our main results.
We usedhydra, the parameters can be changed inconfigor directly
in the CLI. Innotebooks, we provide examples on toy datasets.ContributingWe are usingnbdevfor this package and the documentation. See thisintroductionto start
usingnbdev. The code and documentation should be modified in the
notebooksnbs/, then runnbdev_preparebefore a commit. This command
will export the notebooks to.pyfiles inheatgeo, it will also
clean the metadata, and run some test. The page will then automatically
be deployed through GitHub actions.AcknowledgementsThis repository is a simplified version of a larger codebase used for
development. It loses the original commit history which contains
contributions from other authors of the paper. This repository uses or
modify code from the PHATEimplementation, and the
Chebychev polynomialsimplementationof the paperFast Multiscale Diffusion on
Graphs.
Package: heatgraphy
❗We are in beta, API may change and bugs expectedCreate x-layout visualization!Quick start in the browser without a line of code!Open AppRead DocumentationInstallationpipinstallheatgraphyExamplesStacked BarHeatmapOncoprintDeploy yourselfThe web version of heatgraphy cannot handle large traffic,if you want a more fluent experience,
you can easily deploy it yourself or run it locally.You only need 3 steps:Clone this repository:git clone https://github.com/Heatgraphy/heatgraphy.gitInstall dependencies:pip install -r app/requirements.txtLaunch:streamlit run app/Home.py
Package: heatherrd
A simple Python microservice that turns RTM into a synchronous HTTP interface.$ pip install heatherrd
$ heatherrd --listen=tcp:8001 --url=http://example.com/callback-url/$ curl --user <bot-user-id>:<bot-access-token> http://localhost:8001/connectI’ll maintain the RTM connections for the bot and relay incoming RTM messages
as JSON to the URL provided.The URL can echo a list of RTM responses as JSON which will be sent back
over the RTM connection as a reply.
Package: heatmap
heatmap 1.0jjg@case.eduBuild heatmaps in python.  Requires the Python Imaging Library.Minimal example in examples/example.py.  Full readme athttp://jjguy.com/heatmap/CHANGELOG2.2.1 - 11 Jan 12pip install bugfix.  sorry pip folks!  thanks to Jordi Llonch again for the bugfixbugfix in the area parameter for non-square areas; thanks to github.com/y3pp3r2.2 - 2 Oct 12modifed API to return Image instance; caller must specify filenamerestructured project layout to be more standardizedmany thanks to Jordi Llonch (llonchj@gmail.com, github.com/llonchj) for the pull request2.1.1 - 27 Sep 12added install support for cygwinfixed gross omission of KML outputfixed bug in min computation with negative values2.1 - 20 Sep 12fixed bug that flipped x/y coordinates - thanks to Curt Hartung for the find and fixadded area parameter to allow caller to specify data bounds - thanks to Alex Little for the design.various small cleanups2.0 - 17 Sep 12moved heavy lifting into C module.  Compiles on POSIX systems,
pre-compiled DLLs provided for x86 and x64 Windows systems.1.1 - 31 Jan 10modified _colorize() to not use putpixel;
reduced processing time for 1024x1024 image from 14s to 5s1.0Initial release
Package: heatmapanimation
heatmapanimationPython package for generating heatmap animation with given data and geojson.English|简体中文IntroductionIf you want to generate a heatmap animation with given data and geojson file or url,
you can use this package.
You can also type the region name or code replacing the geojson file.Use高德地图地理/逆地理编码get the region code.Use阿里云数据可视化平台get the geojson file.Note: Currently, the region name must be in Chinese.Installpip install heatmapanimationUsageimport heatmapanimation as hma

heatmap = hma.Heatmap() # create a heatmap object

# set the configuration
heatmap.region = '北京'
heatmap.datafile = './data/data.csv'
heatmap.run_x() # run the animationAPI Referenceclassheatmapanimation.Heatmap()You must set a region and datafile before run the animation.regionThe region name you want to generate the heatmap animation.
Must be type Chinese region in Chinese.region_codeThe region code you want to generate the heatmap animation.
Must be type Chinese region code.region_urlThe url of the geojson file.Or the geojson file path.datafileThe data file path.dataThe data you want to generate the heatmap animation.Options: dict or list or json or pandas.DataFrame.output_formatThe output format of the animation.Options: 'gif' or 'mp4'.fig_nameThe name of the output file.Note: If you don't set the fig_name, the output file will be named as the region name.color_mapThe colormap of the heatmap.Options: 'Blues', 'BuGn', 'BuPu', 'GnBu', 'Greens', 'Greys', 'Oranges', 'OrRd', 'PuBu'.All the colormaps are inmatplotlib.Default: 'Reds'isLegendWhether to show the legend.Options: True or False.Default: False.legend_labelThe label of the legend.Options: str.Default: 'Temperature'.legend_locationThe location of the legend.Options: 'right' or 'right'.Default: 'right'.legend_minThe min value of the legend.Options: int or float.Default: the minimum of the data.legend_maxThe max value of the legend.Options: int or float.Default: the maximum of the data.run_x()Run the animation and generate frame image and synthetic GIF. Currently,
the output format is only 'gif'.run()Run the animation with another method which can not show the legend. But the output format
is gif, mp4, jshtml and html5.LicenseMIT
Package: heatmapcluster
heatmapclusteris a python library for generating a clustered heatmap
with dendrograms plotted along with the heatmap, such as the following:This is prototype-quality software.  The documentation is sparse, and the API
will likely change.Plots are generated with matplotlib (http://matplotlib.org/).
To use the package, numpy, scipy and matplotlib must be installed.setuptoolsis required to install the package usingsetup.py.ExampleThis isheatmapcluster_demo.py.  Most of the code is the functionmake_data,
which generates an array of data for the demonstration.  The main part of the
demo is the last three statements of the script.  This script generates the plot
shown above:import numpy as np
import matplotlib.pyplot as plt
from heatmapcluster import heatmapcluster


def make_data(size, seed=None):
    if seed is not None:
        np.random.seed(seed)

    s = np.random.gamma([7, 6, 5], [6, 8, 6], size=(size[1], 3)).T
    i = np.random.choice(range(len(s)), size=size[0])
    x = s[i]

    t = np.random.gamma([8, 5, 6], [3, 3, 2.1], size=(size[0], 3)).T
    j = np.random.choice(range(len(t)), size=size[1])

    x += 1.1*t[j].T

    x += 2*np.random.randn(*size)

    row_labels = [('R%02d' % k) for k in range(x.shape[0])]
    col_labels = [('C%02d' % k) for k in range(x.shape[1])]

    return x, row_labels, col_labels


x, row_labels, col_labels = make_data(size=(64, 48), seed=123)

h = heatmapcluster(x, row_labels, col_labels,
                   num_row_clusters=3, num_col_clusters=0,
                   label_fontsize=6,
                   xlabel_rotation=-75,
                   cmap=plt.cm.coolwarm,
                   show_colorbar=True,
                   top_dendrogram=True)
plt.show()
Package: heatmap-grammar
rpy2-complex-heatmap-grammarPython heatmap interface using intuitive grammar of graphics, implemented as an rpy2 wrapper around ComplexHeatmap package.IntroductionWhat this package is:an exploration in search of the dream API for complex heatmap creationtrying to get the best of Python,ggplot2(/plotnine) andComplexHeatmaporiented towards data exploration in Jupyter notebooks with IPython (-compatible) kernelpushing boundaries for Python-R interoperability viarpy2What this package is NOT:likely not suitable for beginners (if you can get through installation/used rpy2 before you are not a beginner)not a drop-in substitute for ComplexHeatmap for Pythonnot ready for production use (API is subject to change)not affiliated with rpy2 or ComplexHeatmapIntrigued? Check out theexamples.InstallationRequirementsPython >=3.9packages: rpy2, pandas, numpy, IPythonR >=4.1packages: ComplexHeatmapInstallation from PyPI:pip install heatmap-grammarLatest version:pip install git+https://github.com/krassowski/rpy2-complex-heatmap-grammar.git
Package: heatmisercontroller
Python implementation of Heatmiser protocol for serial connected devices.Originally written to get direct access to heatmiser devices. It was created for reading and controlling Slimline-N and Slimline-HWN  thermostats connected to RS232 serial port through RS485 adapter.Documentation usedHeatmiser V3 System Protocol v3.9Supported HardwareMasterSlavePRT-E- Slimline N - 12v Programmable Room Thermostat.PRT-HW- Slimline HWN - 12v Programmable Room Thermostat.Other heatmiser stats could be added with additional configration.Usage
Package: heatmiserv3
heatmiserv3This library has been created from the work carried out by
Neil Trimboy in 2011 here:
[https://code.google.com/p/heatmiser-monitor-control/]The library uses the Heatmiser V3 Protocol to communicate
with a number of thermostatsAs the DCB Structures are different on each thermostat, this
module doesn't yet cover all their intricacies, but with the
connection in place, it provides a raw method of interfacing
directly with the thermostat.I hope to add specific model support as it gets requested.Supported ThermostatsDT/DT-E/PRT/PRT-E/PRT-HWSupported Timing SwitchesThe timing switches have a smaller DCB, but it is possible with
this module to still send raw comamnds to them.TM1/TM1-NOther sensorsHeatmiser have used their V3 protocol in a number of sensors.
Your mileage may vary in attempting to use this library
to communicate with them, but please open a pull request if
you get something working.RequirementsPython needs to be version 3.Packaging and publishingThis library fell out of a little bit of love as I moved out of
the home that had the thermostats.  However, it appears to have
quite a significant following on home-assistant, with a number
of users wanting to benefit from it.  I've therefore tried to
improve the resilience by upgrading the packaging, building and
publishing process to poetry.  This should make the project
easier to contribute to, and align with the latest standards in
the python ecosystem.
Package: heatmiser-wifi
Heatmiser WiFi - python library and toolOverviewAHeatmiserWiFi Thermostat communication tool and library for python.Supported Heatmiser Thermostats are DT, DT-E, PRT and PRT-E.The main class of the library is Heatmiser. It supports retrieval of all Thermostat parameters as a dictionary. It also supports setting of some (but not all) of the Thermostat parameters.Supported platformsThe application is written in Python and has been successfully tested with Python version 2.7 and 3.4.Both Windows and Linux has been tested successfully. Mac OS X has not been tested, but should work as well.InstallationRunpython -m pip install heatmiser_wifiThis will install both the library and the command line tool.Alternatively, since this is just one python file, you can download heatmiser_wifi.py and include it in your project.Using libarySee how the library/class is used in the main() function of heatmiser_wifi.py.Using command line toolTo list all parameters write:heatmiser_wifi -c <pincode> <themostat_ip_address> -lIt is also possible to read and write specific parameters. For instructions, write:heatmiser_wifi -hAuthor and licenseThis application is written by Joel MidstjÃ¤rna and is licensed under the MIT License.
Package: heatprofile
HeatProfileHeatProfileis a Python decorator for profiling the execution time of individual lines within a function. It provides a detailed overview of the function's performance by highlighting each line's cumulative execution time, call count, and average time per call. Additionally, it uses color coding to visually represent the relative time spent on each line, making it easy to spot performance bottlenecks.FeaturesLine-by-Line Profiling: Detailed execution time analysis for each line within the function.Color-Coded Output: Visual representation using colors to indicate lines with higher execution times.Threshold-Based Coloring: Lines with execution times significantly lower than the maximum are displayed with a white background, ensuring clarity in highlighting performance-critical areas.Dynamic Column Widths: Adjusts column widths based on the length of the source code lines, ensuring readability.InstallationTo useHeatProfile, simply copy theheatprofile.pyfile to your project directory.UsageTo profile a function, importheatprofilefromheatprofile.pyand use it as a decorator:fromheatprofileimportheatprofile@heatprofiledefyour_function(args):# function implementationpassRun your Python script as usual, and the profiling output will be displayed in the console.Output FormatFunction Name: Name of the profiled function.Function Location: File location of the function.Total Function Time: Total execution time of the function.Line: Line number in the source code.Source Code: The actual source code of the line.Cumulative Time(s): Total time spent on this line across all calls.Call Count: Number of times this line was executed.Time/Call(s): Average execution time per call for this line.Color CodingRed: Lines with higher relative execution times.White: Lines with negligible execution times compared to the maximum.CompatibilityHeatProfileis compatible with Python 3.x. It has been tested on various platforms with standard Python interpreters.ContributingContributions toHeatProfileare welcome. Please feel free to submit pull requests, report bugs, or suggest features through the GitHub issue tracker.LicenseThis project is licensed under the MIT License - see the LICENSE file for details.
Package: heatshrink2
Compression using theHeatshrink algorithmin Python 3.InstallationFrom PyPI:$ pip install heatshrink2UsageFiles/StreamsThe file interface attempts to imitate the behaviour of the built-infileobject and other file-like objects (E.g.bz2.BZ2File),
thus you can expect all methods implemented infileto also be
available.You can open a heatshrink file by using theopenfunction:>>>importheatshrink2>>>withheatshrink2.open('data.bin','wb')asfout:...fout.write(b"Is there anybody in there?")...26>>>You can also useHeatshrinkFiledirectly:>>>fromheatshrink2importHeatshrinkFile>>>withHeatshrinkFile('data.bin')asfin:...print(fin.read(256))...b'Is there anybody in there?'>>>withHeatshrinkFile('data.bin')asfin:...forlineinfin:...print(line)...b'Is there anybody in there?'>>>Byte stringsThe encoder accepts any iterable and returns a byte string
containing encoded (compressed) data.>>>importheatshrink2>>>heatshrink2.compress(b'a string')b'\xb0\xc8.wK\x95\xa6\xddg'>>>The decoder accepts any object that implements the buffer protocol and
returns a byte representation of the decoded data.>>>importheatshrink2>>>heatshrink2.decompress(b'\xb0\xc8.wK\x95\xa6\xddg')b'a string'>>>ParametersBoth the encoder and decoder allow providingwindow_sz2andlookahead_sz2keywords:window_sz2- The window size determines how far back in the
input can be searched for repeated patterns. A window_sz2 of 8 will
only use 256 bytes (2^8), while a window_sz2 of 10 will use 1024 bytes
(2^10). The latter uses more memory, but may also compress more
effectively by detecting more repetition.lookahead_sz2- The lookahead size determines the max length
for repeated patterns that are found. If the lookahead_sz2 is 4, a
50-byte run of ‘a’ characters will be represented as several repeated
16-byte patterns (2^4 is 16), whereas a larger lookahead_sz2 may be
able to represent it all at once. The number of bits used for the
lookahead size is fixed, so an overly large lookahead size can reduce
compression by adding unused size bits to small patterns.input_buffer_size- How large an input buffer to use for the
decoder. This impacts how much work the decoder can do in a single
step, and a larger buffer will use more memory. An extremely small
buffer (say, 1 byte) will add overhead due to lots of suspend/resume
function calls, but should not change how well data compresses.Check out theheatshrink configuration pagefor more
details.For more use cases, please refer to thetests folder.Command lineThe command line tool can compress and decompress files.Below is an example of the compress and decompress subcommands.$ ls -l tests/files/foo.txt
-rw-rw-r-- 1 erik erik 3970 jan  5 12:23 tests/files/foo.txt
$ python -m heatshrink2 compress tests/files/foo.txt foo.hs
$ ls -l foo.hs
-rw-rw-r-- 1 erik erik 2727 jan  5 12:24 foo.hs
$ python -m heatshrink2 decompress foo.hs foo.txt
$ cmp tests/files/foo.txt foo.txtBenchmarksThe benchmarks check compression/decompression against a ~6MB file:$ python scripts/benchmark.pyTestingRunning tests is as simple as doing:$ python setup.py build_ext -b .
$ python -m unittestLicenseISC license
Package: heatshrinkpy
Compression using theHeatshrink algorithmin Python 3.This library is a pure Python rewrite and a drop-in replacement ofheatshrink2library.It is significantly slower than the native one. It can be used as a fallback if building a native extension is not an
option.InstallationFrom PyPI:$ pip install heatshrinkpyUsagePlease refer to theheatshrink2library for usage and documentation -
just replace heatshrink2 with heatshrinkpy where applicable.LicenseISC license
Package: heat-tempest-plugin
Tests can be run as a tempest plugin against any heat-enabled OpenStack
cloud, however defaults match running against a recent DevStack.To run the tests against DevStack, do the following:# Define DESTexport DEST=/opt/stack# create test resources and write tempest config$DEST/heat/heat_integrationtests/prepare_test_env.sh$DEST/heat/heat_integrationtests/prepare_test_network.sh# run tempest selecting only these testscd $DEST/tempesttempest run –regex heat_tempest_plugin.testsIf custom configuration is required, edit the [heat_plugin] section of$DEST/tempest/etc/tempest.conf