Saravanan666/pypi-org huggingface dataset:
Package: limu
Tool to analyse images of cleared and trypan blue stained leaves to assess leaf damage.limu_original.py is the program used for the original publication.limu.py is updated to be somewhat flexible with project parameters outside the script itself. It might need tweaking to suit your project though.Currently only works with Canon .cr2 raw images. If you have other types please let me know and I might add other formats.usage: limu [-h] [-p PROJECT] [-i INDIR] [-v] [-r]

Tool to analyse images of cleared and troptophan stained leaves to assess leaf damage.

optional arguments:
  -h, --help            show this help message and 

  -p PROJECT, --project PROJECT
                        path to projects directory, if not supplied one will
                        be requested interactively. If limu.conf file found in
                        current working directory, this will be used

  -i INDIR, --input-dir INDIR
                        path to infile root directory

  -v, --verbose         Print more stuff

  -r, --recalculate     Force recalculation, NOT IMPLEMENTEDMulaosmanovic, E., Lindblom, T.U.T., Bengtsson, M., Windstam, S.T., Mogren, L., Marttila, S., Stützel, H., Alsanius, B.W., 2020. High-throughput method for detection and quantification of lesions on leaf scale based on trypan blue staining and digital image analysis. Plant Methods 16, 62.https://doi.org/10.1186/s13007-020-00605-5Full source is available athttps://gitlab.com/thorgil/limu
Package: lin2023
Linear Regression System with CI/CDThe CodeCloning the code:git clone https://github.com/budi-kurniawan/linear-regressionCreating A Model:python simple_linear_regrsssion.pyThe model (model.sav file) will be saved to the current directory.Run the unittestpython -m pytestDockerMake sure an app directory has been created
$ cd $PROJECT_DIR
$ docker build --tag lin2023 .
$ docker run -i -p 5000:5000 -d lin2023To pull the Docker image from Docker Hub$ docker pull budi2020/lin2023[:tagName]
$ docker pull budi2020/lin2023:v0.0.1
Package: linalg
linalgInstallationInstallation can be done throughpip. You must have python version >= 3.6.pip install linalgDocsDocs can be found at thereadthedocs pageWhat is this?NOT intended to be the best or fastest.NOT intended to be production-grade (yet).IS intended to be fully vanilla python3.IS meant as an educational tool.Technical detailsThis package usesblackfor formatting andsemverfor versioning.UsageThis package provides theMatrixclass and utility functions.import linalg
from linalg import *  # import the Matrix class and utility functions top-level
from linalg import Matrix  # import the Matrix classTo create a matrix object, initialize it with a 2D list or useMatrix.zeroes()orMatrix.identity(). You can also userandom_matrix().mat = linalg.Matrix([[3, 4, 5], [2, 5, -1], [0, 2, 1]])  # 3x3 matrix
mat = linalg.as_matrix([[3, 4, 5], [2, 5, -1], [0, 2, 1]])  # 3x3 matrix, alternative notation
mat = linalg.zeroes(4, 2)  # 4x2 zero matrix
mat = linalg.identity(4)  # 4x4 identity matrix
mat = linalg.random_matrix((2, 3), (-10, 10))  # 2x3 matrix with elements within (-10, 10)This package implements matrix multiplication with the python matrix multiplication operator@(__matmul__). The matrix multiplication of twolinalg.MatrixA, B isC = A @ B.After that, you can use multiple functions to perform linear algebraic operations as explained in the above linked docs.TodoAdd other linear algebraic operationsImplement vectorsAdd documentation
Package: linalg-basic
Linalg BasicThis library is slightly adapted from Joel Grus's Python linear algebra library as he wrote it in chapter 4 of his bookData Science from Scratch. I've assembled it purely to use its parts in my "Linalg Deluxe" library, which adds many more linear algebra operations.Since Linalg Basic is largely Joel Grus's work, I've not bothered documenting it very well or testing it. More extensive documentation, testing, etc. can be found in my Linalg Deluxe library, which builds upon Linalg Basic and is actually my own original work. Go look at that, not this, for a proper demonstration of my skills.
Package: linalg-deluxe
Linalg DeluxeAn extension of Joel Grus's linear algebra Python library as he wrote it in chapter 4 ofData Science from Scratch. I have added transposition, symmetry checking, multiplication of vectors by matrices, the angle between two vectors, outer products, cross products, matrix multiplication, determinants, adjoint matrices, and inverse matrices (plus some input-checking helper functions).Installationpip install linalg-basic
pip install linalg-deluxeGet startedThe following code walks through just a few of the library's features:from linalg_deluxe.linalg_deluxe import transpose, multiply_matrix_vector, symmetric, inverse_matrix

