Saravanan666/pypi-org huggingface dataset:
Package: lsat
LSA-T: The first continuous LSA datasetLSA-T is the first continuous Argentinian Sign Language (LSA) dataset. It contains 14,880 sentence level videos of LSA extracted from theCN Sordos YouTube channelwith labels and keypoints annotations for each signer. Videos are in 30 FPS full HD (1920x1080).Download link(45GB compressed)Visualization notebookPresentation paper (TO-DO)FormatSamples are organized in directories according to the playlists and video they belong to. For each sampleithere are four files:i.mp4: the clip corresponding to the ith line of subtitles.i.jsoncontains:label: the line of subtitles corresponding to the clip.start: time in seconds where the subtitle starts.end: time in seconds where the subtitle ends.video: title of the video which the clip belongs to.playlist: title of the playlist which the clip belongs to.i_ap.json: the raw AlphaPose results over the clip usingHalpe KeyPointsinAlphaPose default output format.i_signer.jsoncontains:scores: for each person in the clip, the amount of "movement" in its hands. It is used to infer who is the signer.roi: the considered region of interest of the clip (bounding box of the infered signer).keypoints: list of keypoints for each frame of the infered signer in same format that ini_ap.json.UsageThis repository can be installed viapipand contains theLSA_Datasetclass (inlsat.dataset.LSA_Datasetmodule). This class inherits from thePytorch dataset classand implements all necessary methods for using it with a Pytorch dataloader. It also manages the downloading and extraction of the database.Also, useful transforms for the clips and keypoints are provided inlsat.dataset.transformsStatistics and comparison with other DBsLSA-TPHOENIX*SIGNUMCSLGSLKETIlanguageSpanishGermanGermanChineseGreekKoreansign languageLSAGSLGSLCSLGSLKLSreal lifeYesYesNoNoNoNosigners10392550714duration (h)21.7810.7155.3100+9.5128# samples14,880709633,21025,00010,29514,672# unique sentences14,2545672780100331105% unique sentences95.79%79.93%2.35%0.4%3.21%0.71%vocab. size (w)14,2392887N/A178N/A419# singletons (w)715010770000% singletons (w)50.21%37.3%0%0%0%0%vocab. size (gl)-1066450-310524# singletons (gl)-3370-00# singletons (gl)-31.61%0%-0%0%resolution1920x1080210x260776x5781920x1080848x4801920x1080fps302530303030*Data was not available for the whole PHOENIX dataset, so the table show its train set statistics.Evaluation splitsLSA-TFull versionReduced versionTrainTestTrainTestsigners103XXXXduration [h]21.7817.494.2915.853.89# sentences14,88011,06527353767910% unique sentences95.79%96.64%92.78%96.88%98.35%vocab. size14,23912,385554626941579% singletons50.21%52.01%61.9%23.2%48.83%% sentences with singletons34.97%40.98%67.97%14.36%54.29%% sentences with words not in train vocabulary--59.2%-84.5%CitationTO-DO
Package: lsbi
lsbi:Linear Simulation Based InferenceAuthor:Will Handley & David YallupVersion:0.12.0Homepage:https://github.com/handley-lab/lsbiDocumentation:http://lsbi.readthedocs.io/A repository for linear modelling and simulation based inferenceUNDER CONSTRUCTIONFeaturesInstallationlsbican be installed via pippipinstalllsbivia condacondainstall-chandley-lablsbior via the github repositorygitclonehttps://github.com/handley-lab/lsbicdlsbipython-mpipinstall.You can check that things are working by running the test suite:python-mpytestblack.isort--profileblack.pydocstyle--convention=numpylsbiDependenciesBasic requirements:Python 3.6+anestheticDocumentation:sphinxnumpydocTests:pytestDocumentationFull Documentation is hosted atReadTheDocs.  To build your own local copy of the documentation you’ll need to installsphinx. You can then run:python-mpipinstall".[all,docs]"cddocsmakehtmland view the documentation by openingdocs/build/html/index.htmlin a browser. To regenerate the automatic RST files run:sphinx-apidoc-fM-tdocs/templates/-odocs/source/lsbi/CitationIf you uselsbito generate results for a publication, please cite
as:Handley et al, (2024) lsbi: Linear Simulation Based Inference.or using the BibTeX:@article{lsbi,year={2023},author={Will Handley et al},title={lsbi: Linear Simulation Based Inference},journal={In preparation}}ContributingThere are many ways you can contribute via theGitHub repository.You canopen an issueto report bugs or to propose new features.Pull requests are very welcome. Note that if you are going to propose major changes, be sure to open an issue for discussion first, to make sure that your PR will be accepted before you spend effort coding it.Adding models and data to the grid. ContactWill Handleyto request models or ask for your own to be uploaded.Questions/Comments
Package: lsbranch
lsbranchList all directories with .git subdirectory and show current branch for each.Instalationpip install lsbranchCLI UsageUsage:lsbranch[OPTIONS]Listalldirectorieswith.gitsubdirectoryandshowcurrentbranchforeach

