Saravanan666/pypi-org huggingface dataset:
Package: lilcache
lilcacheInterprocess and thread safe light weight cacheNote:This is under development and has bad performance (concurrency, response time, error prone, etc. you name it!).
It is not ready for production use.  If you like taking risks, I won't stop you from using it.TimelineWrite unittestsStress testingImprove error handlingExtension to current implementation: Implement connection pool and client reuse connectionsImplementation 2: Twisted bsaed concurrencyImplementation 3: Incordinated cache (file db + locks for synchronization)For each implementation, perform benchmark tests and stress testingRelease to PyPiImplementation 4: Named PIPE based approach and full duplex communicationAdd more features (snapshot, Cache expiry, etc.)Production ready code
Package: lilcom
lilcomThis package lossily compresses floating-point NumPy arrays
into byte strings, with an accuracy specified by the user.
The main anticipated use is in machine learning applications, for
storing things like training data and models.This package requires Python 3 and is not compatible with Python 2.Installation with PyPiFrom PyPi you can install this with justpip3 install lilcomInstallation with condacondainstall-clilcomlilcomHow to useThe most common usage pattern will be as follows (showing Python code):import numpy as np
import lilcom

a = np.random.randn(300,500)
a_compressed = lilcom.compress(a)
# a_compressed is of type `bytes`, a byte string.
# In this case it will use about 1.3 bytes per element.

# decompress a
a_decompressed = lilcom.decompress(a_compressed)The compression is lossy soa_decompressedwill not be exactly the same
asa.  The amount of error (absolute, not relative!)  is determined by the
optionaltick_powerargument to lilcom.compress() (default: -8), which is the
power of 2 used for the step size between discretized values.  The maximum error
per element is 2**(tick_power-1), e.g.  for tick_power=-8, it is 1/512.Installation from GithubTo install lilcom from github, first clone the repository;git clone https://github.com/danpovey/lilcom.gitthen run setup withinstallargument.python3 setup.py install(you may need to add the--userflag if you don't have system privileges).
You need to make sure a C++ compiler is installed, e.g. g++ or clang.
To test it, you can then cd totestand run:python3 test_lilcom.pyTechnical detailsThe algorithm regresses each element on the previous element (for a 1-d array)
or, for general n-d arrays, it regresses on the previous elements along each of
the axes, i.e.  we regress elementa[i,j]ona[i-1,j]anda[i,j-1].  The
regression coefficients are global and written as part of the header in the
string.The elements are then integerized and the integers are compressed using
an algorithm that gives good compression when successive elements tend to
have about the same magnitude (the number of bits we're transmitting
varies dynamically acccording to the magnitudes of the elements).The core parts of the code are implemented in C++.
Package: lilendian
lil endianThis program is comptaible with both Python 2 and 3.It simply returns escaped shell code in Little Endian format for whatever memory address is submitted as the first argument.It's smart enough to distinguish between addresses with an0xprefix and accounts for that.If the address is only in the 64-bit range, you will only receive the 64-bit output.If the address can fit in the x86_64 ranges, you will receive both 32 and 64-bit output.Install for python3 via PyPI:pip3 install lilendianInstall for python2 via setup.py:python setup.py installRun in place:./lilendian [single memory address]Examples$ ./lilendian deadbeef
\xef\xbe\xad\xde
\xef\xbe\xad\xde\x00\x00\x00\x00

$ ./lilendian 0xdeadbeef
\xef\xbe\xad\xde
\xef\xbe\xad\xde\x00\x00\x00\x00

