Saravanan666/pypi-org huggingface dataset:
Package: lightwave
lightwavePython library to provide a reliable communication link with LightWaveRF lights, switches and TRVs.InstallationEither clone this repository and runpython setup.py install, or install from pip usingpip install lightwave.APIThis library makes use of the public API provided by lightwave that can be found here:https://api.lightwaverf.com/lighting_power.htmlLights and SwitchesThe library supports the following functions:turn_on_light(device_id, name)
turn_on_switch(device_id, name)
turn_on_with_brightness(device_id, name, brightness)
turn_off(device_id, name)Where:device_idtakes the formR#D#whereR#is the room number andD#is the device number.nameis the text that will be displayed on the hub.brightnessis a value from 0 (off) to 255 (full on).UsageInitialise a link to the hub by passing in the IP address required. Then call a method on the object to modify the device.
The first time a switch is turned on or off the device will attempt to pair to the hub. This should then show a message on your WiFi Link asking you to pair the device. You have 12 seconds to push the button on the WiFi Link to accept this.import asyncio
import time
from lightwave.lightwave import LWLink

async def main():
    lwLink = LWLink('192.168.15.226')

    print("Off")
    ### R1D3 is room 1 device 3
    lwLink.turn_off('R1D3', "Wall Lights")
    lwLink.turn_off('R1D4', "Ceiling Lights")

    time.sleep(5)
    print("On")
    lwLink.turn_on_light('R1D3', "Wall Lights")
    lwLink.turn_on_light('R1D4', "Ceiling Lights")

    time.sleep(5)
    print("Off")
    lwLink.turn_off('R1D3', "Wall Lights")
    lwLink.turn_off('R1D4', "Ceiling Lights")


    time.sleep(5)
    print("On")
    lwLink.turn_on_with_brightness('R1D3', "Wall Lights", 25)
    lwLink.turn_on_with_brightness('R1D4', "Ceiling Lights", 50)
    lwLink.turn_on_switch('R1D1', "Sockets one")
    lwLink.turn_on_switch('R1D2', "Sockets two")