# Create a Vector and a Matrix (the two data types the library runs on)
v = [1, 2, 3]
m = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

# Transpose v and m
v_vertical = transpose(v)
m_transposed = transpose(m)

# Multiply m by v
m_x_v = multiply_matrix_vector(m, v)

# Is m symmetric?
m_sym = symmetric(m)

# Attempt to generate m's inverse
# This will fail, because m's determinant is not zero in this case
m_inv = inverse_matrix(m)
Package: lin-alg-djl
# Udacity Data Science Project PackageThis package is a demonstration of creating and uploading a working package with PyPi.## Installationpip install lin_alg_djl## UseThis package is built from a code along for the Udacity course on Linear Algebra with Python.Classes is a great refresher on Linear Algebra and Python classes.https://classroom.udacity.com/courses/ud953ClassesVectorPlaneLineHyperplaneLinearSystem
Package: linalg-for-datasci
linalg_for_datasciCode supporting the computational instruction for the course STAT 89A: Linear Algebra for Data Science at UC Berkeley.ContributingIf thepre-commitPython package is installed, you can set uppre-commithooks for automatic code formatting viapre-commit installYou can also invoke the pre-commit hook manually at any time withpre-commit runAutomatic code formatting has been adopted forlinalg_for_datascito make it unnecessary for contributors to worry about their code style.
As long as the code is valid, the pre-commit hook should take care of how the code should look.There are also plugins tointegrate theblackcode autoformatter into your favorite code editor. This way you can format code automatically.If you have already committed files before setting up the pre-commit hook withpre-commit install, you can fix everything up usingpre-commit run --all-files. You need to make the fixing commit yourself after that.
Package: linalg-simple
linalg_simpleA simple linear algebra package written in Python 3This is a more or less direct implementation of theUdacityLinear Algebra Refresher Course.Installationlinalg_simpleis available from the Python Package IndexPyPi.
If you have Python 3 installed on your system you can use thepip installcommand:pip install linalg_simpleClassesThe linalg_simple package currently offers theVector()class, which can directly be imported into your project with:fromlinalgimportVectorVector ClassAttributesTheVector()class has two attributes:Vector.coordinates(Decimal object)Vector.dimension(int)MethodsThe followingVector()class methods are available:ConstructorArguments: int, floatv1 = Vector([1.5, -4.8, 3])+ Methodv3 = v1 + v2- Methodv3 = v1 - v2Scalar MutliplicationArguments: int, floatv1.times_scalar(42)Magnitudevector_length = v1.magnitude()Vector Normalizationunit_vector = v1.normalized()Dot ProductArguments: vector objectdot_product = v1.dot(v2)Angle between two vectorsArguments: vector objectangle = v1.angle_with(v2)Check if vector's length is zeroTo avoid precision errors, you can indicate a tolerance (default: 1e-10).v1.is_zero()Check if two vectors are orthogonal to each otherTo avoid precision errors, you can indicate a tolerance (default: 1e-10).Arguments: vector object, tolerancev1.is_orthogonal_to(v2)Check if two vectors are parallel to each otherArguments: vector objectv1.is_parallel_to(v2)Calculate projection of a vector onto a basis vectorArguments: vector object (basis vector)projection_vector = v1.component_parallel_to(v2)Calculate orthogonal component of vectorArguments: vector object (basis vector)projection_vector = v1.component_orthogonal_to(v2)Calculate Cross Product of two vectorsThe vectors should be 3D (2D vectors will be augmented to 3D).Arguments: vector objectcrossproduct_vector = v1.cross(v2)Calculate the parallelogram spanned by two vectorsArguments: vector objectarea = v1.area_of_parallelogram_with(v2)Calculate area of a parallelogram spanned by two vectorsArguments: vector objectarea = v1.area_of_parallelogram_with(v2)Calculate area of a trinagle spanned by two vectorsArguments: vector objectarea = v1.area_of_triangle_with(v2)
Package: linaro-django-pagination
About the forkThis project is a fork of apparently dead “django-pagination” project
originally written by ‘Eric Florenzano’. It is maintained by the Linaro
Validation/Infrastructure team. Latest releases can be found on launchpad and
pypi.We are in the process of deciding how to properly host and manage the project.
Feel free to hop to #linaro on irc.freenode.net and ask either ‘zyga’ or
‘mwhudson’ about this.About top-level package name changeThe top level package name was changed frompaginationtolinaro-django-pagination. I did this to ensure that existing users of the
original package could easily transition, on their own terms. Since both
packages are co-installable you are free to check things out and see if the new
pagination code works well for you or not.Also, since the implementation of the actual tags was rewritten I would not
feel entirely confident that the new package is a drop-in replacement.ContributorsWe would like to welcome any and all contributors. Please use the pull request
feature on github.How to use linaro-django-paginationSee our official documentation for more details.http://packages.python.org/linaro-django-pagination/
Package: lincbrain-cli
LINC Brain ClientTheLINC Brain Python clientallows you to:DownloadDatasetsand individual subject folders or filesValidate data to locally conform to standardsOrganize your data locally before uploadUploadDatasetsInteract with the LINC Brain archive's web API from PythonDelete data in the LINC Brain archivePerform other auxiliary operations with data or the LINC Brain archiveNote: This project is under heavy development. Seethe issues logorWork-in-Progress (WiP).InstallationLINC Brain Client releases areavailable from PyPIandconda-forge.  Install them in your Python (native, virtualenv, or
conda) environment viapip install lincbrain-cliorconda install -c conda-forge lincbrain-cliCLI ToolThis package provides a command line utility with a basic interface
to help you prepare and upload your data to, or obtain data from, theLINC Brain archive.$>lincbrain
Usage:lincbrain[OPTIONS]COMMAND[ARGS]...AclienttosupportinteractionswithLINCBrainarchive(https://lincbrain.org).Toseehelpforaspecificcommand,runlincbrainCOMMAND--helpe.g.lincbrainupload--help

Options:--version-l,--log-level[DEBUG|INFO|WARNING|ERROR|CRITICAL]Loglevel(caseinsensitive).Maybespecifiedasaninteger.[default:INFO]--pdbFallintopdbiferrorsout--helpShowthismessageandexit.

Commands:deleteDeletedatasetsandassetsfromtheserver.digestCalculatefiledigestsdownloadDownloadafileorentirefolderfromLINCBrainArchive.instancesListknownLINCBrainArchiveinstancesthattheCLIcan...lsList.nwbfilesanddatasetsmetadata.moveMoveorrenameassetsinalocalDatasetand/oron...organize(Re)organizefilesaccordingtothemetadata.shell-completionEmitshellscriptforenablingcommandcompletion.uploadUploadDatasetfilestoLINCBrainArchive.validateValidatefilesforNWBandLINCBraincompliance.validate-bidsValidateBIDSpaths.Runlincbrain --helporlincbrain <subcommand> --help(e.g.lincbrain upload --help) to see manual pages.ResourcesThe LINC Brain ecosystem is forked from theDANDI Archive project. Resources there should point
you towards common questions encountered within the LINC Brain project.To learn how to interact with the LINC Brain Archive (e.g. a forked DANDI archive) and for examples on how to use the DANDI Client in various use cases,
seethe handbook(specifically the sections on using the CLI todownloadanduploadDandisets).To get help:ask a question:https://github.com/dandi/helpdesk/discussionsfile a feature request or bug report:https://github.com/dandi/helpdesk/issues/new/choosecontact the DANDI team:help@dandiarchive.orgTo understand how to contribute to the dandi-cli repository, see theDEVELOPMENT.mdfile.
Package: linchemin
LinChemIn (Linked Chemical Information)The Linked Chemical Information (LinChemIn) package is a python toolkit that allows chemoinformatics operations on synthetic routes and reaction networks.Authors and MaintainersMarta PasquiniMarco StentaResourcesresource typelinkproject pagehttps://linchemin.github.iorepositoryhttps://github.com/syngenta/linchemindocumentationhttp://linchemin.readthedocs.iopypi pagehttps://pypi.org/project/lincheminInstall for usage1) pypipip install linchemin2) clone & pipgit clonehttps://github.com/syngenta/linchemincd linchemin
pip install .3) pip from gitpip install git+https://github.com/syngenta/lincheminInstall for developmentgit clonehttps://github.com/syngenta/linchemincd linchemin
pip install -e .[dev]Testing is based on pytestConfigurationThis package requires some configuration parameters to work,
including some secretes to store access credentials to database and services.
After installation, and before the first usage, the use should run the following commandlinchemin_configurehis command generates the user_home/linchemin directory and places into it two files:settings.toml populated with defaults settings. The user can review and modify these values if necessary..secrets.toml containing the keys for the necessary secrets. The user must replace the placeholders with the correct values
For more details please refer to the Configuration section of the documentation
Package: linchpin
LinchPin provides a command-line interface and Python API for provisioning and
managing resources across multiple infrastructures. Where multiple
infrastructure resource types can be defined with a single topology file.LinchPin can also generate inventory files for use with additional Ansible
playbooks. These are applied using an inventory layout file.Contributing and Community ParticipationDevelopers are encouraged to contribute to the LinchPin project. Please visitContributingfor details.Subscribe and participate on theLinchPin Mailing ListJoin the#linchpinIRC chat channel onfreenodeInstallationInstallation documentationQuickStartTheGetting Started Guideis a quick guide for LinchPin from the Command-Line.Using LinchPinCheck out theGetting Started Guidefor a quick guide on how to use LinchPin from the Command-Line.For API documentation, check out thePython API Reference.
Package: lincl
linclLinux commands line as python methodsThis project is ccreate to help avoiding callingsubprocess.
While working on another script project I was doing lot o system calls. Having
to always import subprocess with Popen, checkoutput, checkcall with ugly
arguments to pass as–show-linesor–include=A,B,C, I decided to
implement somethingpythonreadable.UsagePythonic approch and very simple to use:fromlinclimportcpascopycopy(src,dest,recursive=True,force=True)>>cp--recursive--forcesrcdest# Orfromlinclimportdeboostrapdeboostrap("stable","destination",variant="buildd"include=["A","B","C"])>>deboostrap--variant=buildd--include=A,B,CstabledestinationRequirementsTo use this package you need:Python 3.7 or higher (Tested with python3.7. Let me know for lowers)Linux based is prefered (Tested on Debian buster)You still need sudo for sudo syscallInstallationThere is no pip package if you are interested in having one feel free to
suggest. Otherwize install using:
Package: lincolntools-config
lincolntools-configlincolntools : Python toolbox made inLincoln FranceAuthor: Lincoln InnovationCreation date: 2020-10-01seeAUTHORS.mdThis package belongs to thelincolntoolsnamespaceThe goal of this package is to provide the necessary tools to create a unique and global configuration object that can be queried anywhere in a Python project.Table of contentDocumentationTestsContributeHistoryCreditsInstallationpipinstalllincolntools-configHow to useThere are several possibilities to load a YAML configuration file :Provide the path toa filewhich will be processed and transformed into a PythondictProvide the path toa folderthat contains one or more YAML files that will be concatenated into a single object.ExampleIn the following examples we suppose our config folder has the given structure :└──config├──config_foo├──foo.yaml└──foo.template└──config_bar├──bar.yaml└──bar.templatefoo.yamlfoo:foo_key:foo_valuebar.yamlbar:bar_key:bar_valueCode :fromlincolntools.configimportConfigmy_config=Config('/path/to/config')print(my_config.conf)# {'foo': {'foo_key': 'foo_value'}, 'bar': {'bar_key': 'bar_value'}, '_version': 1}print(my_config.get('foo'))# {'foo_key': 'foo_value'}print(my_config.get('foo').get('foo_key'))# foo_valueprint(my_config.get('foo')['foo_key'])# same as above but with another syntax# foo_valueprint(my_config.flatten())# {'foo-foo_key': 'foo_value', 'bar-bar_key': 'bar_value'}print(my_config.dump())# _version: 2# bar:#   bar_key: bar_value# foo:#   foo_key: foo_valueImportantTheConfigclass is based on the Single design pattern (official documentation).TLDR: Only one instance ofConfigcan be initialized during the whole program lifetime.fromlincolntools.configimportConfigmy_first_config=Config('/path/to/config')# ok, no other instance existsmy_other_config=Config('/path/to/config')# nok# Exception: This is a singletonTestsLaunch tests with the default Python version :# in the project folderpytestLaunch tests on multiple Python versions (seetox.ini) :# in the project foldertoxHistoryVoirHISTORY.mdCreditsThis package was inspired by Cookiecutter_ and theaudreyr/cookiecutter-pypackage_ project template._Cookiecutter:https://github.com/audreyr/cookiecutter_audreyr/cookiecutter-pypackage:https://github.com/audreyr/cookiecutter-pypackageHistory1.0.0 (2020-10-01)First version1.0.1 (2021-01-15)Adding cfg_path argument in get/get_instance methodsAdding easydict for more convenient navigation1.0.2 (2021-01-15)Now look for .yaml and .yml files when directory is provided1.0.3 (2021-02-05)Concatenante yaml files before parsing. Allows anchor to be cross files.1.0.4 (2021-08-10)Documentation and comments translation.
Package: lincot
InstallationLINCOT requires Python 3.6 or above.LINCOT functionality is provided by a command-line tool calledlincot, which can be
installed several ways.Installing as a Debian/Ubuntu Package [Use Me!]:$ wget https://github.com/ampledata/pytak/releases/latest/download/python3-pytak_latest_all.deb
$ sudo apt install -f ./python3-pytak_latest_all.deb
$ wget https://github.com/ampledata/lincot/releases/latest/download/python3-lincot_latest_all.deb
$ sudo apt install -f ./python3-lincot_latest_all.debInstall from the Python Package Index [Alternative]:$ python3 -m pip install -U pytak
$ python3 -m pip install -U lincotInstall from this source tree [Developer]:$ git clone https://github.com/ampledata/lincot.git
$ cd lincot/
$ python3 -m pip install .UsageLINCOT can be configured with a INI-style configuration file, or using
environmental variables.Command-line options:usage: lincot [-h] [-c CONFIG_FILE] [-p PREF_PACKAGE]