$ ./lilendian 0x00007fffffffd980
\x80\xd9\xff\xff\xff\x7f\x00\x00Shell script example snippet:Let's say you wanted to get a piece of 64-bit shellcode for0xdeadbeef + 0xbadcafe + 0xcafebabe + 0xabadbabe.foraddrin{0xdeadbeef,0xbadcafe,0xcafebabe,0xabadbabe};dolilendian$addr|tail-1done|tr-d"\n";echoOutput:\xef\xbe\xad\xde\x00\x00\x00\x00\xfe\xca\xad\x0b\x00\x00\x00\x00\xbe\xba\xfe\xca\x00\x00\x00\x00\xbe\xba\xad\xab\x00\x00\x00\x00Copy and paste that guy straight into your payload.Calling from withingdb:(gdb) ! lilendian 0xdeadbeef
\xef\xbe\xad\xde
\xef\xbe\xad\xde\x00\x00\x00\x00Future:I might tweak it in the future to take multiple memory addresses, but as of right now, it only outputs a single memory address.I have kept it short and simple to be easily scriptable, so I'll leave the rest up to you.
Package: lilfilter
filteringUtilities for resampling and filtering audio dataThis repository exports a Python packagelilfiltercontaining certain
utilities for filtering and resampling audio data.One quite-useful thing is class Resampler:python3
>>> import lilfilter
>>> # ... let a be a Torch tensor of size (num_channels, num_samples)
>>> # that we want to downsample from 42.1kHz to 16kHz.  Note,
>>> # the sampling rates must be integers; only their ratio
>>> # matters.
>>> r = lilfilter.Resampler(42100, 16000, dtype=torch.float32)
>>> b = r.resample(a)Another thing that's useful is class Multistreamer, which can turn a
signal into multiple parallel signals at a lower sampling rate, where
pairs of those signals represent the (real,complex) part of one
complex frequency band of the input.>>> import lilfilter
>>> num_freq_bands = 8
>>> m = lilfilter.Multistreamer(num_freq_bands)
>>>
>>> # ... let a be a Torch tensor of size (num_channels, num_samples)
>>> # that we want to `demultiplex`.
>>>
>>> b = m.split(a)
>>> # now b is of size (num_channels, 2, num_freq_bands, num_samples/num_freq_bands)
>>> # (note: the dim of the last axis may be slightly different from that number).
>>> # You can in principle manipulate b somehow, e.g. do some kind of machine
>>> # learning with it, and then reconstruct to the original format:
>>>
>>> c = m.merge(b)
>>> # now c is of size (num_channels, 8*(num_samples/8)) and will be extremely
>>> # close to a.
Package: lil-histie
# Lil histieThis repo contains an almost pointless python library to create histograms in the terminal fromgdalinfooutput.## OverviewWe all know and love the GDAL utility commandgdalinfo. Lil’ histe displays thegdalinfohistogram objects calculated for each band. To use, pipegdalinfooutput with the-jsonoption to lil_histie like so:`zsh gdalinfo-histinput.tif-json| lil_histie `And enjoy the little histograms printed in the terminal.
Package: lilies
LiliesLilies is currently in beta. Parts of the API are subject to change.Lilies is a cross-platform, CLI text formatting and coloring tool for python. It automatically adjusts support for any console, including old Windows support powered bycolorama. Lilies will attempt to reproduce the original colors as close as possible, regardless of the current terminal's capabilities.Lilies is supported on python 3.5, 3.6, 3.7, and 3.8.Getting startedInstall us viapip!pip install liliesTo test color support in your console:>>>importlilies>>>lilies.print_test()Here's what that looks like in true color terminals:And in 256 color terminals:AlternativesLibrary256 Color SupportTrue Color SupportWindows SupportPlatform-specific coloringlen() adjustmentsFormatting toolslilies✅✅✅✅✅✅colorful✅✅⚠️✅✅❌colored✅❌❌❌❌❌colorama❌❌✅❌❌❌termcolor❌❌❌❌❌❌⚠️: colorful has newer Windows 10 support, but no support for old versions.ContributingYou can find information about contributinghereLicenseMIT
Package: lilili
LiLiLi: List the Licenses of the LibrariesLiLiLi helps you to retrieve and audit software license information.InstallationLiLiLi is available on PyPI:$pipinstalllililiYou can also usepoetryto add it to a specific Python project.$poetryaddlililiExamplesSearch for and list the licenses of librariesPython libraries$piplist>pip-list.txt$lililisearch--yamlpip-list.txtExample ofresult.yml:-domain:pypiname:requestsversion:2.25.1licenses:-spdx_id:Apache-2.0basis:API_EXACTsource_url:https://pypi.org/pypi/requests/2.25.1/jsondownload_url:https://files.pythonhosted.org/packages/29/c1/24814557f1d22c56d50280771a17307e6bf87b70727d975fd6b2ce6b014a/requests-2.25.1-py2.py3-none-any.whlhomepage:https://requests.readthedocs.iogit_url:https://github.com/psf/requestsupdated_at:"2021-02-22T17:32:25.323561"-domain:pypiname:idnaversion:"2.10"licenses:-spdx_id:BSD-3-Clausebasis:API_LATESTsource_url:https://pypi.org/pypi/idna/json-spdx_id:BSD-3-Clausebasis:GITHUB_LICENSES_APIsource_url:https://api.github.com/repos/kjd/idna/licensedownload_url:https://files.pythonhosted.org/packages/a2/38/928ddce2273eaa564f6f50de919327bf3a00f091b5baba8dfa9460f3a8a8/idna-2.10-py2.py3-none-any.whlhomepage:https://github.com/kjd/idnagit_url:https://github.com/kjd/idnaupdated_at:"2021-02-22T17:32:24.035106"Ruby libraries$bundlelist>bundle-list.txt$lililisearch--yamlbundle-list.txtThe outputresult.ymlis in the same format as above.Node.js libraries$yarnlist>yarn-list.txt$lililisearch--yamlyarn-list.txtThe outputresult.ymlis in the same format as above.Why LiLiLi?LiLiLi usesthe SPDX license list, which is also used byGitHub Licenses API, so the license notation can be reused.If LiLiLi cannot determine the license for a particular version of the library, it will search for the latest version of the license or a license registered in the GitHub repository.LiLiLi will reveal the URL of the API on which the licensing decision is based, so you can double-check it yourself.
Package: lilio
lilio: Calendar generator for machine learning with timeseries dataA python package for generating calendars to resample timeseries into training and target data for machine learning. Named afterthe inventorof theGregorian Calendar.Lilio was originally designed for use ins2spy, a high-level python package integrating expert knowledge and artificial intelligence to boost (sub) seasonal forecasting.InstallationTo install the latest release of lilio, do:python3 -m pip install lilioLilio is also available on conda-forge. If you use conda, do:conda install -c conda-forge lilioTo install the in-development version from the GitHub repository, do:python3 -m pip install git+https://github.com/AI4S2S/lilio.gitConfigure the package for development and testingA more extensive developer guide can be foundhere.The testing framework used here ispytest. Before running the test, we get a local copy of the source code and installliliovia the command:gitclonehttps://github.com/AI4S2S/lilio.gitcdliliopython3-mpipinstall-e.[dev]Then, run tests:hatchruntestHow the lilio calendars workIn Lilio, calendars are 2-dimensional. Each row (year) represents a unique
observation, whereas each column corresponds to a precursor period with a
certain lag. This is how we like to structure our data for ML applications.We define the "anchor date" to be between the target and precursor periods
(strictly speaking, it is the start of the first target interval). All other
intervals are expressed as offsets to this anchor date. Conveniently, this
eliminates any ambiguity related to leap years.Here's a calendar generated with Lilio:>>>calendar=lilio.daily_calendar(anchor="11-30",length='180d')>>>calendar=calendar.map_years(2020,2021)>>>calendar.show()i_interval-11anchor_year2021[2021-06-03,2021-11-30)[2021-11-30,2022-05-29)2020[2020-06-03,2020-11-30)[2020-11-30,2021-05-29)Now, the user can load the datainput_data(e.g.pandasDataFrame) and resample it to the desired timescales configured in the calendar:>>>calendar=calendar.map_to_data(input_data)>>>bins=lilio.resample(calendar,input_data)>>>binsanchor_yeari_intervalintervalmean_datatarget02020-1[2020-06-03,2020-11-30)275.5True120201[2020-11-30,2021-05-29)95.5False22021-1[2021-06-03,2021-11-30)640.5True320211[2021-11-30,2022-05-29)460.5FalseFor convenience, Lilio offers a few shorthands for standard of calendars e.g.monthly_calendarandweekly_calendar.
However, you can also create custom calendars by callingCalendardirectly. For a nice walkthrough, seethis example
notebook.DocumentationFor detailed information on usingliliopackage, visit thedocumentation pagehosted at Readthedocs.ContributingIf you want to contribute to the development of lilio,
have a look at thecontribution guidelines.How to cite usPlease use the Zenodo DOI to cite this package if you used it in your research.AcknowledgementsThis package was developed by the Netherlands eScience Center and Vrije Universiteit Amsterdam under Netherlands eScience Center grant NLESC.OEC.2021.005.The package was created withCookiecutterand theNLeSC/python-template.
Package: lil-nocap
Easy Bulk export, no capThis repository provides scripts and notebooks that make it easy to export data in bulk from CourtListener's freely available downloads.Create first version of notebook suitable for Data ScientistsCreate the appropriatedtypesto optimize panda storageSelect necessary colsusecols, for example 'created_by' date field indicating a databaseinsertisn't necessaryRead theopinions.csv(190+gb) chunk at a time from disk while converting into JSONCreate a standalone script that can be piped to other toolsCreate PyPi library usingPoetry:packageOutput script usingjson linesformatImprove speed by usingDASK DataFrame
Package: lilt
The Lilt REST API enables programmatic access to the full-range of Lilt backend services including:   * Training of and translating with interactive, adaptive machine translation   * Large-scale translation memory   * The Lexicon (a large-scale termbase)   * Programmatic control of the Lilt CAT environment   * Translation memory synchronization  Requests and responses are in JSON format. The REST API only responds to HTTPS / SSL requests. ## Authentication Requests are authenticated via REST API key, which requires the Business plan.  Requests are authenticated using [HTTP Basic Auth](https://en.wikipedia.org/wiki/Basic_access_authentication). Add your REST API key as both the &#x60;username&#x60; and &#x60;password&#x60;.  For development, you may also pass the REST API key via the &#x60;key&#x60; query parameter. This is less secure than HTTP Basic Auth, and is not recommended for production use.   # noqa: E501
Package: lilt-python
The Lilt REST API enables programmatic access to the full-range of Lilt backend services including:   * Training of and translating with interactive, adaptive machine translation   * Large-scale translation memory   * The Lexicon (a large-scale termbase)   * Programmatic control of the Lilt CAT environment   * Translation memory synchronization  Requests and responses are in JSON format. The REST API only responds to HTTPS / SSL requests. ## Authentication Requests are authenticated via REST API key, which requires the Business plan.  Requests are authenticated using [HTTP Basic Auth](https://en.wikipedia.org/wiki/Basic_access_authentication). Add your REST API key as both the &#x60;username&#x60; and &#x60;password&#x60;.  For development, you may also pass the REST API key via the &#x60;key&#x60; query parameter. This is less secure than HTTP Basic Auth, and is not recommended for production use.   # noqa: E501
Package: lilvali
lilValiA small Python 3.12 validation experiment for playing withPEP 695.Supports most basic typing constructs including Generics.
Also supports dataclasses and classes with annotated__init__methods.InstallpipinstalllilvaliUsagefromlilvaliimportvalidate,validatorfromlilvali.errorsimport*Simple examples@validatedefadd[T:(int,float)](x:int,y:T)->int|float:returnx+ydefmain():print(f"{add(1,2)=}")print(f"{add(1,2.0)=}")try:print(f"{add(1.0,2)=}")exceptValidationErrorase:print(f"{e=}")else:raiseRuntimeError("Expected ValidationError")if__name__=="__main__":main()@validate@dataclassclassSomeClass:x:inty:str=field(default="hello")@validatordef_x(value):ifvalueisNoneorvalue<0:raiseValidationError@validatordef_y(value)->bool:returnvalue=="hello"@validateclassNotADC:def__init__(self,x:int,y:str):self.x=xself.y=y@validatordef_x(value):ifvalueisNoneorvalue<0:raiseValidationError@validatordef_y(value)->bool:returnvalue=="hello"See the demo folder as well.Tests$./test.sh
Runningtestswithcoverage
.........................
----------------------------------------------------------------------
Ran25testsin0.006s

