Saravanan666/pypi-org huggingface dataset:
Package: laser-keep-alive
laser-keep-aliveis a project aimed at providing a stable run time
environment for the open-source Facebook AI Research (FAIR) project,Language-Agnostic SEntence Representations (LASER).InstallationCurrently installation can only be done using the source code.gitclonehttps://github.com/mingruimingrui/laser-keep-alive.gitcdlaser-keep-alive
pythonsetup.pyinstallTo ensure hardware compatibility, an explicit installation ofpytorch>=1.0might be necessary.Basic UsageScript ExampleTo use this package in your python script, the easiest way is to import thelaser.SentenceEncoderclass.fromlaserimportSentenceEncoder# Loading the modelsent_encoder=SentenceEncoder(lang='en',model_path=path_to_model_file,bpe_codes=path_to_bpe_codes_file,)# Encode texts# Given a List[str]embeddings=sent_encoder.encode_sentences(list_of_texts)# Where embeddings is a 2D np.ndarray# of shape [num_texts, embedding_size]Commandline Toollaser-keep-alivecan also be ran directly from the commandline.$ python -m laser
usage: python -m laser [-h] {encode,filter} ...

Language-Agnostic SEntence Representations

positional arguments:
  {encode,filter}
    encode         Encode a text file line by line
    filter         Filter a parallel corpus based on similarity

optional arguments:
  -h, --help       show this help message and exitAt the moment, the following commandline routines are provided.encodeEncodes a text file line by line into sentence embeddings.
Output formats are.npyand.csv.
If you are using the pretrained-model, your embedding output will have
dimension size of 1024. In the case of.npyoutput format, this corresponds
to byte sizes of 4096 fornp.float32and 2048 fornp.float16.
(Don't worry if you don't get that last sentence)filterFilters a parallel corpus line by line. Keeps only sentences which haseuclidean distancebelow a threshold (default: 1.04).
To apply a stricter filter, use a smaller threshold.Downloading Pretrained ModelPretrained models are necessary since this repository does not provide training
code.Please referencethis scriptto download pretrained models.CreditsFull credit goes toHolger Schwenk,
the author of the LASER toolkit as well as FAIR.
For more information regarding FAIR and LASER, please visit their webpages.FAIR Website:https://ai.facebook.com/FAIR Github:https://github.com/facebookresearchLASER Github:https://github.com/facebookresearch/LASER/If you like this project, please visit theLASER project pageand give it a star ⭐.Licenselaser-keep-aliveis MIT-licensed andLASERis BSD-licensed.
If you wish to uselaser-keep-aliveplease remember to include the
copyright notice.CitationPlease citeHolger SchwenkandMatthijs Douze(also creator ofFAISS).@inproceedings{Schwenk2017LearningJM,title={Learning Joint Multilingual Sentence Representations with Neural Machine Translation},author={Holger Schwenk and Matthijs Douze},booktitle={Rep4NLP@ACL},year={2017},}
Package: laser-offset
Laser OffsetSimple Tools that creates external and internal offsets for shapes. Supports DXF and SVG Import/Export.This project is in early alpha and was created as side-project for hobby.InstallingInstall and update usingpip:$ pip install -U laser_offsetUsageUsage: laser_offset [OPTIONS] SOURCE_PATH TARGET_PATH LASER_WIDTH

    Creates new drawings from DXFs with outer and inner offset lines by
    LASER_WIDTH in μm(microns) ans save them into TARGET_PATH as SVG or DXF.

    SOURCE_PATH is folder with DXFs for batch convertion

    TARGET_PATH is folder for results

    LASER_WIDTH is beam diameter in μm(microns) from 1 to 999

    Options:
    -s, --svg                 Output as SVG  [default: (False)]
    -d, --dxf / -D, --no-dxf  Output as DXF  [default: (True)]
    --help                    Show this message and exit.Example:laser_offset . ./output -s 150LimitationsCan't handle arcs less that half of laser widthIgnores layers, text, shape size and styles