Options:-r,--recursiveRecursivedirectorysearch-p,--pathPATHPathtosearch--helpShowthismessageandexit.Let's say that you want to list all git dirs in current dir, recursively>lsbranch-r-p.Let's say you just want to list all git dirs in current dir, not recursively>lsbranch
Package: lsbsteg
title: Non-suspicious image decoder
emoji: 🥳
colorFrom: red
colorTo: yellow
sdk: gradio
sdk_version: "3.13.2"
app_file: app.py
pinned: falseNon Suspicious Image DecoderRecover pandas dataframe hidden in imageBased onhttps://github.com/RobinDavid/LSB-Steganography
Package: lscae
Laplacian Score-regularized Concrete AutoencodersRequirements:torch >= 1.9scikit-learn >= 0.24omegaconf >= 2.0.6scipy >= 1.6.0matplotlibHow to use:Install the package from pypi:pip install lscaePrepare your dataset by applying Standard Scaler on itfromsklearn.preprocessingimportStandardScalerscaler=StandardScaler()dataset=scaler.fit_transform(dataset)Then load it astorch.utils.data.Datasetand run feature selection
Please see an examplehereimportlscaeimporttorchfromomegaconfimportOmegaConf# define you cfg parameterscfg=OmegaConf.create({"input_dim":100})# define you dataset (Torch based)dataset=torch.utils.data.Dataset(...)dataloader=torch.utils.data.DataLoader(dataset,batch_size=cfg.batch_size,shuffle=True,drop_last=True)lscae.Lscae(kwargs=cfg).select_features(dataloader)
Package: lsclib
lsclib is a python-based repository hosted on GitHub that employs the
Monte Carlo ray-tracing method of radiative transport to effectively model
LSCs. lsclib hopes to short-circuit the learning curve associated with
breaking into the field, and present results in both an academic and
commercial context. This repository will continue to become more
sophisticated, but for now relies heavily upon the paper submitted for
publishing entitled "An open-source Monte Carlo ray-trace simulation tool
for luminescent solar concentrators with validation studies employing
scattering phosphor films."
Package: lscolumn
lscolumnPrint a list of strings in columns like inls.DescriptionTwo styles are available -- BSD-style and GNU-style.
Let's see through example:>>> import lscolumn
>>> lscolumn.pprint(['hello', 'hola world', 'greetings', 'hello again and again'],
...                 total_width=60, style='BSD')
hello                 greetings
hola world            hello again and again
>>> lscolumn.pprint(['hello', 'hola world', 'greetings', 'hello again and again'],
...                 total_width=60, style='GNU')
hello  hola world  greetings  hello again and againIn BSD-style, the widths of the columns are the same, whereas in GNU-style, they are different.
When formatting long list, BSD-style is faster than GNU-style, but GNU-style is more compact.CJK (wide) characters are well supported thanks tocjkjust.Installationpip install lscolumnFunctions and ClassesFor detailed help, tryhelp(...)in Python REPL.pprint(strings, total_width=None, style='BSD', file=None): print in columns the list of stringsstringsBSDFormatter: the BSD-style formatter (see example below)GNUFormatter: the GNU-style formatter (see example below)Example usingBSDFormatterimportlscolumnbsd=lscolumn.BSDFormatter(total_width=80)# print one listbsd.pprint(['hello','hola world','greetings'])# print another list using the same configurationbsd.pprint(['greetings','hello again and again'])# print yet another list to `outfile`withopen('filename.txt','w')asoutfile:bsd.pprint(['hello','hola world'],file=outfile)The same applies toGNUFormatter.
Package: lscom
lscom: list and discover available COM portsMore quickly identify which COM ports are available for use. Any COM ports already in use will not be listed.lscomshould work cross platform (Linux, macOS, Windows), but has not been extensively tested. Have a problem? Open an issue.Usage Example$ lscom
['COM3']PyPI Installationpython-mpipinstalllscomLocal Installation ExampleTo install manually:Clone repository.Open the terminal to the root of the repository.Run-python-mpipinstall.You should now be able to runlscomfrom your terminalIf you can't, check and make sure the scripts directory is included in the system path environment variable.To remove:python-mpipuninstalllscom
Package: lscsoft-glue
LSCSoft-GLUE: the LSCSoft Grid LSC User EnvironmentLSCSoft-GLUE is a collection of utilities for running data analysis pipelines
for online and offline analysis as well as accessing various grid utilities.Please refer to the online documentation:https://lscsoft.docs.ligo.org/glue/GLUE is distributed under the GNU General Public License, version 3 (or later).
See the fileLICENSEfor more information.InstallationCondaLSCSoft-GLUE is available from conda-forge aslscsoft-glue;
to install:condainstall-cconda-forgelscsoft-glueDebian LinuxLSCSoft-GLUE is distributed for Debian in theLSCSoft Debian Repositoriesfor Debian 10 (Buster) and Debian 11 (Bullseye); to install:apt-getinstalllscsoft-glue-utilsfor the full Python 3 library and scripts, orapt-getinstallpython3-lscsoft-glueto install only the Python 3 library.Enterprise LinuxLSCSoft-GLUE is distributed for Enterprise Linux in the LSCSoftEL7andEL8repositories; to install:yuminstalllscsoft-glue-utilsfor the full Python 3 library and scripts, orapt-getinstallpython3-lscsoft-glueto install only the Python 3 library.PyPILSCSoft-GLUE is available from PyPI aslscsoft-glue;
to install:python-mpipinstalllscsoft-glue
Package: lsdb
LSDBLSDB - Large Survey DataBaseA framework to facilitate and enable spatial analysis for extremely large astronomical databases
(i.e. querying and crossmatching O(1B) sources). This package uses dask to parallelize operations across
multiple HiPSCat partitioned surveys.Check out ourReadTheDocs sitefor more information on partitioning, installation, and contributing.See related projects:HiPSCat (on GitHub)
(on ReadTheDocs)HiPSCat Import (on GitHub)
(on ReadTheDocs)ContributingSee thecontribution guidefor complete installation instructions and contribution best practices.AcknowledgementsLINCC Frameworks is supported by Schmidt Futures, a philanthropic initiative
founded by Eric and Wendy Schmidt, as part of the Virtual Institute of
Astrophysics (VIA).
Package: ls-django-treeadmin
ls-django-treeadmin===================ls-django-treeadmin is a complement to models that are`django-mptt`_-enabled. It provides a drag-&-drop interface to modify thetree.It was originally developed as part of `FeinCMS`_. They deserve all thekudos for this.This version is a fork of `piquadrat`'s version, updated for django 1.7,and Python 3 as well.NOTE: this has not been tested with Django > 1.7.. _django-mptt: https://github.com/django-mptt/django-mptt.. _FeinCMS: http://www.feinheit.ch/media/labs/feincms/.. _piquadrat: http://github.com/piquadrat/django-treeadmin0.4.8=====Fix "too many values to unpack error", add .gitignore0.4.7=====PEP 8 changes, copyright updates0.4.6 (Unreleased)=====Merge PR#2, update python3 support, rename JQquery to JQuery0.4.5=====Fix error importing pull request for django > 1.6 support0.4.4=====Fix error importing pull request for django > 1.6 support0.4.3=====Updated for packaging and distributionModified to run with Python 30.4.2=====Updated for Django 1.7, changed name, included some of the pull requestsoutstanding on the original project.
Package: lsdnumbatools
# lsdnumbatoolsDISCLAIMER: early and WIP, do not use if you don’t know what you are doing!Provides numba framework for topographic analysis within the LSDTopoTools ecosystem. It aims to provdide full python access to the main algorithms of LSDTopoTools while avoiding the neeeds of c++. It does not replace or provide numba portage of the full LSDTopoTools, just the main one for quick use or quick developments. The data structure is heavily based onxarray.License:Free software: MIT license## What-Why-How?Numbais a Just-in-time (JIT) compiler for python code, which means that it translates at runtime some pieces of code into assembly language using LLVM engine. It has the power to make somepythonfunctions as performant asCcode under few conditions. Although it does not allow as much flexibility and power asC++does, it is powerful enough for function with simple data-structure (numpy arrays). The huge advantage is that it fits in the interpreted python language and allow very quick development/debugging/distribution of code without the need of compiling for different platform and making bindings betweenpythonandC, making it an ideal tool for (i) testing algorithms before implementing them in heavier languages and (ii) develop alightversion of theLSDTopoToolsframework usable in full-python when the full stack ofLSDTopoToolsare not needed.## Features### Node graphSo far I mostly worked on the node graph object, which build on demand neighbouring info (Queen, King); single (Braun et al. 2013) and multiple (seefastscapelib-fortran](https://github.com/fastscape-lem/fastscapelib-fortran) ) flow topological order, and periodic/closed boundary conditions.## InstallationIf I start using this package more seriously, I will make aconda-forgepackage. Otherwise, clone this repository, and install the following dependencies:numba, numpy, matplotlib, pandasand it should do the trick. I recommend usingcondaas python environment manager.## Quick StartAs a quick start, I added a jupyter notebook in the notebook folder.## CreditsContact: Boris Gailleton (boris.gailleton@gfz-potsdam.de)Some of the core functions have been adapted fromxarray-topoby Benoit Bovy
This package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.0.1 (2020-09-07)First release on PyPI.
Package: lsdttparamselector
lsdttparamselectorA small package using ipython widgets that allows users to select parameters from menus. These can be passed to another object in lsdviztools to create a driver file for the lsdtopotools command line tools.Free software: MIT licenseDocumentation:https://lsdttparamselector.readthedocs.io.FeaturesTODOCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2020-07-13)First release on PyPI.
Package: lsdtt-xtensor-python
lsdtt_xtensor_python is a python binder for LSDTopoTools. It directly binds in-memory the c++ code in order to use it alongside with python.
Not all the routines are binded yet as I am still working on it. See lsdviztools for a full use of all the tools with command line/driver files/indirect python bindings.
Note that this is an intermediate package: lsdtopotools is the c++ package, lsdtt_xtensor_python offers low-level bindings to lsdtopotools and finally lsdtopytools offers the automated user-friendly scripting use.
Package: lsdyna-parser
The following code will return a dictionary containing all entities of the Ls-Dyna model. An entity consits of the Keyword and the corresponding cards as a list of parameter lines.fromlsdyna_parserimportparse_lsdyna_deckparsed_dyna=parse_lsdyna_deck(path='example_lsdyna_deck.k')The parser can be used as a starting point for model analysis and CAE process automation.
Package: lselect
lselect is a straightforward implementation ofCSS3 Selectorsforlxmldocuments. Unlikecssselect, it does not translate selectors toXPath.
It is currently slower but more correct than cssselect.Quick facts:Free software: BSD licensedCompatible with Python 2.6+ and 3.xLatest documentationon python.orgSource, issues and pull requestson GithubReleaseson PyPIInstall withpip install lselect
Package: lsf
# LSF
A simple abstraction built on top of existing LSF SWIG bindings.To run tests, first make sure you set the proper environment variables:`bash exportLSF_INCLUDEDIR=/usr/local/lsf/8.0/includeexportLSF_LIBDIR=/usr/local/lsf/8.0/linux2.6-glibc2.3-x86_64/lib`Then run tox:`bash pip install tox tox `
Package: lsfb-dataset
LSFB DatasetThis library is a companion for theFrench Belgian Sign Language dataset. You will find useful functions to load and manipulate the video from the LSFB dataset. Thuis library also provides scripts to download and sync the datasets.This dataset is available under theCreative Commons Attribution-NonCommercial-ShareAlike 4.0 International license.The code of this library is available under theMIT license.InstallationJust type :python -m pip install lsfb-datasetUseful linksThe code is available onGithubIf you find any issue, please report themhereThe full documentation of this library is availablehereCiteIf you use this library or the associated dataset for your research, please cite the following paper:@inproceedings{Fink2021,
  doi = {10.1109/ijcnn52387.2021.9534336},
  url = {https://doi.org/10.1109/ijcnn52387.2021.9534336},
  year = {2021},
  month = jul,
  publisher = {{IEEE}},
  author = {Jerome Fink and Benoit Frenay and Laurence Meurant and Anthony Cleve},
  title = {{LSFB}-{CONT} and {LSFB}-{ISOL}: Two New Datasets for Vision-Based Sign Language Recognition},
  booktitle = {2021 International Joint Conference on Neural Networks ({IJCNN})}
}
Package: lsfiles
Path object VC indexIndex versioned .py filesInstallpip install lsfilesDevelopmentpoetry installUsageTheLSFilesinstance is a list-like object instantiated with an empty index>>>fromlsfilesimportLSFiles>>>frompathlibimportPath>>>>>>files=LSFiles()>>>files<LSFiles[]>TheLSFilesindex callsgitls-filesand only versioned files are indexed>>>files.populate()>>>forpathinsorted([p.relative_to(Path.cwd())forpinfiles]):...print(path)docs/conf.pylsfiles/__init__.pylsfiles/_indexing.pylsfiles/_objects.pylsfiles/_version.pytests/__init__.pytests/_environ.pytests/_test.pytests/conftest.pywhitelist.pyTheLSFilesinstance is an index of unique file pathsIt’s implementation ofextendprevents duplicates>>>p1=Path.cwd()/"f1">>>p2=Path.cwd()/"f1">>>>>>files=LSFiles()>>>files.extend([p1,p2])>>>sorted([p.relative_to(Path.cwd())forpinfiles.reduce()])[PosixPath('f1')]Reduce minimizes index to directories and individual files relative to the current working dirThe list value is returned, leaving the instance unaltered>>>p1=Path.cwd()/"f1">>>>>>d=Path.cwd()/"dir">>>p2=d/"f2">>>p3=d/"f3">>>>>>files=LSFiles()>>>files.extend([p1,p2,p3])>>>sorted(p.relative_to(Path.cwd())forpinfiles.reduce())[PosixPath('dir'),PosixPath('f1')]Exclusions can be added on instantiationExclusions are evaluated by their basename, and does not have to be an absolute path>>>p1=Path.cwd()/"docs"/"conf.py">>>p2=Path.cwd()/"lsfiles"/"__init__.py">>>>>>files=LSFiles()>>>files.populate(f".*\/{p1.name}")>>>>>>ps=[str(p)forpinfiles]>>>>>>assertnotstr(p1)inps>>>assertstr(p2)inps
Package: lsf-lions-sectioned-format
lsfLSF (Lion's Sectioned Format) is a plain-text container format.It features:header & content sectionstitles for all sections (except the header)key-value pairs for all sections (optionally)body text for each section (optionally)LSF files are always UTF-8 encoded.Installingpip install lsf-lions-sectioned-formatAn example LSF Filetitle: My Blog
tags: blog

This is my blog.

== 2021-01-20 ==
tags: blogpost datepage github
date: 2021-01-20

Today I uploaded my lsf module to PyPI.

== 2021-01-18 ==
tags: blogpost datepage holiday
date: 2021-02-10

Today was Martin Luther King Day.This file has a header section, and two content sections (2021-01-20,2021-01-18).  All sections have keys and body text content.Example of UseHere's reading an LSF file:import lsf

L = lsf.loadfile("basic_blog.lsf")

for section in L:
    print(section[lsf.TITLE])
    print("  " + section[lsf.KEYS].get("tags"))
    print("  " + str(len(section[lsf.BODY])) + " characters in body")And adding a section:lsf.append(L, "A Title", {"date": "2021-01-19", "tags": "test"}, "This is a new entry.")And saving to the file:lsf.savefile(L, "basic_blog.lsf")Section DictionariesEach section has a dictionary of the form:{TITLE: "...a title...",
 TITLELN: 10,
 KEYS: {"key1": "value 1", "key2": "value 2", ...},
 BODY: "Central\nBody\nText\n",
 BODYLN: 16}...which corresponds to section:10. == ...a title... ==
11. key1: value 1
12. key2: value 2
    ...
15. 
16. Central
17. Body
18. Text(The line numbers are not part of the source; They are supplied only so that you can see how TITLELN and BODYLN function.)It's safe to manipulate data in place.
Package: lsfmpy
lsfmpy python libraryFunctionality:Writing:a series of tiffs, a  stack of images in a single tiff or a nifti file (with RAS orientation) can be compressed to hdf5channel name is requireda json file with metadata is requiredan xml file for big data viewer compatibility will be created (and recreated every time a new channel is added)user can specify how much memory should be used (for file reading, in GB) at oncedeafult 2 GBdoes not take into account memory for processing this amount of dataan affine from a file (itk compatible) can be written for a specified channelExporting:3D imagesreoriented from original orientation to RASresampled (down- or upsampled) to desired resolutionfrom desired level of internal pyramid of resolutionsworks for single compononet images, multicomponent images, segmentationaffine and displacement fields can be specified for transformation of image during export. the order, type and inversion of transforms must be given. many transforms can be chained (a composite transform will be created and executed)if channel segmentation (from registration) is present in the hdf file, it can be used to specify which region (anatomical structure) should be exported (a bounding box), this also can be transformed to a reference space during exporta subset of image volume, in the form of a cuboid, with origin specified in the output space (i.e. reference space if transformations are required) and of given physical size and resolution (in mm) can also be exportedif a grid (number of chunks in each direction in output space) and overlap are also given when exporting a subset of image volume, appropriate grid of chunks will be exported (doesn't work with transformations)if grid = 0,0,0 whole image volume will be exported as a grid of chunks (origin parameter is ignored)slicesslices along a given (0,1,2) axis can be exported from pre-resampled levels, with	given rangeif range is None, all slices will be exportedroi can be specified via ox,oy,sx,sy (origin and size) in pixel coordinatesExport functions can either write data to specified path name, or if output_path isNone, will return the data (or generator for multiple chunks/slices)viewing:hdf5 files can be viewed with BigDataViewer plugin for Fiji via accompanying xml fileinfo:informations about the data written to file (or for specified channel) can be printedmetadata:arbitrary metadata (as a key-value pair) can be added to fileprovenance:all operations on hdf5 file, along with command line, will be logged (unix systems)interactive:console commands with -- --interactive will return data in IPython notebookdump_metadata:some metadata can be recovered from some of the tiff/nifti files, and a json file will be created, it needs to be inspected, and missing values must be filled inh5_external:hdf5 files can be repacked, compressed or decompressed with this utility (repacking is useful for recovering space after deletion of large amounts of data that 	otherwise will not be freed)