Saravanan666/pypi-org huggingface dataset:
Package: larryc
LarrycLarryc is an asynchronous dictionary-search engine that runs in your terminal with a pleasing UI. It is depending on thedictionary api. And, the UI is written using theRich framework.MotivationFirst of all, nobody these days carries dictionaries. Second of all, not everyone likes to use the browser for everything. Especially me. I feel like small things like this should be done in the terminal, which is fast and straight to point. Larryc ismaybegoing to solve thedictionarycrysis. That's what I'm calling it.Installation & UsageCross-platform (Python must be installed):# Install the package (pip required).pipinstalllarryc# Basic command-line usage.python-mlarrycarcheology# You can use any word in place of archeology here.ContributionContributing to Larryc is pretty straight-forward. If you're up to creating some new features for the projects or make a massive change, here are the simple steps to follow:Forkthe repository and clone it.Do your stuff.Pushyour changes to the fork.Create a pull requestand submit!Developer NotesIn order to set up the development environment for this library, considercloning the repositoryand installing the dependencies for it first using the commands below. The tests for this project have been written to supportpytest.# The tests/requirements.txt text file contains the dependency names.pipinstall-rtests/requirements.txt# Run the tests with the pytest command, --verbose flag to show detailed output.python3-mpytest--verboseLicenseMIT License

Copyright (c) 2022 furtidev, HitBlast