loop = asyncio.get_event_loop()
loop.run_until_complete(main())
loop.close()TRV SupportThe library also supports TRVs with the following function:set_temperature (device_id, temp, name)Where:device_idtakes the formR#D#whereR#is the room number andD#is the device identifier (normallyDh).tempis the target temperature (0.5 increments)nameis the text that will be displayed on the hub.TRV ProxyThe Proxy is now optional.  A built in listener is now available via the async functionLW_listen().Alternativly, to read the TRV status (current temperature, target_temperature, battery status and current output) aLightwave TRV Proxycan be used.
To use the proxy:set_trv_proxy (proxy_ip, proxy_port)
(temp, targ, batt, output) = read_trv_status(serial)Where:proxy_ipis the IP address of the proxyproxy_portis the IP Port of the proxyserialis the serial number of the TRV of interest (NB: This is theserialnumber, and NOTdevice_idthey are different).ContributorsTRV Support byColin Robbins
Package: lightweaver
LightweaverC. Osborne (University of Glasgow) & I. Milić (NSO/CU Boulder), 2019-2021MIT LicenseLightweaver is an NLTE radiative transfer code in the style ofRH.
It is well validated against RH and alsoSNAPI.
The code is currently designed for plane parallel atmospheres, either 1D single columns (which can be parallelised over wavelength) or 1.5D parallel columns withProcessPoolor MPI parallelisation.
There is also support for unpolarised radiative transfer in 2D atmospheres.Lightweaver is described in apaper (including examples!), and hasAPI documentation.Whilst the core numerics are implemented in C++, as much of the non-performance critical code as possible is implemented in Python, and the code currently only has a Python interface (provided through a Cython binding module).
Other languages with a C/C++ interface could interact directly with this core, hopefully allowing it to be reused as needed in different projects.The aim of Lightweaver is to provide an NLTE Framework, rather than a "code".
That is to say, it should be more malleable, and provide easier access to experimentation, with most forms of experimentation (unless one wants to play with formal solvers or iteration schemes), being available directly from python.
Formal solvers that comply with the interface defined in Lightweaver can be compiled into separate shared libraries and then loaded at runtime.
The preceding concepts are inspired by the popular python machine learning frameworks such as PyTorch and Tensorflow.InstallationFor most users precompiled python wheels (supporting modern Linux, Mac, and Windows 10 systems) can be installed frompipand are the easiest way to get started with Lightweaver.
Lightweaver requires python 3.8+, and it is recommended to be run inside a virtual environment usingconda.
In this case a new virtual environment can be created with:conda create -n Lightweaver python=3.8activate the environment:conda activate Lightweaverand Lightweaver can then be installed withpython -m pip install lightweaverInstallation from sourceWhilst the above should work for most people, if you wish to work on the Lightweaver backend it is beneficial to have a source installation.
This requires a compiler supporting C++17.
The build is then run withpython3 -m pip install -vvv -e ..
The libraries currently produce a few warnings, but should not produce any errors.DocumentationPaper.API documentation.I suggest looking throughthe samples repository(in particular theSimple*.py) after the code description in the paper to gain an understanding of the basic functionality and interfaces.
These samples are unfortunately not always up to date, but are a work in progress.TheMsLightweaver repositorycontains a more "production grade" tool built on Lightweaver for reprocessing the time-dependent radiative output from RADYN simulations.
This tool is currently undocumented, but has a relatively simple structure.Please contact me through this repository if difficulties are encountered.AcknowledgementsThepython implementationof the Wittmann equation of state has been kindly provided J. de la Cruz Rodriguez.
Package: lightweb
功能特性Django 请求常用工具安装目前 lightweb 支持的 Python 环境有 3.4+为了简化安装过程，推荐使用 pip 进行安装pipinstalllightweb升级 lightmail 到新版本:pip install -U lightweb如果需要安装 GitHub 上最新代码:pip install https://github.com/ni-ning/lightweb/archive/master.zip使用使用案例:import lightweb
Package: lightweb4py
lightweb4py - A lightweight WSGI framework with Router, CBV, ORM and LoggerThis framework allows for rapid development of applications to deal with HTTP requests from a WSGI server.
It implements:request routing to CBV's (Class-Based Views) that can use Jinja2 templating engine,basic ORM (Object-Relational Mapping) functionality with interfaces to JSON and SQLite, andLogger functionality with console and CSV file output.
There's also a demo app aimed to demonstrate the framework's capabilities (demo/ folder).Detailed framework description is available in its documentation (in Russian language only) (docs/README.md).Description of the demo app is presented in its documentation (in Russian language only) (demo/docs/README.md).lightweb4py - Легкий WSGI-фреймворк с маршрутизацией, CBV, ORM и логгеромФреймворк позволяет с минимальными затратами разработать приложение для работы с HTTP-запросами от
WSGI-сервера и реализует:функциональность маршрутизации запросов в классы-обработчики CBV (Class-Based Views),
использующие шаблонизатор Jinja2,механизм ORM (Object-Relational Mapping, объектно-реляционное отображение данных) с интерфейсом к JSON и SQLite,
а такжелоггер с отображением логов на консоль и сохранением их в текстовый файл CSV.
Также реализовано демонстрационное приложение для демонстрации возможностей фреймворка (папка demo/).Детальное описание фреймфорка приведено в его документации (docs/README.md).Описание демонстрационного приложения приведено в его документации (demo/docs/README.md).
Package: lightweight
lightweight: a static site generatorCode over configuration.DocumentationExamplesFeaturesJinja2 templatesMarkdown rendering with YAML frontmatterSass/SCSS renderingDev serverTemplate projectClean extensible APIFast EnoughFails FastInstallationAvailable fromPyPI:pipinstalllightweightQuick ExamplefromlightweightimportSite,SiteCli,markdown,paths,jinja,template,sassdefblog_posts(source):post_template=template('_templates_/blog/post.html')# Use globs to select files. # source = 'posts/**.md'return(markdown(path,post_template)forpathinpaths(source))defexample(url):site=Site(url)# Render an index page from Jinja2 template.site.add('index.html',jinja('index.html'))# Render markdown blog posts.[site.add(f'blog/{post.source_path.stem}.html',post)forpostinblog_posts('posts/**.md')]site.add('blog.html',jinja('posts.html'))# Render SASS to CSS.site.add('css/global.css',sass('styles/main.scss'))# Include a copy of a directory.site.add('img')site.add('fonts')site.add('js')returnsitedefgenerate_prod():example(url='https://example.org/').generate(out='out')if__name__=='__main__':# Run CLI with `build` and `serve` commands.SiteCli(build=example).run()Create a new projectInitialize a new project usinginitcommand:lwinit--urlhttps://example.orgexampleIt accepts multiple optional arguments:lw init -h
usage: lw init [-h] [--title TITLE] location

