Saravanan666/pypi-org huggingface dataset:
Package: lc-flask-reqparser
flask-reqparser-pyOverviewThe Flask web framework provides access to request parameters viaflask.request.argsforGETrequests and viaflask.request.formforPUTandPOSTrequests.
Requiring certain parameters be present for an endpoint, or parsing parameters as custom types, necessitates extra logic to process values from the aforementioned
dictionaries and is error-prone.  However, API endpoints can act much like command line interfaces, and Python has solved that problem
fairly will with theargparselibrary.flask-reqparser-pyexposes aRequestParserclass
that allows you to define a parser for request arguments, and access them like regular command line arguments.InstallationInstall from PyPi (preferred method)pipinstalllc-flask-reqparserInstall from GitHub with Pippipinstallgit+https://github.com/libcommon/flask-reqparser-py.git@vx.x.x#egg=lc_flask_reqparserwherex.x.xis the version you want to download.Install by Manual DownloadTo download the source distribution and/or wheel files, navigate tohttps://github.com/libcommon/flask-reqparser-py/tree/releases/vx.x.x/dist, wherex.x.xis the version you want to install,
and download either via the UI or with a tool like wget. Then to install run:pipinstall<downloadedfile>Donotchange the name of the file after downloading, as Pip requires a specific naming convention for installation files.Dependenciesflask-reqparser-pydepends on, and is designed to work with, theFlask framework.  Only Python versions >= 3.6 are officially supported.Getting StartedThe syntax for defining aRequestParseris almost identical to anArgumentParser, except that all arguments should be
defined as positional, and it supports the builder pattern for adding arguments.RequestParserwill take the positional
definitions and transform them to act like optional arguments (optional arguments inargparsecan still haverequired=True).fromtypingimportListfromflaskimportFlaskfromlc_flask_reqparserimportRequestParserapp=Flask(__name__)defCommaSeparatedList(arg:str)->List[str]:"""Convert string representation of CSV to list of str."""returnarg.split(",")@app.route("/api/describe/person")defdescribe_person():"""API endpoint to describe information about a person."""parser=(RequestParser().add_argument("name",required=True).add_argument("nicknames",type=CommaSeparatedList))args,_=parser.parse_args()//useargs.nameorargs.nicknameslisttolookupuserindatabase//andreturninformationinJSONform.Note thatRequestParser.parse_argsreturns a tuple containing theNamespacewith defined arguments, as well as
a list of the remaining (undefined) arguments.  If an API endpoint only cares about defined arguments, it can safely
ignore the second element of the tuple like the example above.Contributing/SuggestionsContributions and suggestions are welcome! To make a feature request, report a bug, or otherwise comment on existing
functionality, please file an issue. For contributions please submit a PR, but make sure to lint, type-check, and test
your code before doing so. Thanks in advance!
Package: lcgeuclideanmethod
LCG T-TEST USING EUCLIDEAN METHODAdvanced Analytics and Growth Marketing TelkomselProject Supervisor : Rizli Anshari
Writer             : Azka Rohbiya Ramadani, Muhammad Gilang, Demi LazuardiThis project has been created for statistical usage, purposing for determining ATL takers and nontakers using LCG ttest and Euclidean Method.This python requires related package
more importantly python_requires=’>=3.1’, so that package can be install
Make sure the other packages meet the requirements below
‘pandas>=1.1.5’,
‘numpy>=1.18.5’,
‘scipy>=1.2.0’,
‘matplotlib>=3.1.0’,
‘statsmodels>=0.8.0’
Package: lcg-neuro-compneuro
DocumentationIssue trackerRepository contentsHistory of changesContribution/development guideCopy of MIT LicenseInstallationpipinstalllcg-neuro-compneuroPowered byGitLab CICreated byPedro Asadusingcookiecutterandgl:pedroasad.com/templates/python/python/app@1.1.0
Package: lcg-neuro-plx
DocumentationIssue trackerRepository contentsHistory of changesContribution/development guideLicenseInstallationpipinstalllcg-neuro-plxYou’ll need g++ installed in order to compile the bundled extensions.
Up to the current version, only source distributions are available onPyPI.UsageA minimal tutorial is pending.
For now, see the project’s documentation athttps://lcg.gitlab.io/neuro/python-plx.Powered byGitLab CICreated byPedro Asad <pasad@lcg.ufrj.br>usingcookiecutterand@pedroasad.com/templates/python/python/app-1.0.0
Package: lcg-neuro-v2-dataset-orm
v2_dataset – Python object-relational mapping (ORM) and tools for the V2 DatasetDocumentationIssue trackerRepository contentsHistory of changesContribution/development guideThis repository contains aPython packagebased on theSQLAlchemyobject-relational mapping (ORM) framework for accessing the V2 Dataset's curated information.
It also contains a minimalcommand-line interfacethat supports the creation ofSQLitedatabases to hold curated information and its manipulation through a set ofparsing routinesthat are being continuously developed.The curated information itself is stored in thecontents repository, together with information on how to obtain the recording data (which is not open-sourced, as of now).
Thecontents repositoryshould be clonedseparatelyand linked from your working copy, as explained below.Installation and setupThe library may be installed withpipinstalllcg-neuro-v2-dataset-ormAdditional steps:Clone the V2 Dataset'scontents repositoryto any directory on your computer,e.g.:gitclonegit@gitlab.com:lcg/neuro/v2/dataset/contents/data/v2-datasetMake sureto check out acompatible versionof thecontents repository.
Usually, the latest version of the library will be compatible with the latest version of the dataset.The library must be able to locate the dataset directory, which can be done in one of two ways:If Define aV2_DATASET_DIRenvironment variable pointing to the directory where you cloned thecontents repository(you may do it with a.envrcfile), orCreate a symlink nameddataset(it is Git-ignored in this repository) in your working copy or library installation directory (/lib/pythonx.y/site-packages/lcg-neuro-v2-dataset-orm) pointing to thecontents repositorycopy.Note:You may needg++orclangto compile some dependent libraries's extensions.Development notesGit LFS and cloningCloning may take a while because we useGit LFSto track larger files that are included mainly for testing.
After the initial cloning, further pushing/pulling/fetching should only take as long as needed to download missing files, which we intend to keep at a minimum over this project's lifetime.Important:you must installGit LFSbefore cloning.— Powered byGitLab CI— Created byPedro Asad
<pasad@lcg.ufrj.br>usingcookiecutterand@pedroasad.com/templates/python/python/app-1.0.0
Package: lck.common
This library consists of various simple common routines and language constructs
that are so useful they ten to be rewritten in every subsequent project I’m
working on. Each function, decorator or module on its own is too simple to
dedicate an entire PyPI package for it.  Together however, this library
represents a Swiss army knife for everyday needs (YMMV). Among the things you
might find inside:robust memoizationsome less obvious collections (e.g.orderedset)a@synchronizeddecorator (with threading or lockfile backends)some controversial language enhancements like the Null objectconverter from ElementTree instances to dictsfile finder (searching locations commonly used for storing app data)The latest version can be installed viaPyPI:$ pip install lck.commonor:$ easy_install lck.commonThesource code repositoryandissue trackerare
maintained onGitHub.For the curious,lckstands for LangaCore Kit. LangaCore is a one man
software development shop of mine.Note:lck.commonrequiresPython 2.7because all of its code is using
the so-called four futures (absolute_imports,division,print_functionandunicode_literals). One of the virtues in the creation of this library
is to make the code beautiful. These switches give a useful transitional
state between the old Python 2.x and the new Python 3.x. You should use them as
well.Change Log0.4.5fixed an uncommon bug in memoization where an exception in the memoized
function could leave stale keys in the cache0.4.4lck.gitintroduced with aget_versionroutinedecode_entitiesadded tolck.xml0.4.3lck.lang.Nullintroduced, seeNull Object patternlck.lang.unsetis now aNullinstancelck.xmlintroduced with aetree_to_dictroutinelck.confighas been removed, use theconfigparser backport0.4.2lck.cryptointroduced with a couple of thin wrappers over PyCryptolck.mathintroduced starting with Elo rating calculation routine.0.4.1lck.lang.unsetis now alsoFalseandlen(unset)is zero0.4.0migrated to thelcknamespace fromlangacore.kitmigrated licensing from GPL 3 to MITbumped the trove from alpha status to beta, the code is in production for over
a year nowAncient historyNo proper change log was kept before 0.4.0
Package: lclayout
LibreCellLibreCell aims to be a toolbox for automated synthesis of CMOS logic cells.LibreCell is structured in multiple sub-projects:librecell-layout: Automated layout generator for CMOS standard cells.lctime: Characterization kit for CMOS cells and tool for handling liberty files.The project is in a very early stage and might not yet be ready for productive use.
Project structure and API might change heavily in near future.Getting startedLibreCell can be installed using the Python package managerpipor directly from the git repository.DependenciesThe following dependencies must be installed manually:python3z3https://github.com/Z3Prover/z3: SMT solver.Optional dependencies (not required for default configuration):GLPKhttps://www.gnu.org/software/glpk: ILP/MIP solverDepending on your linux distribution this packages can be installed using the package manager.Installing from gitIt is recommended to use a Python 'virtual environment' for installing all Python dependencies:# Create a new virtual environmentpython3-mvenvmy-librecell-env# Activate the virtual environmentsource./my-librecell-env/bin/activateInstall from git:gitclonehttps://codeberg.org/tok/librecell.gitcdlibrecell
./install.sh# Alternatively use ./install_develop.sh to install symlinks.# This allows to edit the code with immediate effect on the installed program.Now, check if the command-line scripts are in the current search path:lclayout--helpIf this shows the documentation of thelclayoutcommand, then things are fine. Otherwise, thePATHenvironment variable needs to be updated to include$HOME/.local/bin.# Instead of executing this line each time it can be added to ~/.bashrcexportPATH=$PATH:$HOME/.local/binInstalling with pipNote: The version PyPI is often not the most recent one. Consider installing from git to get the most recent version.It is recommended to use a Python 'virtual environment' for installing all Python dependencies:# Create a new virtual environmentpython3-mvenvmy-librecell-env# Activate the virtual environmentsource./my-librecell-env/bin/activate