Permission 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.View Original
Package: lars
lars is a smallPythonframework for working with httpd logs (from a variety
of common servers likeApache,nginx, and IIS). The primary purpose is to
provide a set of conversions to ease loading such logs into relational
databases, but numerous other possibilities can be realized with a little
imagination. Which is to say: lars isnota web log analyzer. However, itisa toolkit that makes it quite easy to construct your own analyzer.LinksThe code is licensed under theMIT licenseThesource codecan be obtained from GitHub, which also hosts thebug
trackerThedocumentation(which includes installation instructions and several
examples) can be read on ReadTheDocsThebuild statuscan be observed on Travis CI
Package: larsespenssb-pypitemplate
Larsespenssb PypitemplateFeaturesTODORequirementsTODOInstallationYou can installLarsespenssb PypitemplateviapipfromPyPI:$pipinstalllarsespenssb-pypitemplateUsagePlease see theCommand-line Referencefor details.ContributingContributions are very welcome.
To learn more, see theContributor Guide.LicenseDistributed under the terms of theMIT license,Larsespenssb Pypitemplateis free and open source software.IssuesIf you encounter any problems,
pleasefile an issuealong with a detailed description.CreditsThis project was generated from@cjolowicz'sHypermodern Python Cookiecuttertemplate.
Package: lart-research-assistant
The L’ART Research Assistant is a freely available open-source app
that aids researchers in the collection, storage and transfer of
data for research in bilingualism and language attitudes, especially
in cases of bilinguals who speak a majority language and a regional
/ minority / minoritized language.📥Download🧭User Guide📜Quick Tutorials🛟SupportFeaturesFieldwork-ready— use the included versions of the LSBQe, AToL, MGT, and digital informed consent forms, or make your own versions.Reproducible— make your research reproducible by simply sharing version information.Extensible— contribute with JSON, Python, HTML and JavaScript or import the backend in your own Python project.Free and open— dual-licensed under theAGPLv3-or-laterand theEUPL-1.2+.Cross-platform— runs on Windows, Linux, and MacOS.ScreenshotInstallationInstallation on Windows is super simple:
Go to theReleases <https://github.com/lart-bangor/research-assistant/releases>and download the
Windows installer for the latest version (or an earlier one if you need that).
Run it and follow the instructions.For a detailed walk-through, and instructions for Linux and MacOS, see ourInstallation Guide.DocumentationComprehensive documentation for the L’ART Research Assistant, including a User Guide, Quick Tutorials,
a Developer Guide and an API Reference for both the backend and frontend are available from theofficial documentation hosted on Read the Docs.ContributingDevelopment of the L’ART Research Assistant is a collaborative effort which we hope will benefit many
researchers in our field. Your contributions are actively welcome. Please see theContributingsection of ourDeveloper Guidefor all you need to know to get going.CitingIf you use the L’ART Research Assistant (or parts of it), please cite the following document or directly
import the project’scitation metadatainto your reference manager.Breit, F., Tamburelli, M., Gruffydd, I. and Brasca, L. (2023). The L’ART Research Assistant app: A digital toolkit for bilingualism and language attitude research [Software, version 0.5.0]. Bangor University.DOI:10.13140/RG.2.2.18801.35686Questions, issues, …For any questions not answered by the documentation, or anything you wish to disucss that’s to do with
the app, use theGitHub Discussionsfeature.To report issues/bugs, please useGitHub Issues.
Package: larzuk
larzukA command-line tool to help modding-as-code for game Diablo II: Resurrected.How to UseInstall this command-line tool viapip:$pipinstalllarzukWrite migration scripts in a directory (e.g.migrations):# Relative path of .txt file you want to modify.target='global/excel/armor.txt'# Entry function of migrationdefmigrate(txt_file):forrowintxt_file:row['minac']=row['maxac']Runlarzukcommand to do migrations:$larzukup--target-dir/path/to/d2r/dataCheck filearmor.txtin data directory, values in columnminacequal tomaxac.ExampleCheckhttps://github.com/he-yaowen/LabloLicenseCopyright (C) 2023 HE Yaowenhe.yaowen@hotmail.comThe GNU General Public License (GPL) version 3, seeLICENSE.
Package: lasagne_visualizer
===============================lasagne_visualizer===============================.. image:: https://img.shields.io/pypi/v/lasagne_visualizer.svg:target: https://pypi.python.org/pypi/lasagne_visualizer.. image:: https://img.shields.io/travis/SimonKohl/lasagne_visualizer.svg:target: https://travis-ci.org/SimonKohl/lasagne_visualizer.. image:: https://readthedocs.org/projects/lasagne-visualizer/badge/?version=latest:target: https://lasagne-visualizer.readthedocs.io/en/latest/?badge=latest:alt: Documentation Status.. image:: https://pyup.io/repos/github/SimonKohl/lasagne_visualizer/shield.svg:target: https://pyup.io/repos/github/SimonKohl/lasagne_visualizer/:alt: UpdatesA small python package that lets you have a glimpse at the inner workings of your deep lasagne architectures.-----------------------------------------------------------------------Using ipython notebook you can now live-monitor the weight learning of your models, or just save the generated visualizations when running command line python scripts.Obviously, having a rough idea of how the weights of your model progress, can guide you in how to tweak your architecture and its parameters.Other frameworks such as Tensorflow have had such visualizations from the start and lasagne_visualizer tries to provide a similar, though much more leight-weight, tool.The image below gives a flavor of how your output might come out to look:.. image:: https://github.com/SimonKohl/lasagne_visualizer/blob/develop/examples/example.png:target: https://github.com/SimonKohl/lasagne_visualizer/blob/develop/examples/Example-----For an example on how to use lasagne_visualizer in an IPython Notebook, see `Finetuning for Image Classification <https://github.com/SimonKohl/lasagne_visualizer/blob/develop/examples/Finetuning%20for%20Image%20Classification.ipynb>`_, which borrows the underlying example from  `ebenolson <https://github.com/ebenolson>`_.Further Information-----* Free software: MIT license* Documentation: https://lasagne-visualizer.readthedocs.io.Features--------* plot the mean/extremal values/1 sigma error band of the weights of lasagne layers as a function of the training epochs* use modes to either auto-select all trainable/the currently trainable/user-specified layers for plotting* adjust the range of the weights in the plots* TODO: enable the plotting of bias weightsCredits---------This package was created with Cookiecutter_ and the `audreyr/cookiecutter-pypackage`_ project template... _Cookiecutter: https://github.com/audreyr/cookiecutter.. _`audreyr/cookiecutter-pypackage`: https://github.com/audreyr/cookiecutter-pypackage=======History=======0.1.0 (2016-11-30)------------------* First release on PyPI.
Package: lascheck
lascheckPython library for checking conformity of Log ASCII Standard (LAS) files to standardsDerived fromlasioCurrently supports checking against LAS 2.0 standard onlyhttp://www.cwls.org/wp-content/uploads/2014/09/LAS_20_Update_Jan2014.pdfSimple example>>> las = lascheck.read('sample.las')
 >>> las.check_conformity()
 >>> las.get_non_conformities()The checks present in the package:The depth value divided by the step value must be a whole number.

  The index curve (i.e. first curve) must be depth, time or index.

  The only valid mnemonics for the index channel are DEPT, DEPTH, TIME, or INDEX.

  Time and date can be included in LAS 2.0 files provided that they are expressed as a number.

  "~V" must be the first section.

  Embedded blank lines anywhere in the section are forbidden

  "~V" is a required section.

   "~W" (also known as "WELL INFORMATION SECTION") is a required section.

  *"~C" *(also known as ~CURVE INFORMATION SECTION") is a required section.

  *"~A" *(also known as ~ASCII LOG DATA") is a required section.

  Only one *"~V" *section can occur in an LAS 2.0 file.

  ~V section must contain the lines: VERS, WRAP.

  Only one *"~W" *section can occur in an LAS 2.0 file.

  ~W section must contain the lines: "STRT", "STOP", "STEP", "NULL", "COMP", "WELL", "FLD", "LOC", "SRVC", "DATE".

  Only one *"~C" *section can occur in an LAS 2.0 file.

  Only one *"~P" *section can occur in an LAS 2.0 file.

  Only one *"~O" *section can occur in an LAS 2.0 file.

  The data section ~A is the last section in a file.
  
  The start depth (or time or index) value when divided by the step depth (or time or index) value must be a whole number.

  The stop depth (or time or index) value when divided by the step depth (or time or index) value must be a whole number.
  
  If the index is depth, the units must be M (metres), F (feet) or FT (feet).
Package: lase
lase - Gitflow release toolInstallingpipinstalllaseUsingPrerequisites:Git-based project withmasteranddevelopbranches present, and Maven-style version
number in theVERSIONfileSeelase --helpfor the list of all options.Starting a release of your project with remote operation enabledcd/path/to/project/git/repo
lase--remoteoriginstartThe above command will, and create therelease/X.Y.Zrelease branch whereX.Y.Zis the version
being released, bumping the version in theVERSIONfile on thedevelopbranch at the same time.After reviewing the diff between the release andmasterbranches proceed to the finish step below.Finishing a release of a your project with remote operation enabledcd/path/to/project/git/repo
lase--remoteoriginfinishDevelopingPrerequisites:Python 3pipenvInitialize a virtualenv with dev dependencies installed:makedevelopProject dependenciesProject dependencies shoud always be specified insetup.pyusing thecompatible releasenotation.Updating dependencies in virtualenvRun the following after updatingsetup.pymakeupdate-depsInstalling development dependenciesReplace<PACKAGE>with the actual name, and<VERSION>with the MAJOR.MINOR
(or MAJOR.MINOR.PATCH for versions below 1.0.0) version of the package.Read more on compatible releases.pipenvinstall--dev<PACKAGE>~=<VERSION>Running unit-testsmaketestRunning E2E testsPrerequisites:Sheltermakee2e-testStarting a releaseVariables:RELEASE_REMOTEset to the name of the Git remote. Set to empty to disable pushes to
remote. Default value:originRELEASE_VERSIONoverride the release version, or leave empty to release the current
snapshot (-SNAPSHOTwill be stripped off). Empty by defaultmakerelease-startFinishing a releaseVariables:RELEASE_REMOTEset to the name of the Git remote. Set to empty to disable pushes to
remote. Default value:originRELEASE_PUBLISHset to1to enable publishing of the sdist tarball after the release`makerelease-finishrelease-finishwill leave the release Git tag checked out on completion.Building and publishing the source distribution:makepublish
Package: laserchicken
Please cite the software if you are using it in your scientific publication.Toolkit for handling point clouds created using airborne laser scanning (ALS). Find neighboring points in your point cloud and describe them as feature values. Read ouruser manualand our (very modest)tutorial.InstallationPrerequisites:Python 3.7 or higherpippip install laserchickenNecessary steps for making a new releaseCheck citation.cff using general DOI for all version (option: create file via 'cffinit')Create .zenodo.json file from CITATION.cff (using cffconvert)cffconvert --validatecffconvert --ignore-suspect-keys --outputformat zenodo --outfile .zenodo.jsonSet new version number in laserchicken/_version.txtCheck that documentation uses the correct versionEdit Changelog (based on commits inhttps://github.com/eecolidar/laserchicken/compare/v0.3.2...master)Test if package can be installed with pip (pip install .)Create Github releaseUpload to pypi (now implemented via GitHub Actions):python setup.py sdist bdist_wheelpython -m twine upload --repository-url https://upload.pypi.org/legacy/ dist/*(orpython -m twine upload --repository-url https://test.pypi.org/legacy/ dist/*to test first)Check doi on zenodoFeature testingAll features were tested for the following general conditions:Output consistent point clouds and don't crash with artificial data, real data, all zero data (x, y or z), data without points, data with very low number of neighbors (0, 1, 2)Input should not be changed by the feature extractorThe specific features were tested as follows.Echo ratioA test was written with artificial data to check the correctness of the calculation with manually calculated ratio. Also tested on real data to make sure it doesn't crash, without checking for correctness. We could add a test for correctness with real data but we would need both that data and a verified ground truth.EigenvaluesOnly sanity tests (l1>l2>l3) on real data and corner cases but no actual test for correctness. The code is very simple though and mainly calls numpy.linalg.eig.Height statistics (max_z','min_z','mean_z','median_z','std_z','var_z','coeff_var_z','skew_z','kurto_z)Tested on real data for correctness. It is however unclear where the ground truths come from. Code is mainly calling numpy methods that do all the work already. Only calculations in our code are:range_z = max_z - min_z
coeff_var_z = np.std(z) / np.mean(z)I don't know about any packages that could provide an out of the box coefficient of variance. This is probably because the calculation is so simple.Pulse penetration ratioTested for correctness using artificial data against manually calculated values. No comparison was made with other implementations.Sigma_zTested for correctness using artificial data against manually calculated values. No comparison was made with other implementations.PercentilesTested for correctness using a simple case with artificial data against manually calculated values.point_densityTested for correctness on artificial data.
Package: laserembeddings
LASER embeddingsOut-of-the-box multilingual sentence embeddings.laserembeddings is a pip-packaged, production-ready port of Facebook Research'sLASER(Language-Agnostic SEntence Representations) to compute multilingual sentence embeddings.Have a look at the project's repo (master branchorthis release) for the full documentation.Getting startedPrerequisitesYou'll need Python 3.6+ and PyTorch. Please refer toPyTorch installation instructions.Installationpip install laserembeddingsChinese languageChinese is not supported by default. If you need to embed Chinese sentences, please install laserembeddings with the "zh" extra. This extra includesjieba.pip install laserembeddings[zh]Japanese languageJapanese is not supported by default. If you need to embed Japanese sentences, please install laserembeddings with the "ja" extra. This extra includesmecab-python3and theipadicdictionary, which is used in the original LASER project.If you have issues running laserembeddings on Japanese sentences, please refer tomecab-python3 documentationfor troubleshooting.pip install laserembeddings[ja]Downloading the pre-trained modelspython -m laserembeddings download-modelsThis will download the models to the defaultdatadirectory next to the source code of the package. Usepython -m laserembeddings download-models path/to/model/directoryto download the models to a specific location.UsagefromlaserembeddingsimportLaserlaser=Laser()# if all sentences are in the same language:embeddings=laser.embed_sentences(['let your neural network be polyglot','use multilingual embeddings!'],lang='en')# lang is only used for tokenization# embeddings is a N*1024 (N = number of sentences) NumPy arrayIf the sentences are not in the same language, you can pass a list of language codes:embeddings=laser.embed_sentences(['I love pasta.',"J'adore les pâtes.",'Ich liebe Pasta.'],lang=['en','fr','de'])If you downloaded the models into a specific directory:fromlaserembeddingsimportLaserpath_to_bpe_codes=...path_to_bpe_vocab=...path_to_encoder=...laser=Laser(path_to_bpe_codes,path_to_bpe_vocab,path_to_encoder)# you can also supply file objects instead of file pathsIf you want to pull the models from S3:fromioimportBytesIO,StringIOfromlaserembeddingsimportLaserimportboto3s3=boto3.resource('s3')MODELS_BUCKET=...f_bpe_codes=StringIO(s3.Object(MODELS_BUCKET,'path_to_bpe_codes.fcodes').get()['Body'].read().decode('utf-8'))f_bpe_vocab=StringIO(s3.Object(MODELS_BUCKET,'path_to_bpe_vocabulary.fvocab').get()['Body'].read().decode('utf-8'))f_encoder=BytesIO(s3.Object(MODELS_BUCKET,'path_to_encoder.pt').get()['Body'].read())laser=Laser(f_bpe_codes,f_bpe_vocab,f_encoder)
Package: laserfarm
LaserfarmLaserfarm (Laserchicken Framework for Applications in Research in Macro-ecology) provides a FOSS wrapper toLaserchickensupporting the use of massive LiDAR point cloud data sets for
macro-ecology, from data preparation to scheduling and execution of distributed processing across a cluster of compute
nodes.InstallationLaserfarm requires thePDALandGDALlibraries and the PDAL Python
bindings. These packages are most easily installed throughcondafrom theconda-forgechannel:condainstallpdalpython-pdalgdal-cconda-forgeLaserfarm can then be downloaded and installed usingpip:pipinstalllaserfarmor usinggit+pip:gitclonegit@github.com:eEcoLiDAR/Laserfarm.gitcdLaserfarm
pipinstall.In order to setup a new conda environment with Laserfarm and all its dependencies, the YAML file provided can be
employed:condaenvcreate-fenvironment.ymlDocumentationThe project's full documentation can be foundhere.Applications and Current LimitationsThis package has been tested on data provided in a metric-based 2D-projected Cartesian coordinate system, i.e. theActueel Hoogtebestand Nederland.
While some of the tools of Laserfarm could be applied to data in an ellipsoidal latitude/longitude coordinate system
as well, this has not been tested and it is generally expected to fail.ContributingIf you want to contribute to the development of Laserfarm,
have a look at thecontribution guidelines.LicenseCopyright (c) 2022, Netherlands eScience CenterLicensed 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 athttp://www.apache.org/licenses/LICENSE-2.0Unless 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.
Package: laserfields
laserfieldslaserfieldsis a library to describe the time-dependent electric fields of
a laser pulse. It implements the same pulse shapes and most of the features of
thelaserfields librarywritten in
Fortran. Please see the documentation of that library for the parameter
meanings, conventions used, etc. In particular, the "main" functionmake_laserfield(**kwargs...)accepts the same parameters as the Fortran library
parameter files as keyword arguments, and returns an instance of a subtype of
the base classLaserFielddepending on the parameters. E.g., to create
a Gaussian pulse with a duration (defined as the FWHM of the intensity) of 6 fs,
a wavelength of 800 nm, a peak intensity of 1e14 W/cm^2, and with the peak at
time t=7fs, one should calllf=make_laserfield(form="gaussianI",is_vecpot=true,lambda_nm=800,intensity_Wcm2=1e16,duration_as=6000,peak_time_as=7000)Given aLaserFieldinstancelf, the functionslf.E(t),lf.E_fourier(ω),lf.A(t), andlf.A_fourier(ω)can be used to obtain,
respectively, the electric field as a function of time, its Fourier transform
(implemented for most pulse shapes), the vector potential as a function of time,
and its Fourier transform. Calling the instance as a function,lf(t)returns
the electric field, i.e., is equivalent tolf.E(t). The notebooks in theexamplesfolder show some ways to use the library, including how to define a
set of fields through a YAML configuration file.The "effective" duration of the pulse for n-photon processes can be obtained aslf.Teff(n_photon), which is the integral over the pulse intensity envelope to
the n-th power (i.e., electric field envelope to the (2n)th power)
over the pulse, see, e.g.,https://doi.org/10.1103/PhysRevA.77.043420(Eq. 14).
Package: laserforce.py
# laserforce.py
[![Build Status](https://travis-ci.org/SpookyBear0/laserforce.py.svg?branch=master)](https://travis-ci.org/SpookyBear0/laserforce.py)
[![Documentation Status](https://readthedocs.org/projects/laserforcepy/badge/?version=latest)](https://laserforcepy.readthedocs.io/en/latest/?badge=latest)
[![MIT](https://img.shields.io/pypi/l/gd.py.svg)](https://opensource.org/licenses/MIT)A python package for Laserforce!
Package: laserhammer
LaserHammer is a simple DocBook to mdoc(7) ("UNIX man page syntax") converter.The command line utility resides in the scripts/ subdirectory; use it like this:./laserhammer book.parsed.xml book.7The 7 above stands for section 7 of man pages, "miscellaneous documentation".
The 'book.parsed.xml' is a processed XML source of the FreeBSD Handbook; you can
use it as test sample.  The 'book.7' is the example translated into mdoc.There's also a rudimentary Python module.  Use it like this:import laserhammer

mdoc = laserhammer.laserhammer(file_path)
print(mdoc)