Generate Lightweight skeleton application

positional arguments:
  location       the directory to initialize site generator in

optional arguments:
  -h, --help     show this help message and exit
  --title TITLE  the title of of the generated siteDev ServerLightweight includes a simple static web server with live reload serving atlocalhost:8080:python-mwebsiteserveHerewebsiteis a Python moduleHost and port can be changed via:python-mwebsiteserve--host0.0.0.0--port80The live reload can be disabled with--no-live-reloadflag:python-mwebsiteserve--no-live-reloadOtherwise every served HTML file will be injected with a javascript that polls/__live_reload_id__.
The script triggers page reload when the value at that location changes.
The/__live_reload_id__is changed after regenerating the site upon change in--sourcedirectory.To stop the server pressCtrl+Cin terminal.
Package: lightweightdebugmessages
LightweightDebugMessagesTheLightweightDebugMessagesclass is a lightweight class that adds a
simple console printing for debugging messages that can be enabled or
disabled via a parameter to classes by inheritingLightweightDebugMessagesas a superclass to a user class.Documentation and User GuideSee theUser Guidefor detailed documentation on the package.
This includes the API docs, user guide, and examples.HistoryLightweightDebugMessagesis pulled fromConfigParserEnhancedinto its
own module because it is an interesting and useful class. Splitting these up
was the intent from the beginning when it was originally developed.UpdatesSeeCHANGELOGfor information on changes.
Package: lightweight-environ
lightweight-environSimple and lightweight environment variable ingestion. No dependencies.Designed for use with Django but it should be suitable for any Python 3 framework / project.installpipinstalllightweight-environusageGiven an environment:MY_STRING=ford_prefect
MY_INTEGER=42
MY_FLOAT=6.283
MY_BOOLEAN=True
MY_LIST=DONT,PANICfromlightweight_environimportEnv# Raises a KeyError exception if a variable does not exist>>>Env.get('A_MISSING_VAR')Traceback...# first optional arg is a default returned if a variable does not exist>>>Env.get('A_MISSING_VAR','foo')'foo'# get() returns a string>>>Env.get('MY_STRING')'ford_prefect'# get() _always_ returns a string>>>Env.get('MY_INTEGER')'42'# integer coersion>>>Env.int('MY_INTEGER')42# boolean coersion>>>Env.bool('MY_BOOLEAN')True# Reading via bool does not raise a KeyError exception if a variable does not exist - it returns false>>>Env.bool('A_MISSING_VAR')False# All methods support a default for missing keys>>>Env.bool('A_MISSING_VAR',True)True# float coersion>>>Env.float('MY_FLOAT')6.283# list coersion from a string of comma separated values>>>Env.list('MY_LIST')['DONT','PANIC']>>>Env.list('A_MISSING_VALUE','Oh,freddled,gruntbuggly')['Oh','freddled','gruntbuggly']>>>Env.list('A_MISSING_VALUE',['Oh','freddled','gruntbuggly'])['Oh','freddled','gruntbuggly']# has() tests for variable existenceEnv.has('A_MISSING_VALUE')FalseEnv.has('MY_INTEGER')True
Package: lighty
Lighty is a simple all in one web framework writen in Python. It includes:Tool to configure applications using configuration files.Simple ORM to access MongoDB (other databases will be added in future). This
ORM looks close to Django’s ORM.Simple but powerfull and fast template engine almost like Django Templates or
Jinja2.URL routing: can easy resolve urls described in specified format and reverse
urls for view name and arguments taken.Bindings to WSGI and Tornado.It’s not a full list of features. To read more look into documentation.
Package: lighty-template
Lighty-template~~~~~~~~~~~~~~~Lighty-template is very simple template engine for python (python.org).Template syntax looks like django-template or jinja2 template. But templateengine code is easier and gives a way to write all needed tags without anyhacks.Now it does not include all features django-template or jinja2 supports, butI'll try to fix it as soon as possible.Features:---------- Stupid simple syntax almost compatible with django-template.- Pure python.- Supports both Python 2 (checked with 2.7.2) and Python 3 (checked with 3.2.2)- Fast. From 3 to 10 times faster than django-template and even faster on somebenchmarks than jinja2 (but in one benchmark 2 times slower).- Simple and compact code.- Template filters with multiply arguments.- Basic template filters included (now just 14 template filters).- Basic template tags included.- Simple but powerfull tag declaration - it's easy to create your own blocktags with writing single function.- Custom template tags can modify template on fly.Example:--------Here a small template example:<!DOCTYPE html><html><head><title>{{ title }}</title>{% block style %}{% endblock %}{% block script %}{% endblock %}</head><body>{% block content %}<h1>Hello, {{ name }}!</h1><p>Some text here</p>{% endblock %}{% include "includes/footer.html" %}</body></html>TODO:------ More default tags (now there is no load tags, and if and for tags wassimplified and requires additional work).- More default filters (strings saving, etc.)- Some additional execution optimizations.- More tests (in progress).- Documentation.- Thinking about unicode and escaping.
Package: ligning
LigninGraphs is an open-source software package in Python to generate feasible lignin structures.Lignin is an aromatic biopolymer found in ubiquitous sources of woody biomass such as wood and bark.
Designing and optimizing lignin valorization processes requires a fundamental understanding of lignin structures.
We introduce a graph-based multiscale modeling framework for lignin structure generation and visualization.
The framework employs accelerated rejection-free polymerization and hierarchical Metropolis Monte Carlo optimization algorithms.
It can be used to generate feasible lignin strutcures to match experimental or literature data.DocumentationSee ourdocumentation pagefor examples, equations used, and docstrings.DevelopersYifan Wang (wangyf@udel.edu)Jake Kalscheur (jkalsch@udel.edu)DependenciesPython >= 3.7RDKit>= 2021.09.1: Used for constructing feasible chemical structuresNetworkx>= 1.4: Used for computational graph operationsPysmiles>= 1.0.1: Used for reading and writing smiles strings from/to graphsMatplotlib: Used for generating plotsNumpy: Used for vector and matrix operationsScipy: Used for curve fittingPandas: Used to import data from Excel or CSV filesopenpyxl: Used by Pandas to import Excel filespytest: Used for unit testsGetting StartedInstall using pip (see documentation for full instructions):pip install ligningRun the unit tests.Read the documentation for tutorials and examples.LicenseThis project is licensed under the MIT License - see the LICENSE.md.
file for details.ContributingIf you have a suggestion or find a bug, please post to ourIssuespage on GitHub.QuestionsIf you are having issues, please post to ourIssuespage on GitHub.FundingThis material is based upon work supported by the Department of Energy’s Office
of Energy Efficient and Renewable Energy’s Advanced Manufacturing Office under
Award Number DE-EE0007888-9.5.AcknowledgementsSiyi Huang (Logo design)Publications
Package: ligo
LIgOLIgO is a tool for simulation of adaptive immune receptors and repertoires,
internally powered byimmuneML. The README includes quick installation instructions and information on how to run a quickstart. For more detailed documentation, seehttps://uio-bmi.github.io/ligo/.InstallationRequirements: Python 3.11 or later.To install from PyPI (recommended), run the following command in your virtual environment:pip install ligoTo install LIgO from the repository, run the following:pip install git+https://github.com/uio-bmi/ligo.gitTo be able to use Stitcher to export full-length sequences, download the database after installing LIgO:stitchrdl -s humanUsageTo run LIgO simulation, it is necessary to define the YAML file describing the simulation. Here is
an example YAML specification, that will create 300 T-cell receptors. The first 100
receptors will contain signal1 (which means all of these 100 receptors will have TRBV7 gene andASsomewhere in the receptor sequence), the next 100 receptors will contain signal2 (sequences will containG/Gwith the gap denoted by '' sign and the gap size between 1 and 2 inclusive), and the final 100 receptors
will not contain any of these signals.definitions:motifs:motif1:seed:ASmotif2:seed:G/Gmax_gap:2min_gap:1signals:signal1:v_call:TRBV7motifs:-motif1signal2:motifs:-motif2simulations:sim1:is_repertoire:falsepaired:falsesequence_type:amino_acidsimulation_strategy:RejectionSamplingremove_seqs_with_signals:truesim_items:sim_item1:# group of AIRs with the same parametersgenerative_model:chain:betadefault_model_name:humanTRBmodel_path:nulltype:OLGAnumber_of_examples:100signals:signal1:1sim_item2:generative_model:chain:betadefault_model_name:humanTRBmodel_path:nulltype:OLGAnumber_of_examples:100signals:signal2:1sim_item3:generative_model:chain:betadefault_model_name:humanTRBmodel_path:nulltype:OLGAnumber_of_examples:100signals:{}# no signalinstructions:my_sim_inst:export_p_gens:falsemax_iterations:100number_of_processes:4sequence_batch_size:1000simulation:sim1type:LigoSimTo run this simulations, save the YAML file above as specs.yaml and run the following:ligo specs.yaml output_folderNote thatoutput_folder(user-defined name) should not exist before the run.
Package: ligo-calibplot
CalPlotEventually, this repository will serve as a tool (mostly likely a python package) to facilitate querying and plottling influx data for quick and easy LIGO calibration monitoring. Currently, this project is in the early development stage, will change frequently, and most builds will be unstable.Current featuresQuerying influxDB data via LIGO scald for arbitrary measurments and fields.Filtering queried data based on arbitrary conditions placed on measurements and fields such as time ranges, lock status, and data channelsQuery results are returned in Pandas DataFrames for easy manipulation and data organizationVERY rough plotting script to plot queried data.
Package: ligo.em-bright
ligo.em_brightThis library provides the tools to compute the possibility of merging gravitational-wave binaries to have an electromagnetic counterpart or having a component in the lower mass-gap region. The data products are source propertiesHasNS: The mass of at least one of the compact binary coalescence is consistent with a neutron star.HasRemnant: A non-zero amount of remnant matter remained outside the final compact object (a necessary but not sufficient condition to produce certain kinds of electromagnetic emission such as a short GRB or a kilonova).HasMassGap: The mass of at least one of the compact binary coalescence is consistent with lower mass-gap region i.e. between 3-5 solar mass.TheHasNSandHasRemnantquantities depend on, and are marginalized over, several neutron star equations of state (EOS). The marginalization is done using data fromGW170817.
Package: ligo-gracedb
The Gravitational-wave Candidate Event Database (GraceDB) is a web service designed for aggregating and communicating information about candidate events from gravitational-wave searches and associated follow-ups.ligo-gracedbprovides a Python-based client tool for facilitating interactions with the GraceDB API.DocumentationFor more information, see thefull documentation.Quick installpipinstallligo-gracedbContributingPlease fork thisrepositoryand submit a merge request if you wish to contribute to this package.See thecontributing documentationfor more details.
Package: ligoogle
LiGoogle DocsThis package allows you to open google on the Linux terminal.InstallationYou can install it via pip using:pip3 install ligoogleUsageYou open ligoogle by typing:python3 -m ligoogleThen the ligoogle cli pops up. Then type your search term and it should take a very short peroid of time till the results appear.The LiGoogle appIf you searchcommand:appon ligoogle, something will popup. It looks a bit like this:You add your search term and a RapidAPI api key and then, it will take about 4 seconds to open a new window with the JSON result.This is great for people who do not want the terminal but want the JSON results.Copyright (c) Arjun J
Package: ligo-rrt-chat
ChatCreate a mattermost chat for discussing superevents.UsageThis current version uses a superevent_id information
to make mattermost channels. It only works if the .netrc
file has a "mattermost-bot" login with appropiate token as password.If the channel creation succeedes, the new channel
name will beRRT O4 {superevent_id}. A post will be
made in this channel with a corresponding
grace_db url. Raises exceptions in case of failures.from ligo.rrt_chat import channel_creation
import json