OK
NameStmtsMissCoverMissing
------------------------------------------------------------
lilvali/__init__.py20100%
lilvali/binding.py1670100%
lilvali/errors.py60100%
lilvali/validate.py800100%
tests/test_tiny_validate.py1950100%
tests/test_validate_types.py1240100%
------------------------------------------------------------
TOTAL5740100%TODO
Package: lilyanncabinets
Current Version: 2.0.2Patch Notes:===========================================================================[2.0.2]: Fixed issue with returning data===========================================================================[2.0.1]: Added new module for scanning excel sheets with the command "search_excel_file(sheet_name, keyword, row_offset, column_offset, search_in_column, search_in_row).sheet_name: Name of the sheet within the file you would like to search throughkeyword: Keywords you would like to search for, format ["keyword1", "keyword2"]row_offset: Number of rows offset the target would you like to read fromcolumn_offset: Number of column offset the target would you like to read fromsearch_in_column: Defaults to "None" lets you pick a specific column to read from, ex. "A", "B", or "C"search_in_row: Defaults to "None" lets you pick a specific column to read from, ex. 1, 2, or 3===========================================================================[1.5.3]: Fixed patchnotes formating===========================================================================[1.5.2]: Fixed issue where writeToSheet() would just create a new sheet and delete the previous data===========================================================================[1.5.1]: Creating a new "build" added an auto spreadsheet creating and updating function for use with both robot and manual data tracking,added createNewSheet(): to create the sheet (names the sheet the current date)added writeToSheet(): Use to write data to the created sheet although running "createNewSheet()" is not required as the function will create one if a sheet under the current date cannot be located. Format for the function is writeToSheet(Row, Column, data)===========================================================================[0.5.2]: "Added equations for "limelight" functions"===========================================================================[0.5.1]: "Started Unstable build 0.5"===========================================================================reminder to py -m build
and py -m twine upload --repository pypi dist/*
Package: lilypond
LilyPond wheelsWhat's this?GNU LilyPondis a text-based music typesetter.Wheelsare the standard binary distribution format for Python packages.  This
repository contains a script that is being used to package LilyPond in wheel
format. The resulting wheels are uploaded on PyPI (see thelilypondproject page). The goal is to make
it easy to use LilyPond from Python code, installing LilyPond as if it were a
normal Python package — which allows to include it in your dependencies, pin it,
makes tools liketoxable to install it, and generally makes all the tooling
around standard Python packages just work.UsageIf you want to have the LilyPond wrapper package available in your Python
environment, you can install it usingpip install lilypondAs always, consider installing packages in avirtual
environmentinstead of globally.You can of course use it in all the other normal ways a package on PyPI can be
used:pyproject.tomlproject.dependencieslist, dependencies intox.ini,requirements.txtfiles, etc.pip install lilyponddoesNOTmakelilypondavailable as a command —
this is normal! This wrapper is specifically intended for using LilyPond from
Python code, not for installing LilyPond in general. In order to use the bundled
LilyPond, you should do:import subprocess

import lilypond

subprocess.run([lilypond.executable(), "file.ly"])That is, import thelilypondmodule, and use theexecutable()function to
get the full path to the bundledlilypondexecutable, as apathlib.Pathobject, then use thesubprocessmodule to execute it.Scripts shipped with LilyPond are also available; use the optional argument toexecutable(), e.g.,executable("convert-ly"), to access them.MaintenanceWhen a new LilyPond release is out, runhatch run build <version> 0This leaves wheels of LilyPond<version>inbuild/. If they look good (use a
venv to check), upload them withpython -m twine upload build/*.whlThe0in thehatchcommand is the build number. In case something goes wrong
in published wheels, fixed wheels should be uploaded with a build number of1(then2, etc.).For type checking:hatch run mypy:check
Package: lilyponddist
This package wraps the binary distribution of lilypond, allowing to install and use lilypond from pythonNotice that this package installs lilypond from the releases provided by the lilypond team. It does not
conflict with any user-installed lilypond version, since it places lilypond at an ad-hoc place, without
modifying the PATH or any other part of the environment.At the moment the platforms supported are linux x86_64, windows x86_64 and macos x86_64. For macos
arm64 the only way to install a native version is via homebrew.At first runlilyponddistwill download the corresponding distribution. Whenever lilypond releases
a new binary this package will be updated with the new URLs. After the package itself is updated
the lilypond version can be updated by calling theupdatefunctionInstallationpipinstall--updatelilyponddistExampleimportlilyponddistimportsubprocesssubprocess.call([lilyponddist.lilypondbin(),'/path/to/score.ly','--pdf','-o','/path/to/output'])# Update if possiblelilyponddist.update()# It can be checked if an update is availablelilyponddist.needs_update()# will return True if there is an update available# The current version can be checked via ``lilypond_version``. This returns the version of the# lilypond distribution installed via ``lilyponddist``. There is never an attempt to interact with# a user installed lilypondlilyponddist.lilypond_version()
Package: lily-unit-test
This package aims to be a full alternative to the Python’s build in unittest package.
This package has the following features:Test suite class with various build-in functions.Test runner that scans all Python files in your project for test suites and executes them.Single page HTML report:test report latest release.Text log file of every test suit that was executed.The package is available onPyPi.InstallationInstall the package from PyPi:pip install lily-unit-testUsageThe following example shows a basic test suite for your python code:# Import the packageimportlily_unit_test# Some functions that needs testingdefadd_one(x):returnx+1defadd_two(x):returnx+2# Simply make a sub class of the lily unit test test suiteclassMyTestSuite(lily_unit_test.TestSuite):deftest_add_one(self):assertadd_one(3)==4,"Wrong return value"deftest_add_two(self):assertadd_two(3)==5,"Wrong return value"if__name__=="__main__":# Run the test suiteMyTestSuite().run()Run the Python file, the output should look like this:2023-12-20 19:28:46.105 | INFO   | Run test suite: MyTestSuite
2023-12-20 19:28:46.105 | INFO   | Run test case: MyTestSuite.test_add_one
2023-12-20 19:28:46.106 | INFO   | Test case MyTestSuite.test_add_one: PASSED
2023-12-20 19:28:46.106 | INFO   | Run test case: MyTestSuite.test_add_two
2023-12-20 19:28:46.106 | INFO   | Test case MyTestSuite.test_add_two: PASSED
2023-12-20 19:28:46.106 | INFO   | Test suite MyTestSuite: 2 of 2 test cases passed (100.0%)
2023-12-20 19:28:46.106 | INFO   | Test suite MyTestSuite: PASSEDRun the test runner to run all test suites in a folder:fromlily_unit_testimportTestRunnerTestRunner.run("path/to/test_suites")The test runner scans the folder recursively for Python files containing a test suite class.More detailed information can be found in thedocumentation on Read the Docs.The source code is available onGitHub.Created and owned byLilyTronics