pip3installlclayoutGenerate a layoutGenerate a layout from a SPICE netlist which includes the transistor sizes:--output-dir: Directory which will be used to store GDS and LEF of the cell--tech: Python script file containing design rules and technology related data--netlist: A SPICE netlist containing the netlist of the cell as a sub circuit (.subckt).--cell: Name of the cell. Must match the name of the sub circuit in the SPICE netlist.mkdirmylibrary
lclayout--output-dirmylibrary--techexamples/dummy_tech.py--netlistexamples/cells.sp--cellAND2X1Adapting design rulesDesign rulesi and technology related data need to be encoded in a Python script file as shown inexamples/dummy_tech.py.Known issuesReproducibilityYou may want to generate standard cells in a fully reproducable manner.
Right now there is some non-determinism in LibreCell that has not been investigated yet.
The current workaround is to set thePYTHONHASHSEEDenvironment variable.exportPYTHONHASHSEED=42lclayout...Contact"codextkramerych".replace("x","@").replace("y",".")
Package: lclip
LClipLClip script helps you search clipboard data on your Ubuntu GNOME favourite browser.FeaturesOpen SourceMakes search easier.Browser Google or Firefox or ChromiumSearch on google.com or duckduckgo.comInstallation and UsagePython3requiredInstall lclippip3 install lcliplclip setuplclip -sNot Implemented Error:"Pyperclip could not find a copy/paste mechanism for your system"sudo apt-get install xselto install the xsel utility.How can it helps?When using keyboard shortcut to run the script, it is lot easier to search any keyword or url that you read on book, website etc.Example:
Copy any keyword or url.Ctrl + cRun script with keyboard shortcut and search on browser's new tab.Ctrl + Shift + xScreenshotOther DistroRemove set_up_keyboard_shortcut fromlclip fileInstall python packagespip3installvalidatorspyperclipRun scriptpython3lclipCreate keyboard shortcut manually with commandpython3~/.lclip/xbrowser.pySuggestionsOpen to any suggestions and help provided.
Package: lclpy
lclpyLclpy is a localsearch library implemented in python.Getting StartedHere, you will find a simple guide to install the library on your system.PrerequisitesThe library is intended to be installed withpip.
Make sure pip is installed on your system.
(It's probably included with your python implementation, but it doesn't hurt to check.)After you've made sure pip is installed,
install the following packages:setuptoolspip install setuptoolsYou will be notified if it is already installed. This isn't be a problem.InstallingAfter the prequisites have been properly installed, it's time to install lclpy.
Do not worry about dependencies and such, setuptools should take care of those.pip install lclpyYou can easily test if it's installed by using theinteractive interpreter.Depending on your local installation, it might also be possible to start the interactive interpreter by using:pythonorpyOnce inside the interpreter, try the following command:import lclpyIf it succeeds without errors, lclpy is installed.UsageIf you have any questions of how to use the library, you can download the project from github and check the documentation in the docs/html folder.
You can also check the docstrings of a module in the interactive interpreter like this:print(module_alias.__doc__)There are also severaljupyter notebooksthat demonstrate the use of some classes. These notebooks can be found in the project on github in the notebooks folder.TestsMost of the modules of lclpy have somedoctestsincluded.One can perform these by importing a module and then using the following code in the interactive interpreter:import doctest