channel_creation.rrt_channel_creation(superevent_id, gracedb_url)
Package: ligo.skymap
Theligo.skymappackage provides tools for reading, writing, generating, and
visualizing gravitational-wave probability maps from LIGO and Virgo. Some of
the key features of this package are:Command line tool bayestar-localize-coincsandbayestar-localize-lvalert: BAYESTAR, providing rapid, coherent, Bayesian,
3D position reconstruction for compact binary coalescence eventsCommand line tool ligo-skymap-from-samples: Create 3D sky maps from
posterior sample chains using kernel density estimationCommand line tool ligo-skymap-plot: An everyday tool for plotting
HEALPix mapsModule ligo.skymap.plot: Astronomical mapmaking tools for
perfectionists and figure connoisseursTo get started, see theinstallation instructionsor thefull
documentation.This illustration of the position of GW170817, prepared usingligo.skymap,
illustrates the main features of this package: rapid localization of compact
binaries with BAYESTAR[1], three-dimensional density estimation[2][3], cross-matching with
galaxy catalogs, and visualization of gravitational-wave sky maps.
Reproduced from[4].[1]Singer, L. P., & Price, L. R. 2016,Phys. Rev. D, 93, 024013.https://doi.org/10.1103/PhysRevD.93.024013[2]Singer, L. P., Chen, H.-Y., Holz, D. E., et al. 2016,Astropys. J. Lett.,
829, L15.https://doi.org/10.3847/2041-8205/829/1/L15[3]Singer, L. P., Chen, H.-Y., Holz, D. E., et al. 2016,Astropys. J. Supp.,
226, 10.https://doi.org/10.3847/0067-0049/226/1/10[4]Kasliwal, M. M., Nakar, E., Singer, L. P. et al. 2019,Science, 358, 1559.https://doi.org/10.1126/science.aap9455
Package: ligotimegps
This module provides a pure-python version of theLIGOTimeGPSclass, used to represent GPS times (number of seconds elapsed since GPS epoch) with nanoseconds precision.This module is primarily for use as a drop-in replacement for the 'official'lal.LIGOTimeGPSclass (provided by the SWIG-python bindings ofLAL) for use on those environments where LAL is not available, or building LAL is unnecessary for the application (e.g. testing).The code provided here is much slower than the C-implementation provided by LAL, so if you really care about performance, don't use this module.How to installpipinstallligotimegpsHow to use>>>fromligotimegpsimportLIGOTimeGPS>>>t=LIGOTimeGPS(12345,67890)>>>print(t)12345.00006789