Saravanan666/pypi-org huggingface dataset:
Package: lca-disclosures
lca_disclosuresPython based tools for working with LCA foreground model disclosuresDisclosure framework based on "Disclosure of product system models in life cycle assessment: achieving Transparency and Privacy" by Brandon Kuczenski inJ Ind Ecol. (doi:10.1111/jiec12810)This package was originally authored byJames Joyce.  Code and testing related toBrightway 2have been branched into thelca_disclosures_bw2repository so as to remove dependencies from the core program.  The original repositorylca_disclosuresis still operational.Supported software frameworksThelca_disclosuresrepository supports the generation of a disclosure specification from the following software:lcoptAntelope FrameworkSupport (and testing) for Brightway2 is available in the original repositorylca_disclosures.UsageTo use the disclosure framework, instantiate the appropriateDisclosuresubclass and supply it with the software-specific input data.  The disclosure object can be used to answer questions about the model:listing foreground flows, background flows, and emissions;identifying cutoff flows (flows that exit the model boundary with no impacts);performing an aggregation of the model into a unit processThe disclosure object can also be serialized to JSON or saved as an Excel spreadsheet.Requirementspandas, to write to excelscipy, to perform matrix operationsContents of an LCA DisclosureA disclosure has six parts, including three lists of flows:iAn ordered list of foreground flows, beginning with the functional unit of the system (length =p);iiAn ordered list of flows from background processes or activities (length =n);iiiAn ordered list of environmental or social "emissions" (length =m).And three sparse matrix specifications:ivA list of nonzero entries in thep x psparse matrix defining the foreground;vA list of nonzero entries in then x psparse matrix defining the foreground's dependency on the background;viA list of nonzero entries in them x psparse matrix defining the foreground's direct emissions.A visual representation of the disclosure is found in Figure 3 of the above paper:DevelopmentThe base Disclosure class is abstract, and a subclass must be created for each supported software type.  A subclass must populate the following methods:_prepare_efn()returns the evaluated filename used to store disclosure serializations._prepare_disclosure()returns a 6-tuple corresponding to the 6 disclosure elements, in the order listed above.__init__()must be written to handle input data and then call the superclass__init__, which computes_prepare_disclosure()and stores the output.
Package: lcapygui
# lcapy-guiThis package provides an experimental GUI for Lcapy, lcapy-tk.
Schematics can be created and saved in a number of formats and
symbolic component voltages and currents can be inspected.## Installation
Ensurewheelandsetuptoolsare installed.Runpip install .If running on windows, please ensure you have the latest [Microsoft Visual C++ Redistributable](https://learn.microsoft.com/en-us/cpp/windows/latest-supported-vc-redist?view=msvc-170) installed.To view equations, and export circuit diagrams, please ensure LaTeX is installed.
#### Linux
Please install from your distros package manager.
#### macOS
Usebrewto install texlive.brew install texlive.## How to run
From the console it can be run aslcapy-tk.From a python interpreter it can be run using:from lcapygui import LcapyTk
e = LcapyTk()
e.display()
Package: lcax
LCAxThe goal for LCAx is to make an open, machine and human-readable data format for exchanging LCA results,
EPD's and assemblies.We propose a simple three level data format with information on project, assembly and EPD level,
written in an open data format and paired with a validator for a more robust and standardized format.
We intend to create connections to existing tools and API’s.InstallInstall Python packagespipenvinstall--devLocal Developmentmkdocsserve
Package: lcboapi
Python 3 wrapper for the unofficial LCBO APIFull API documentation for LCBO API can be found at:
[https://lcboapi.com/docs]InstallationVia PyPI:$ pip install lcboapiVia Github:$ git clone https://github.com/shamrt/LCBOAPI.git
$ cd LCBOAPI
$ python setup.py installUsageObtain anaccess keyfrom LCBO API.Initialize API wrapper:fromlcboapiimportLCBOAPIapi=LCBOAPI('your_API_access_key')Get data for store #614:printapi.stores(614)TestingFirst setup your virtual environment:$ virtualenv env
$ . env/bin/activate
$ pip install -r requirements.txtThen set an environment variable for your API access key:$exportLCBOAPI_ACCESS_KEY='your_API_access_key'Finally, run tests:$ py.testVersioning and PublishingRequirements:bumpversion <https://pypi.org/project/bumpversion/>twine <https://pypi.org/project/twine/>Run:$ . env/bin/activate
$ pytest tests/
$ bumpversion [patch/minor/major]
$ python setup.py sdist bdist_wheel
$ python -m twine upload dist/*
Package: lccc_mapper
Locale, currency, and country code mapperPython library for looking up locale, currency, or country code based on one of the other.URLshttps://github.com/peal/lccc_mapperhttp://pypi.python.org/pypi/lccc_mapperExample>>> import lccc_mapper
>>> lccc_mapper.currency_to_country_codes('USD')
['AS', 'BQ', 'IO', 'EC', 'SV', 'GU', 'HT', 'MH', 'FM', 'MP', 'PW', 'PA', 'PR', 'TL', 'TC', 'US', 'UM', 'VG', 'VI']
>>> lccc_mapper.country_code_to_currencies('CH')
['CHF', 'CHE', 'CHW']
>>> lccc_mapper.locale_to_currencies('en_GB')[0]
'GBP'
Package: lc-classifier
Light Curve Classifier LibraryInstalling late_classifierFrom PyPI stable version:pip install numpy Cython
pip install -e git+https://git@github.com/alercebroker/turbo-fats#egg=turbofats
pip install -e git+https://git@github.com/alercebroker/mhps#egg=mhps
pip install -e git+https://git@github.com/alercebroker/P4J#egg=P4J
pip install lc-classifierFor development:git clone https://github.com/alercebroker/lc_classifier.git
python -m pip install -e .How to use the library?Check the available Jupyter notebooks in theexamplesdirectory.FunctionalitiesFeature computationThis library provides an extensive number of feature extractors for astronomical
light curves, including period computation, autoregresive models, parametric models,
statistical features, etc. We also provide tools to transform your data into
the format that this library expects (Pandas dataframes).AugmentationIf you want more samples you can use our ShortTransientAugmenter class.
More data augmentation techniques will be implemented in further releases.ClassifierTwo classifiers are available: A traditional Random Forest model, and a hierarchical
model made from 4 Random Forest classifiers.Preprocessing for ZTF data:Before computing features, we preprocess the time series with filters
and boundary conditions:Drop duplicate observations.Discard noisy detections.Discard bogus.Filter time series with more than 5 detections.Discard invalid values (like nans and infinite).How can I add my own feature extractors to the library?Feature extractors extend the following classes:FeatureExtractorFeatureExtractorSingleBand. This type of feature extractor runs independently
on each available band.Check out the existent feature extractors in the directorylc_classifier/features/extractors.Profile functionalitiesThe easiest way to profile a step is using cProfile, for this we just have to run the step with the following command:python-mcProfile-o<outputfile>profiling/<functionality>.pyAfter that you can runsnakeviz(first install it).snakeviz <outputfile>Test functionalitiesYou must first install the following packages:pipinstallcoveragepytestAll scripts of tests must be intestsfolder. For run all tests:coveragerun--sourcelc_classifier-mpytest-x-stests/If you want run a specify functionality you can run:coveragerun--sourcelc_classifier-mpytest-x-stests/<functionality>After that you can see a report of tests:coveragereportRun a containerThis repository comes with a Dockerfile to test the model.To build the image rundocker build -t alerce/lc_classifierThen run the containerdocker run --rm -p 8888:8888 alerce/lc_classifierThe container comes with a jupyter notebook and some examples inhttp://localhost:8888ReferenceIf you use this library, please cite our work:@inproceedings{sanchez2020alert,
  title={Alert Classification for the ALeRCE Broker System: The Light Curve Classifier},
  author={S{\'a}nchez-S{\'a}ez, P and Reyes, I and Valenzuela, C and F{\"o}rster, F and Eyheramendy, S and Elorrieta, F and Bauer, FE and Cabrera-Vives, G and Est{\'e}vez, PA and Catelan, M and others},
  year={2020}
}
Package: lccm
What Lccm isLccm is a Python package for estimating latent class choice models
using the Expectation Maximization (EM) algorithm to maximize the likelihood function.Main FeaturesLatent Class Choice ModelsSupports datasets where the choice set differs across observations.Allows the analyst to capture correlation across multiple observations for the same respondent (panel data in Revealed Preference contexts and multiple choice tasks in Stated Preference contexts).Supports model specifications where the coefficient for a given variable may be generic (same coefficient across all alternatives) or alternative specific (coefficients varying across all alternatives or subsets of alternatives) in each latent class.Accounts for sampling weights in case the data you are working with is choice-based i.e. Weighted Exogenous Sample Maximum Likelihood (WESML) from (Ben-Akiva and Lerman, 1983) to yield consistent estimates.Constrains the choice set across latent classes whereby each latent class can have its own subset of alternatives in the respective choice set.Constrains the availability of latent classes to all individuals in the sample whereby it might be the case that a certain latent class or set of latent classes are unavailable to certain decision-makers.Where to get itAvailable from PyPi::pip install lccmhttps://pypi.python.org/pypi/lccm/0.1.20For More InformationFor more information about the lccm code, see the following dissertation:El Zarwi, Feras. “Modeling and Forecasting the Impact of Major Technological and Infrastructural Changes on Travel Demand”, PhD Dissertation, 2017, University of California at Berkeley.AttributionIf Lccm is useful in your research or work, please cite this package by citing the dissertation above and the package itself.LicenseModified BSD (3-clause)Changelog0.1.20 (April 21st, 2017)Initial package release for estimating latent class choice models using the Expectation Maximization Algorithm.
Package: lccnorm
LccnormInstallationpip install lccnormUsageImport the package>>> import lccnormGet a normalized version of an LCCN:>>> lccnorm.normalize("75-425165//r75")
'75425165'Check that an LCCN is valid:>>> Lccnorm.is_valid("75425165")
True
>>> lccnorm.is_valid("not even a number")
FalseContributingBug reports and pull requests are welcome on GitHub athttps://github.com/seanredmond/lccnorm-py. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to theContributor Covenantcode of conduct.LicenseThe gem is available as open source under the terms of theMIT License.Code of ConductEveryone interacting in the Lccnorm project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow thecode of conduct.
Package: lcd2usb
ContentsIntroduceUsageRequirementsInstallationLCD2USB’s Python Libraryhome:http://github.com/xyb/lcd2usbPyPI:http://pypi.python.org/pypi/lcd2usbIntroduceThe LCD2USB’s Python Library is a Pure-python wrapper forLCD2USBwhich
provide a simple way to control your LCD2USB display device.LCD2USBis a
open source/open hardware project to connect HD44780 based text LCD displays
to various PCs via USB.UsageConnect a lcd2usb device is easy:>>> from lcd2usb import LCD
>>> lcd = LCD()
>>> lcd.info()
Found LCD2USB device on bus 004 device 004.Get lcd2usb firmware version:>>> lcd.version
(1, 9)Write something on the screen:>>> lcd.write('Hello, LCD2USB!')Clean screen and wirte some on the 2nd row:>>> lcd.clear()
>>> lcd.goto(0, 1)
>>> lcd.write('Flying with PYTHON')Or simpler:>>> lcd.write('Flying with PYTHON', 0, 1)Define a custom smile symbol and display it on the center of first row
(on a 4x20 display):>>> from lcd2usb import SMILE_SYMBOL
>>> lcd.define_char(0, SMILE_SYMBOL)
>>> lcd.write('\0', 9, 0)That it!If you need a quickly running test for your device, use this:python -m lcd2usbRequirementsPython3 requiredctypes(included in Python)libusb-1.0python-libusb1InstallationInstallation is done just as for any other Python library. Using thepiporeasy_installcommand from setuptools is the easiest:pip install lcd2usbOr:easy_install install lcd2usb
Package: lcdata
lcdataTools for manipulating large datasets of astronomical light curvesAboutlcdatais a package for manipulating large datasets of astronomical time series.lcdatais designed to handle very large datasets: it uses a compact internal representation to be able to keep many light curves in memory at the same time. For datasets that are too large to fit in memory, it offers the option of reading them from disks in chunks.lcdataalso contains tools to download different publicly available releases of astronomical time series.Installation and UsageInstructions on how to install and uselcdatacan be found on thelcdata
readthedocs page.
Package: lcd-i2c
LCD I2CUse an I2C LCD with PythonBasic library for interacting with I2C LCD screens. It started off as a Python port of the ArduinoLiquidCristal_I2Clibrary and ended up implementing an object oriented API, for easier use.Tested using a Raspberry Pi Zero 2W.ExamplesConnect to LCD screen and print some text:fromlcd_i2cimportLCD_I2Clcd=LCD_I2C(39,16,2)# Turn on the backlightlcd.backlight.on()# Show the blinking cursorlcd.blink.on()# or:# lcd.cursor.blink.on()# Print some textlcd.write_text('Hola!')
Package: lc-django-autoslug
Django-autoslug is a reusable Django library that provides an improved
slug field which can automatically:populate itself from another field,preserve uniqueness of the value anduse customslugify()functions for better i18n.The field is highly configurable.RequirementsPython 2.7, 3.5 or PyPy.Django 1.7.10or higher.It may be possible to successfully use django-autoslug in other environments
but they are not tested.NotePyPy3 is not officially supported only because there were some problems with
permissions and__pycache__on CI unrelated to django-autoslug itself.ExamplesA simple example:fromdjango.db.modelsimportCharField,ModelfromautoslugimportAutoSlugFieldclassArticle(Model):title=CharField(max_length=200)slug=AutoSlugField(populate_from='title')More complex example:fromdjango.db.modelsimportCharField,DateField,ForeignKey,Modelfromdjango.contrib.auth.modelsimportUserfromautoslugimportAutoSlugFieldclassArticle(Model):title=CharField(max_length=200)pub_date=DateField(auto_now_add=True)author=ForeignKey(User)slug=AutoSlugField(populate_from=lambdainstance:instance.title,unique_with=['author__name','pub_date__month'],slugify=lambdavalue:value.replace(' ','-'))DocumentationSee thecomplete documentationon ReadTheDocs.  It is built automatically for the latest version.CommunityThis application was initially created by Andy Mikhailenko and then improved
by other developers. They are listed inAUTHORS.rst.Please feel free to file issues and/or submit patches.SeeCONTRIBUTING.rstfor hints related to the preferred workflow.LicensingDjango-autoslug is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public License as
published by the Free Software Foundation; either version 3 of the
License, or (at your option) any later version.Django-autoslug 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
Lesser General Public License for more details.You should have received a copy of the GNU Lesser General Public
License along with this program; see the file COPYING.LESSER. If not,
seeGNU licenses.
Package: lcdoc
lcdocLC documentation generatorMarkup Featuressub-documentation for each memberauthomatic code blocks and inline code blocks highlighting usinghighlightjs```cppinti=42```manual syntax highlighting support using user friendly<code-*>tags<pre><code><code-keyword>int</code-keyword><code-var>i</code-var>=<code-number>42</code-number>;</code></pre>LaTex equations rendering usingtex-mathpackage (based onkatex) :inline equation:<i-math>x^2</i-math>equation:<tex-math>i \hbar \frac{\partial}{\partial t} \psi = H \psi</tex-math>dependencies:We uselibclangPython binding, dochere,see also
Package: lcdscreen
This class makes it easy to write messages to your LCD screen via your Raspberry Pi.For a working example of the class, seeexample.py.InstallationInstall from pippip install lcdscreenFrom there you can use it as you wish!from lcdscreen import LCDScreenNext, initialise the class, passing in the parameters as required:lcd = LCDScreen({
        'pin_rs': 25,
        'pin_e': 24,
        'pins_db': [23, 17, 27, 22],
        'backlight': 18,
        'dimensions': [20, 4]
})The defaults are below. If you don’t wish to change anything then you can initilise without passing anything in:config_preset = {
        'pin_rs': 25, # The input of the RS pin
        'pin_e': 24, # The input of the E pin
        'pins_db': [23, 17, 27, 22], # The input of the DB pins
        'backlight': 18, # The input of the Backlight pin
        'dimensions': [20, 4], # How big your screen is [width, height]
        'delay': 3, # The default delay time
        'spacer': ' ' # The default spacer character
        'truncate': '..' # What to add to a truncated string if the message is longer than the screen width
}Once initialised, it’s quite easy to operate. The class is well documented and the exmaple file shows how to use itUsageBacklightTurn the backlight on:lcd.backlight('on')And turn it off:lcd.backlight('off')Messagelcd.message('Your message')Delaylcd.delay() # Delay by default delay time (set in config)
lcd.delay(5) # Delay by 5 seconds
lcd.delay_clear() # Wait default delay time then clear the screen
Package: lcd-st7032
# LCD_ST7032Python module for ST7032 LCD controller with I2C interface.This module is inspired by https://github.com/olkal/LCD_ST7032Tested with RaspberryPi 2, Python 3.6 and AQM1602XA-RN-GBW# usage```$ pip install -r requirements.txt$ pip install lcd_st7032```# Hello World```pythonfrom lcd_st7032 import ST7032lcd = ST7032()lcd.write("Hello World!")lcd.setCursor(1, 0)lcd.write([0xba, 0xdd, 0xc6, 0xc1, 0xdc, '!'])```# LICENSEMIT
Package: lcensemble
Local Cascade Ensemble (LCE)is ahigh-performing,scalableanduser-friendlymachine learning method for the general tasks ofClassificationandRegression.In particular, LCE:Enhances the prediction performance of Random Forest and XGBoost by combining their strengths and adopting a complementary diversification approachSupports parallel processing to ensure scalabilityHandles missing data by designAdopts scikit-learn API for the ease of useAdheres to scikit-learn conventions to allow interaction with scikit-learn pipelines and model selection toolsIs released in open source and commercially usable - Apache 2.0 licenseAn article introducing LCE and illustrative code examples has been published inTowards Data Science.InstallationLCE package can be installed usingpip:pip install lcensembleDocumentationLCE documentation, including API documentation and general examples, can be foundhere.ReferenceThe full information about LCE can be found in the associatedjournal paper:[1]Fauvel, K., E. Fromont, V. Masson, P. Faverdin and A. Termier. XEM: An Explainable-by-Design Ensemble Method for Multivariate Time Series Classification. Data Mining and Knowledge Discovery, 36(3):917–957, 2022
Package: lcep-package
lcep-packagePython package for lcep.Free software: MITDocumentation:https://lcep-package.readthedocs.io.FeaturesTODOCreditsThis package was created withcookietempleusingCookiecutter.ChangelogThis project adheres toSemantic Versioning.2.0.1 (2021-04-08)AddedFixedDependenciesDeprecated2.0.0 (2021-04-08)AddedAdded model (v2) trained on recount2 TCGA/GTEx liver(cancer) data obtained from mlf-core/lcepReplaced test dataFixedDependenciesDeprecated1.2.0 (2020-08-28)AddedAdded flag –cuda and –no-cuda to enable and disable GPU predictionFixedDependenciesDeprecated1.1.0 (2020-08-28)AddedFixedhelp command messageDependenciesDeprecated1.0.0 (2020-08-28)AddedParsing of an appropriate data input fileLoading an already trained model and performing predictionsWriting the predictions to an output fileFixedDependenciesDeprecated0.1.0 (2020-08-28)AddedCreated the project using cookietempleFixedDependenciesDeprecated
Package: lcexoplanet
lcexoplanetLigth Curves for ExoplanetsDocumentation:https://diegohs79.github.io/lcexoplanetSource Code:https://github.com/DiegoHS79/lcexoplanetThis is a package to manage exoplanets light curves.Downloading FITS filesWe can directly download files just providing the space mission and the ID number of the mission:fromlcexoplanet.utilsimportSpaceMissionFitsDownloadSpaceMissionFitsDownload("k2","220522664")OutputYouhaveselected:220522664objectfromK2SpaceMission⤷objectavailableinc8:downloadingktwo220522664-c08_llc.fitsinto/Users/username/.lcexoplanet/fits/k2/c8The package will create a folder structure into your local "username" to download a single FIT file.If, for instance, the mission k2 have more than one FITS files in different campaigns, it will download all those files in its folders.