doctest.testmod(module_alias)If there are no failed tests, everything is fine.AuthorsDaan Thijs-Design and initial implementation-nobody1570LicenseThis project is licensed under the MIT License - see theLICENSE.mdfile for detailsAcknowledgmentsTony WautersWim Vancroonenburg
Package: lcls
lclcislsbut with colors and icons.InstallTo install dopip install lclsUsageThe executable is namedlclsto prevent conflicts withlsand monolc, you can make an alias and name it however you want.lcls -[al] [directory]Multiple directories can be provided. Currently lc recognizes-aand-loptions.
Directory is optional (defaults to current working directory)Configurationlcfirst tries to read~/.lc.rules.yamland if it fails it will load the default configuration from where it is installed.To customize icons and colors you can copy.lc.rules.yamlto your home folder and modify its contents.For color, either provide anumber (8bit color number),
a list of numbers (rgb), or the color name.DependenciesYou need nerd fonts (or equivalent) to make this work properly. Python dependencies arestyandruamel.yaml
Package: lcls-krtc
krtcThis is a very small utility class for using Kerberos authentication with Python requests.Installation$pipinstalllcls-krtc$condainstall-cconda-forgekrtcUsage exampleTo use this when making calls to a web service:import requests
from krtc import KerberosTicket
from urllib.parse import urlparse