optional arguments:
-h, --help            show this help message and exit
-c CONFIG_FILE, --CONFIG_FILE CONFIG_FILE
                        Optional configuration file. Default: config.ini
-p PREF_PACKAGE, --PREF_PACKAGE PREF_PACKAGE
                        Optional connection preferences package zip file (aka Data Package).Configuration options:COT_URLstr,  default: udp://239.2.3.1:6969URL to CoT destination. Must be a URL, e.g.tcp://1.2.3.4:1234ortls://...:1234, etc. SeePyTAKfor options, including TLS support.COT_STALEint, default: 3600CoT Stale period (“timeout”), in seconds. Default3600seconds (1 hour).COT_TYPEstr, default: a-u-S-X-MOverride COT Event Type (“marker type”).See example-config.ini in the source tree for example configuration.# python3 -c “import uuid;nn=str(uuid.getnode());print(nn[len(nn)-4:len(nn)])”SourceGithub:https://github.com/snstac/lincotLicense & CopyrightCopyright 2023 Sensors & Signals LLCLicensed 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: lincs-cookiecutter
lincs_cookiecutterThis is a toy test to try cookiecutter2 during LINCS tutorialFree software: GNU General Public License v3Documentation:https://ibgp2.github.io/lincs_cookiecutter/.FeaturesTODOCreditsThis package was created withCookiecutterand thefrancois-durand/package_helper_2project template.History0.1.1 (2022-01-19): First patchFirst test patch0.1.0 (2022-01-19): First releaseFirst release on PyPI.
Package: linda
Linda is an widely studied distributed computing environment, centred around
the notion of a tuple space. A tuple space is a bag (also called a multi-set) of
tuples. A tuple is an ordered, typed chunk of data. Tuple spaces exist
independently of processes in the system, and the data placed into a tuple space
also exist independently. See “Generative communication in Linda” (1985) and
“Multiple tuple spaces in Linda” both by David Gelernter for more information on
Linda.PyLinda is a simple implementation of a linda system, however it also includes
several of the more recently proposed extensions to Linda in the form of multiple
tuple spaces, garbage collection, sane non-blocking primitives and bulk tuple
operations.