Package: lasertram
lasertramWelcome to the repository forlasertram, a package for the time resolved analysis for processing laser ablation inductively coupled plasma mass spectrometry (LA-ICP-MS) data. It is utilized heavily in the dashboardLaserTRAM-DB.Documentationplease see theDocumentationfor more!Installationpip install lasertramContributingIf you have features you'd like to see please open an issue or consider contributing yourself! I'm always happy to have help.-- Jordan
Package: lasfile
lasfileLibrary for reading CWLS Log ASCII Standard v. 1.2, 2.0, and 3.0 .las files.InstallationpipinstalllasfileUsageRead LAS fileimportlasfilelas=lasfile.LASFile(file_path='path/to/file.las')In order for an lasfile to properly read, and pass a critical error check, it must have the following sections:VersionWellCurvesDataView sections in LAS filelas.sectionsView section data in LAS fileUsing dot notationAs raw ascii textlas.well.raw_dataAs pandas dataframelas.well.dfUsing dictionary notationAs raw ascii textlas['well']['raw_data']As pandas dataframelas['well']['df']ErrorsView all errorslas.errorsView specific errorslas.open_errorlas.read_errorlas.split_errorlas.version_errorlas.parse_errorlas.validate_errorCheck for errorsCheck for only critical errorslasfile.error_check(las)Check for all errorslasfile.error_check(las,critical_only=False)LASSection objects can also be passed to error_checklasfile.error_check(las.well)LicenseMIT
Package: las-geoh5
Import/Export LAS files to/from geoh5 format.This package contains three modules for import/export of LAS files in
and out of a geoh5 file. the import/export directories modules allow
export and subsequent re-import of LAS files from a drillhole group
saved in a geoh5 file to a structured set of directories on disk. The
import files module is intended for the more general case of LAS file
import to an existing drillhole group.Basic UsageThe most convenient way to use this package is throughGeoscience ANALYST Prowhere the import files driver may be run from thefile -> importmenu.All drivers may also be run from a ui.json file inGeoscience ANALYST Proby either adding to the Python Scripts directory or drag and drop into
the viewport. Defaulted ui.json files can be found in the uijson folder
of the las-geoh5 project.Finally, the drivers can be run from CLI using the followingpython-mlas_geoh5.module.driversome_file.ui.jsonWhere module is one ofimport_files,export_files, orimport_las.LicenseMIT LicenseCopyright (c) 2023 Mira GeosciencePermission is hereby granted, free of charge, to any person obtaining a
copy of this software and associated documentation files (the
“Software”), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.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 OR COPYRIGHT HOLDERS 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.
Package: lash
This package provides a set of desktop tools that simplify and
automate multiple processes. Lash also has utility functions
that cover some needs of desktop users, like image handling, spy
tools, scheduling, math and others.Thinking about being simple and effective, Lash was developed with a command
line interface, having syntax similar to cli’s linux, with options args and help sections.Full ReadMe inGithubpage.Documentation onKevBoyz Docs.DocumentationV2 (pt-br)7562Hall.
Package: lasikservice
Lasik service that exposes an interface to all beams of all connected lasik boardsInstallationtested on Ubuntu 18.04 onlyFrom source for developmentClone the repo and in this folder runpip3 install virtualenv
virtualenv env
source env/bin/activate
pip3 install -e .The-eswitch installs with symlinks to this folder which is great during development.From PyPIpip3 install lasikserviceUsageto start the server:lasikservice <host port>to talk to a single board:lasikconnect <serialdevice>eglasikconnect /dev/ttyACM0note: pip might install these commands in~/.local/binwhich might not be in your path.
Package: laskea
LaskeaCalculate (Finnish: laskea) some parts.DocumentationUser and developerdocumentation of laskea.Bug TrackerAny feature requests or bug reports shall go to thetodos of laskea.Primary Source repositoryThe main source oflaskeais on a mountain in central Switzerland.
We use distributed version control (git).
There is no central hub.
Every clone can become a new source for the benefit of all.
The preferred public clones oflaskeaare:on codeberg- a democratic community-driven, non-profit software development platform operated by Codeberg e.V.at sourcehut- a collection of tools useful for software development.ContributionsPlease do not submit "pull requests" (I found no way to disable that "feature" on GitHub).
If you like to share small changes under the repositories license please kindly do so by sending a patchset.
You can either send such a patchset per email usinggit send-emailor
if you are a sourcehut user by selecting "Prepare a patchset" on the summary page of your fork atsourcehut.SupportPlease kindly submit issues athttps://todo.sr.ht/~sthagen/laskeaor write plain text email to ~sthagen/laskea@lists.sr.htto submit patches and request support. Thanks.StatusProduction/Stable.Note: The default branch isdefault.
Package: laspy
LaspyLaspy is a python library for reading, modifying and creating LAS LiDAR
files.Laspy is compatible with Python  3.8+.FeaturesLAS support.LAZ support vialazrsorlaszipbackend.LAS/LAZ streamed/chunked reading/writting.COPCsupport over files.COPCsupport over https withrequestspackage.CRS support viapyprojpackage.ExamplesDirectly read and write lasimportlaspylas=laspy.read('filename.las')las.points=las.points[las.classification==2]las.write('ground.laz')Open data to inspect header (opening only reads the header and vlrs)importlaspywithlaspy.open('filename.las')asf:print(f"Point format:{f.header.point_format}")print(f"Number of points:{f.header.point_count}")print(f"Number of vlrs:{len(f.header.vlrs)}")Use the 'chunked' reading & writing featuresimportlaspywithlaspy.open('big.laz')asinput_las:withlaspy.open('ground.laz',mode="w",header=input_las.header)asground_las:forpointsininput_las.chunk_iterator(2_000_000):ground_las.write_points(points[points.classification==2])Appending points to existing fileimportlaspywithlaspy.open('big.laz')asinput_las:withlaspy.open('ground.laz',mode="a")asground_las:forpointsininput_las.chunk_iterator(2_000_000):ground_las.append_points(points[points.classification==2])API Documentation and tutorials are available atReadTheDocs.InstallationLaspy can be installed either withpip:pip install laspy # without LAZ support
# Or
pip install laspy[laszip] # with LAZ support via LASzip
# Or
pip install laspy[lazrs] # with LAZ support via lazrsChangelogSeeCHANGELOG.md
Package: lasrasterize
lasrasterizelasrasterizeis a command line tool and associated library used to convert lidar LAS files into geotiff raster files.InstallationTo installlasrasterize, clone the repository and run the setup script:gitclonehttps://github.com/bmander/lasrasterize.gitcdlasrasterize
pipinstall.Alternatively, install from the python package index:pipinstalllasrasterizeUsageConsult thelasrasterizehelp:lasrasterize--helpDevelopmentTo run the unit tests, use the following command from the base directory:pytest.Licenselasrasterizeis released under the MIT license. See the LICENSE file for details.
Package: lassh
LasshAn open source, MIT-licensed command line tool for managing per-project ssh configs.Using a ssh configssh allows the use of aconfigplaintext file, usually located in~/.ssh/config, that allows you to customizesshin a whole host (heh) of ways. One primary use is the creation of aliases for hosts.However, a single global config file for ssh can quickly become unwieldy and messy (motivating stack exchange).Introducing LasshA CLI to manage your global ssh config and to allow for per-project configurations.InstallationLassh requires Python 3. Runpip install lassh. If you haven't already, check outpyenvfor python version management andpipenvfor dependency management, though they aren't neccesary for using Lassh.Getting Startedcdinto your project (or lab or class or secret government R&D group) directory that you want to configure ssh for.Initializing Lasshlassh initwill create a global config and a projectlassh.config(if they don't already exist). Note:lassh.configfiles are valid plaintext.ssh/configfiles. Lassh will then link your new or existinglassh.configto the global config! But you don't have any new hosts to connect to...Adding Hostslassh addhost beepboop computer.dartmouth.edu stevenchunadds a host now calledbeepboopthat points tostevenchun@computer.dartmouth.edu. You can also specify a path to identity keys using the--keyoption and a port with the--portoption. If you leave the user out, it will default toroot.It's important to remember that while Lassh allows you to distribute your config files, the ssh alias namespace is global so you can't have the same alias in two different lassh.config files.Deleting Hostslassh deletehost beepboopdeletes the host we just made from our locallassh.config. (It does not remove the link from our projectlassh.configto the global config)Teardownlassh teardownunlinks and deletes thelassh.configin the current directory from the global config. Warning: this deletes all aliases you have in the project'slassh.configOther OperationsSince eachlassh.configis a valid ssh config file, if you want to add an option like LocalForward, simply add the host and manually edit thelassh.configfile to add more options (or contribute to add the relevant feature to Lassh!!).TestingTests can be run usingpython -m unittest test.test_lasshwhile in thelasshpython package directory.
Package: lassie
Copyright (c) 2017 Mike HelmickPermission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the “Software”), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.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 OR COPYRIGHT HOLDERS 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.Description: UNKNOWN
Keywords: lassie open graph web content scrape scraper
Platform: UNKNOWN
Classifier: Development Status :: 4 - Beta
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: MIT License
Classifier: Topic :: Software Development :: Libraries :: Python Modules
Classifier: Topic :: Internet
Classifier: Natural Language :: English
Classifier: Programming Language :: Python
Classifier: Programming Language :: Python :: 2.7
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.8
Package: lassobbn
LASSO BBNLearning Bayesian Belief Networks (BBNs) with LASSO. Example code is as below.fromlassobbn.learnimportlearn_parameters,learn_structure,to_bbn,to_join_tree,posteriors_to_df# Step 1. Learn the structuredf_path='./data/data-binary.csv'meta_path='./data/data-binary-complete.json'parents=learn_structure(df_path,meta_path,n_way=2,ignore_neg_gt=-0.01,ignore_pos_lt=0.05)# Step 2. Learn the parametersd,g,p=learn_parameters(df_path,parents)# Step 3. Get the BBNbbn=to_bbn(d,g,p)# Step 4. Get the Join Treejt=to_join_tree(bbn)You can then usePy-BBNto create a BBN and join tree (JT) instance and perform exact inference.InstallationpipinstalllassobbnLinksCodeDocumentationPyPiAdditional APIsturing_bbnpyspark-bbnturing_bbnis a C++17 implementation of py-bbn; take your causal and probabilistic inferences to the next computing level!pyspark-bbnis a is a scalable, massively parallel processing MPP framework for learning structures and parameters of Bayesian Belief Networks BBNs usingApache Spark.Citation@misc{alemi_2021,
title={lasso-bbn},
url={https://lasso-bbn.readthedocs.io/},
author={F. Alemi, J. Vang},
year={2021},
month={Aug}}Copyright StuffSoftwareCopyright 2021 Farrokh Alemi and Jee Vang

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.Art CopyrightCopyright 2021 Daytchia VangSponsor, LovePatreonGitHub
Package: lasso.issues
PDS Lasso IssuesThe PDS Lasso Issues package provides utilities handle issues on GitHub. It provides four commands:milestonespds-issuesmove-issuespds-labelsadd-version-label-to-open-bugsPlease visit our website at:https://nasa-pds.github.io/lasso-issuesIt may have useful information for developers and end-users.PrerequisitesInstalling this software requiresgitto be present on the target systme.User QuickstartInstall with:pip install lasso-issuesTo execute, run:(put your run commands here)Code of ConductAll users and developers of the NASA-PDS software are expected to abide by ourCode of Conduct. Please read this to ensure you understand the expectations of our community.DevelopmentTo develop this project, use your favorite text editor, or an integrated development environment with Python support, such asPyCharm.ContributingFor information on how to contribute to NASA-PDS codebases please take a look at ourContributing guidelines.InstallationInstall in editable mode and with extra developer dependencies into your virtual environment of choice:pip install --editable '.[dev]'Configure thepre-commithooks:pre-commit install
pre-commit install -t pre-push
pre-commit install -t prepare-commit-msg
pre-commit install -t commit-msgThese hooks check code formatting and also aborts commits that contain secrets such as passwords or API keys. However, a one time setup is required in your global Git configuration. Seethe wiki entry on Git Secretsto learn how.PackagingTo isolate and be able to re-produce the environment for this package, you should use aPython Virtual Environment. To do so, run:python3 -m venv venvThen exclusively usevenv/bin/python,venv/bin/pip, etc. Or, "activate" the virtual environment by sourcing the appropriate script in thevenv/bindirectory.If you havetoxinstalled and would like it to create your environment and install dependencies for you run:tox --devenv <name you'd like for env> -e devDependencies for development are specified as thedevextras_requireinsetup.cfg; they are installed into the virtual environment as follows:pip install --editable '.[dev]'All the source code is in a sub-directory undersrc.ToolingThedevextras_requireincluded in the template repo installsblack,flake8(plus some plugins), andmypyalong with default configuration for all of them. You can run all of these (and more!) with:tox -e lint
Package: lassonet
LassoNetLassoNet is a new family of models to incorporate feature selection and neural networks.LassoNet works by adding a linear skip connection from the input features to the output. A L1 penalty (LASSO-inspired) is added to that skip connection along with a constraint on the network so that whenever a feature is ignored by the skip connection, it is ignored by the whole network.Installationpip install lassonetUsageWe have designed the code to follow scikit-learn's standards to the extent possible (e.g.linear_model.Lasso).from lassonet import LassoNetClassifierCV 
model = LassoNetClassifierCV() # LassoNetRegressorCV
path = model.fit(X_train, y_train)
print("Best model scored", model.score(X_test, y_test))
print("Lambda =", model.best_lambda_)You should always try to give normalized data to LassoNet as it uses neural networks under the hood.You can read the fulldocumentationor read theexamplesthat cover all features.Featuresregression, classification andCox regressionwithLassoNetRegressor,LassoNetClassifierandLassoNetCoxRegressor.cross-validation withLassoNetRegressorCV,LassoNetClassifierCVandLassoNetCoxRegressorCVgroup feature selection with thegroupsargumentlambda_start="auto"heuristicNote that cross-validation, group feature selection and automaticlambda_startselection have not been published in papers, you can read the code orpost as issueto request more details.We are currently working (among others) on adding support for convolution layers, auto-encoders and online logging of experiments.Cross-validationThe original paper describes how to train LassoNet along a regularization path. This requires the user to manually select a model from the path and made the.fit()method useless since the resulting model is always empty. This feature is still available with the.path()method for any model or thelassonet_pathfunction and returns a list of checkpoints that can be loaded with.load().Since then, we integrated support for cross-validation (5-fold by default) in the estimators whose name ends withCV. For each fold, a path is trained. The best regularization value is then chosen to maximize the average performance over all folds. The model is then retrained on the whole training dataset to reach that regularization.WebsiteLassoNet's website ishttps:lasso-net.github.io/. It contains many useful references including the paper, live talks and additional documentation.ReferencesLemhadri, Ismael, Feng Ruan, Louis Abraham, and Robert Tibshirani. "LassoNet: A Neural Network with Feature Sparsity." Journal of Machine Learning Research 22, no. 127 (2021).pdfbibtexYang, Xuelin, Louis Abraham, Sejin Kim, Petr Smirnov, Feng Ruan, Benjamin Haibe-Kains, and Robert Tibshirani. "FastCPH: Efficient Survival Analysis for Neural Networks." In NeurIPS 2022 Workshop on Learning from Time Series for Health.pdf
Package: lassoreg
Lasso Regression PackageOverviewThis Python package provides a simple implementation of Lasso Regression (L1 regularization)
using the Python Standard Library andNumPy. Lasso Regression is a linear regression
technique that adds a penalty term proportional to the absolute values of the regression
coefficients, promoting sparsity in the model.InstallationpipinstalllassoregUsagefromlassoreg.regressionimportLassoRegression# Create an instance of Lasso Regressionlasso_model=LassoRegression(alpha=0.01,max_iter=1000,tol=1e-4)# Fit the model to training datalasso_model.fit(X_train,y_train)# Make predictions on new datapredictions=lasso_model.predict(X_test)DocumentationFor detailed information on the parameters and methods, please refer to the docstring in the source code.ExampleAn example of generating synthetic data and fitting the Lasso Regression model is provided in theexampledirectory.cdexample
pythonexample.pyTestingTo run the unit tests, use the following command:pytesttestsLicenseThis package is licensed under theMIT License.