ws_url = "https://ws.slac.stanford.edu/ws/getData.json"
krbheaders = KerberosTicket("HTTP@" + urlparse(ws_url).hostname).getAuthHeaders()
r = requests.get(ws_url, headers=krbheaders)
print(r.json())
Package: lcm
This is the FRoSt Lab at BYU's fork of LCM. It contains only minor modifications to make it compatible with python3, as well as publish it as a pypi package (to make installable from pip).Original source ishere, our fork is availablehere, and to find out more about our lab seehere.LCMLightweight Communications and Marshalling (LCM)LCM is a set of libraries and tools for message passing and data marshalling,
targeted at real-time systems where high-bandwidth and low latency are
critical. It provides a publish/subscribe message passing model and automatic
marshalling/unmarshalling code generation with bindings for applications in a
variety of programming languages.Quick LinksLCM downloadsWebsite and documentationFeaturesLow-latency inter-process communicationEfficient broadcast mechanism using UDP MulticastType-safe message marshallingUser-friendly logging and playbackNo centralized "database" or "hub" -- peers communicate directlyNo daemonsFew dependenciesSupported platforms and languagesPlatforms:GNU/LinuxOS XWindowsAny POSIX-1.2001 system (e.g., Cygwin, Solaris, BSD, etc.)LanguagesCC++C#GoJavaLuaMATLABPython
Package: lcmap-app-deploy
Backup or deploy Marathon application job definitions.What does it do?Gets job definitions from a Marathon endpoint and saves them to a json file.Loads job definitions from a json file and puts them to a Marathon endpoint.Project and job name filters can be used to limit which jobs are backed up/deployed.A test mode will show what would have been backed up/deployed.Use# Show app's help/all arguments.app-deploy--help# Test a backup from a dev Marathon endpoint to a file.
# Use job filters "/myproject" and then all for all jobs.app-deploy--backup--test--envdev--projectmyproject--joball--filemytest.json# Run a backup from a dev Marathon endpoint to a file.
# Use job filters "/myproject" and then further filter jobs with "myjob" in the name.app-deploy--backup--envdev--projectmyproject--jobmyjob--filemytest.json# Test a deploy from a file to a dev Marathon endpoint.
# Use job filters "/myproject and then all for all jobs.app-deploy--deploy--test--envdev--projectmyproject--joball--filemytest.jsonInstall and Runpipinstalllcmap-app-deployexportMARATHON_USERNAME=myuserexportMARATHON_PASSWORD=mypwexportMARATHON_APPS_URL_DEV=https://hostdev:port/v2/appsexportMARATHON_APPS_URL_TEST=https://hosttest:port/v2/appsexportMARATHON_APPS_URL_PROD=https://hostprod:port/v2/appsapp-deploy--helpVersioninglcmap-app-deploy follows semantic versioning:http://semver.org/
Package: lcmap-change-worker
[![Build Status](https://travis-ci.org/USGS-EROS/lcmap-change-worker.svg?branch=develop)](https://travis-ci.org/USGS-EROS/lcmap-change-worker)# lcmap-change-workerworker for initiating change detection jobs, and sending results to the data store## Install```bash# locally$ pip install -e.```## Usage```bash# lcw-listen is available following install with pip$ lcw-listen# lcw-test-send will send stdin to the LCW_RABBIT_EXCHANGE$ lcw-test-send '{"some":"message"}'``````python# same effect as lcw-listenfrom cw import __listener____listener__.main()# useful for sending test messages only.from cw import __sender__message = '{"x": 123, "y": 456, "algorithm": "pyccd-beta1", "result": "OUTPUT"}'__sender__.main(message)```## Configurationlandsat-change-worker is configurable with the following environment variables| Variable | Default | Description || --- | --- | --- || `LCW_RABBIT_HOST` | localhost | RabbitMQ Host || `LCW_RABBIT_PORT` | 5672      | RabbitMQ Port || `LCW_RABBIT_QUEUE` | local.lcmap.changes.worker | Queue for LCW to listen for messages || `LCW_RABBIT_EXCHANGE` | local.lcmap.changes.worker | Exchange for LCW to publish messages || `LCW_RABBIT_RESULT_ROUTING_KEY` | change-detection-result | Routing key used when publishing change detection result messages || `LCW_RABBIT_SSL` | False | Enable/Disable SSL.  True/False |## Developing & TestingGet the local environment ready for development and testing.```bash$ git clone git@github.com:usgs-eros/lcmap-change-worker$ cd lcmap-change-worker$ virtualenv -p python3 .venv$ . .venv/bin/activate$ pip install -e .[test]$ pip install -e .[dev]```Run tests:```bash# the right way$ python setup.py test# alternatively$ pytest```## Deploying
Package: lcmap-merlin
MerlinA Python3 library for turning LCMAP spatial data into timeseries.FeaturesRetrieve chips & chip specsConvert chips & chip specs into time series rodsMany composable functionsWorks with symmetric or assymetric data arraysBuilt with efficiency in mind… leverages Numpy for heavy lifting.Tested with cPython 3.5 & 3.6Exampleimportmerlintimeseries=merlin.create(x=123,y=456,acquired='1980-01-01/2017-01-01',cfg=merlin.cfg.get(profile='chipmunk-ard',env={'CHIPMUNK_URL':'http://localhost:5656'}))print(timeseries)(((123,456,123,456),{'reds':[9,8,...],'greens':[99,88,...]},'blues':[12,22,...],'dates':['2017-01-01','2016-12-31',...]}),((123,456,124,456),{'reds':[4,3,...],'greens':[19,8,...]},'blues':[1,11,...],'dates':['2017-01-01','2016-12-31',...]}),)DevelopmentA Conda environment is highly recommended.# generate build artifacts$makebuild# run all tests$maketests# generate documentation$makedocs# push to pypi
# expected env vars:
# TWINE_USERNAME
# TWINE_PASSWORD$makedeploy# Releasing to Pypi
# 1. increment version in setup.py
# 2. git add *
# 3. git commit -m 'add release message'
# 4. git push
# 5. git tag -a 1.2.3
# 6. git push --tagsDocumentationComplete documentation is available athttp://lcmap-merlin.readthedocs.io/Installationpipinstalllcmap-merlinVersioningMerlin follows semantic versioning:http://semver.org/LicenseThis is free and unencumbered software released into the public domain.Anyone is free to copy, modify, publish, use, compile, sell, or
distribute this software, either in source code form or as a compiled
binary, for any purpose, commercial or non-commercial, and by any
means.In jurisdictions that recognize copyright laws, the author or authors
of this software dedicate any and all copyright interest in the
software to the public domain. We make this dedication for the benefit
of the public at large and to the detriment of our heirs and
successors. We intend this dedication to be an overt act of
relinquishment in perpetuity of all present and future rights to this
software under copyright law.THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
OTHER DEALINGS IN THE SOFTWARE.For more information, please refer tohttp://unlicense.org.
Package: lcmap-oxen
Tooling for creating the auxiliary datasets needed in LCMAPInstallingpipinstalllcmap-oxenA full GDAL installation is required.  GDAL can be compiled and installed by conda.Other requirements:python >= 3.6Run the script from the command line:$clip_nlcd-i/path/to/conus-nlcd-raster-o/path/to/output-directory/--acquiredYYYYMMDD--prodNLCD*or*NLCD_TRAININGCLI parameters:-i, The full path to a CONUS NLCD raster file.-o, The full path to an output directory, will be created if it does not exist.–acquired, A date (YYYYMMDD) that describes the acquisition of the original raster data; used in the filenames for the outputs.–prod, A string description of the input dataset, currently NLCD and NLCD_TRAINING are valid options; used in the filenames for the outputs.–overwrite, Optional, adding this will cause existing files to be overwritten, otherwise they will be skipped.This script was designed to generate tiled NLCD but could be modified to produce other tiled LCMAP auxiliary products.