Saravanan666/pypi-org huggingface dataset:
Package: libsg
scene-builderLocal testing:pipinstall--upgradebuild
python-mbuild
pipinstall-e.Running Scene Builder Flask AppFetch stk/scenestate data and place under yourFLASK_BASEDIR.FLASK_BASEDIR=~/path/to/dataflask--applibsg.app--debugruncurllocalhost:5000/scene/retrieve/curl-XPOST-H'Content-Type:application/json'-d@object_add_category_position.jsonhttp://127.0.0.1:5000/object/add-oobject_add_category_position_output.jsoncurl-XPOST-H'Content-Type:application/json'-d@object_remove_category.jsonhttp://127.0.0.1:5000/object/remove-oobject_remove_category_output.jsonPackagingBelow packaging follows guidelines athttps://packaging.python.org/en/latest/tutorials/packaging-projects/Generate tokens on pypi and store in.pypircfile as below:[testpypi]username=__token__password=pypi-XXX[pypi]username=__token__password=pypi-XXXNOTE: uploads with a specific version are only allowed once.
Thus, be careful about currentversiontag inpyproject.tomlfile.Deploying test package:pipinstall--upgradebuildtwine
python-mbuild
python-mtwineupload--repositorytestpypidist/*
python-mpipinstall--index-urlhttps://test.pypi.org/simple/--no-depslibsgDeploying package to real pypi index is same as above except for much simpler upload and install commands:python-mtwineuploaddist/*
pipinstalllibsg
Package: libSGM
libSGMSemi-Global Matching algorithm.Overview•Install•Usage•Related•ReferencesOverviewC++ implementation of Semi-Global Matching (SGM) algorithm that is wrapped with cython to provide alibsgmpython module based on[Hirschmuller, 2008],[Ernst, Ines & Hirschmüller, 2008]and[Hirschmüller, Buder & Ernst, 2012].Installlibsgmis available on Pypi and can be installed by:pipinstallnumpy
pipinstalllibsgmUsagelibSGM must be used as a package :fromlibSGMimportsgm_wrapper...cost_volumes_out=sgm_wrapper.sgm_api(cost_volume_in,p1,p2,directions,invalid_value,False,False)Let's seepandora_plugin_LibSGMfor real life exemple.RelatedPandora- A stereo matching frameworkPlugin_LibSGM- Stereo Matching Algorithm plugin for PandoraReferencesPlease cite the following paper when using libsgm:Cournet, M., Sarrazin, E., Dumas, L., Michel, J., Guinet, J., Youssefi, D., Defonte, V., Fardet, Q., 2020. Ground-truth generation and disparity estimation for optical satellite imagery. ISPRS - International Archives of the Photogrammetry, Remote Sensing and Spatial Information Sciences.[Hirschmuller, 2008]H. Hirschmuller, "Stereo Processing by Semiglobal Matching and Mutual Information," in IEEE Transactions on Pattern Analysis and Machine Intelligence, vol. 30, no. 2, pp. 328-341, Feb. 2008. doi: 10.1109/TPAMI.2007.1166[Ernst, Ines & Hirschmüller, 2008]Ernst, Ines & Hirschmüller, Heiko. (2008). Mutual Information Based Semi-Global Stereo Matching on the GPU. Proceedings of the International Symposium on Visual Computing. 5358. 10.1007/978-3-540-89639-5_22.[Hirschmüller, Buder & Ernst, 2012]Hirschmüller, Heiko & Buder, Maximilian & Ernst, Ines. (2012). Memory Efficient Semi-Global Matching. ISPRS Annals of Photogrammetry, Remote Sensing and Spatial Information Sciences. I-3. 10.5194/isprsannals-I-3-371-2012.
Package: libshipkore
libshipkoreShipkore tracking library & CLI to track packages across couriers.
This is first Open source product of Innerkore Technologies. We are commited to do things differently.InstallationpipinstalllibshipkoreUsageAs CLIlibshipkoreprovidersTo get all the supported Couriers.libshipkoretrackTo track a package in supported Couriers. It will ask for 2 thingsProvider (Couries)Waybill (Tracking number)As LibraryComing SoonFeaturesTracking through CLIEmbeddable as libraryGive standard responseConvert Courier’s statuses to standard statusesConvert date & time to timezone specific ISO FormatSample ResponseComing SoonSupported StatusesInfoReceivedInTransitOutForDeliveryAttemptFailDeliveredAvailableForPickupExceptionReverseDeliveredReverseOutForDeliveryReverseInTransitSupported CouriersDelhiveryEkartCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2020-12-20)First release on PyPI.
Package: libsixel-python
What is this?This module is a python wrapper of libsixel.libsixel:https://github.com/saitoha/libsixelInstallExample 1. Install into the python prefixed with ‘/usr/local’$ git clone https://github.com/saitoha/libsixel.git
$ cd libsixel
$ ./configure --enable-python --prefix=/usr/local
$ make installExample 2. Install into only current active python$ git clone https://github.com/saitoha/libsixel.git
$ cd libsixel
$ ./configure --disable-python
$ make install  # install libsixel
$ cd python
$ python setup.py install  # install python moduleCode Exampleencoderfrom libsixel.encoder import Encoder, SIXEL_OPTFLAG_WIDTH, SIXEL_OPTFLAG_COLORS

encoder = Encoder()
encoder.setopt(SIXEL_OPTFLAG_WIDTH, "300")
encoder.setopt(SIXEL_OPTFLAG_COLORS, "16")
encoder.encode("test.png")decoderfrom libsixel.decoder import Decoder, SIXEL_OPTFLAG_INPUT, SIXEL_OPTFLAG_OUTPUT

decoder = Decoder()
decoder.setopt(SIXEL_OPTFLAG_INPUT, "test.six")
decoder.setopt(SIXEL_OPTFLAG_OUTPUT, "test.png")
decoder.decode()LicenseThe MIT lisenceCopyright (c) 2014,2015 Hayaki Saito

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.
Package: libskaro
Skaro is an open standard for instant messaging.More about
skaro.libskaro - a library that simplifies working with skaro protocol.DocumentationSee the documentation forinstallation and usage instructions.Third-party softwarelibskaro includes the following third-party software:Simple event observer system (libskaro/event.py) by Tom Dryer is
licensed under the MIT License:https://github.com/tdryer/hangups/
Package: libslack
StatusTicketsOverviewlibslack is a lightweight python wrapper around theSlack-Web-Api.
As part of libslack a small tool called scmd.py which provides a command line interface for the slack api.LinksProject on GithubDocumentationRequirementsPython 3.4 and newerDependenciesdocoptInstallationFrom PyPipip install libslackFrom Githubpip install git+https://github.com/Nicoretti/libslack.gitFrom Sourcepython3 setup.py install
Package: libsnew
### Step class ###
The Step class consists of common functions that can be inherited by other classes : setTaskID, setUUID, setTaskExecutionID ,startRedisConn ,setLogger ,loadParams ,connectToAPIForKey , create and GetResponseFromURL, getLogger, exceptionTraceback, getRelativeFile.### Extract class###
The extract class includes an init method that sets all Parameters and log files, as well as a superclass startup that can be defined from the client extract.### ML class ###
The ML class is made up of an init method that sets all parameters and the log file, as well as a startMLSubscriber method that subscribes to incoming data.### Transform class ###
The Transform class has an init method that sets all Parameters and the log file. a startTRSubscriber method that subscribes to incoming data.### Load Class ###
Load class consists of an init method that sets all parameters and the log file, load subscribers to subscribe to incoming data from Redis queue, and client logic; to load final data, it needs to be added to the client load file;### Connectors Added ###
AzBlob Read (Azure Blob)Â
Using this connector, you can read files from AzBlob.
For an Azure Blob Read connection ,create a source folder inside params, and add spec.json with connection configs.AzBlob Write (Azure Blob)
Using this connector, you can write a file to an AzBlob.
For an Azure Blob Write connection, create a destination folder inside params, and add spec.json with connection configs.SFTP ReadÂ
This connector is used to read files from an SFTP server.
For an SFTP connection, create a source folder inside params and add spec.json with connection configs.SFTP WriteÂ
Using this connector, you can read files to an SFTP server for an SFTP write connection,
Create a destination folder inside params and add spec.json with connection configs.Postgres ReadÂ
This is the Source connector for PostgreSQL databases using SQLAlchemy,
It includes the check() method, which validates the connection to the Postgres database.
The read() method takes an optional query parameter and executes the query on the connected database. discover(): This discover() function is used to discover the tables in the database.Postgres WriteÂ
Using this connector, you can read files into a Postgres database, consisting of check(),
read() In addition to this, it contains the create_table() function that is used to create a new table in the database.
It compiles the table object provided into a SQL; the alter_table() function is used to alter a table in the database, and the write() function is used to write data to the database.
It takes in the table object and a list of dictionaries.IPFS sourceÂ
You can use this connector to read file from any IPFS http url.
This connector includes a check() function for validating the connection and a read() function for returning data in bytes format.IPFS destinationÂ
This connector helps you upload any file to a custom IPFS node.
The write() function in this connector uses file and target location as input and will return JSON consisting of contentId, name, and size of the file.License-File: LICENSE.txt
Package: libsniffpy
libsniffpyMotivationI wanted to have a nice cython/python wrapper aroundlibsniff.
This name might confuse you, I just care about sniffing wifi packets from a nic in monitor mode.Installationpip install libsniffpyUsageSimple: Low level usagefromsniffimportget_socket# You might have to adjusts=get_socket("wlan0mon")# or whatever big number, forgot how big those frames are lelraw=s.recv(3000)Advanced: Iterate over the Radiotap framesfromsniffimportget_socket,type_predicate,subtype_predicate,loopfromsysimportstderrfromdpktimportieee80211fromdpkt.radiotapimportRadiotapif__name__=="__main__":mgmt_predicate=type_predicate(ieee80211.MGMT_TYPE)probe_request_predicate=subtype_predicate(ieee80211.M_PROBE_REQ)mgmt_packets=filter(mgmt_predicate,loop("wlan0mon"))probe_requests=filter(probe_request_predicate,mgmt_packets)forpkginprobe_requests:print(pkg)Guidance for n00bsThis lib opens a raw socket for a monitor mode enabled interface.
It needs privs that your user probably don't have.Either you run this stuff asrootor you do sth like this:sudo setcap cap_net_raw,cap_net_admin=eipon a wrapper script that calls your python interpreter.LicenseThis project is licensed under the GPL-3 license.
Package: libsnmp
libsnmpA pure Python implementation of the Simple Network Management Protocol as a Python library.OverviewI wrote this library many years ago because I was frustrated by PySNMP and something else that
I can't recall, but that used an overly theoretical CompSci-type implementation of ASN.1 entities mapped
directed to a deep class hierarchy, which made it really slow.The PySNMP project has now utterly eclipsed the functionality of libsnmp, so you probably want to use it instead.The code is here mostly for historical reference, and so people who keep downloading it from PyPI for some
unknown reasons can fork and update the code if they so wish.Installationlibsnmp is available in PyPI, so you can just use:pip install libsnmpif you want. Or use:python setup.py installThere are a bunch of example scripts in the main directory.
Package: libsnr
# libsnrLibsnr is the underlying core library for snr-generated payloads and interface. Please see [snr-meta](https://github.com/GlobularOne/snr-meta) for more information.## Contacting the authorYou can always send an email to me. I am available asGlobularOne@proton.me## LicenseApache Software License 2.0. See the [LICENSE](https://github.com/GlobularOne/libsnr/blob/main/LICENSE) file for more information.
Package: libsocket
LibsocketPrincipleThe idea behind this library is to facilitate the communication between python clients and servers. It will automatically make the connection, and has the ability to send and receive messages and files. The connection can optionally be encrypted using XOR cypher. The XOR key is exchanged securely with an RSA keypair provided by the server. The encryption protocol is inspired by the SSH protocol, and described below.EncryptionClientThe client will send a special request to the server to ask for its public key for asymmetric encryption. The client will wait for the response from the server, and store the key sent in response by the server.The client will then generate a random symmetric encryption key (a XOR key seems simple and efficient to me). It will encrypt the generated symmetric key with the previously received server's public key, and send the encrypted key to the server.The server will then store the symmetric encryption key, and use it to decrypt and encrypt the messages during the communication process.The client will have the ability to encrypt and decrypt the messages using the XOR key previously generated. The client can choose if it wants to encrypt the messages, however, once the key has been sent to the server, all the messages sent by the server to the client will be encrypted.ServerThe server will wait for a connection request. When a client will ask him for his previously generated public key, he will send it to the client, and wait for the sending of the symmetric key.When it receives the symmetric key, it will save it and use it to encrypt all messages sent to the client. If a recived message is encrypted, it will be decrypted with this same key.
Package: libsoc_zero
This is repository containing useful Python code examples of how to
interact with theLinker mezzanine card starter kit for 96Boards.Created byBarry Byfordwith hopefully other contributors.DocumentationThis documentation is availablehttp://pythonhosted.org/libsoc_zero/If there are issues with the documentation then get involved and help make it better athttps://github.com/DBOpenSource/linker_starter_kit/DevelopmentThis project is being developed onGitHubso join in:Provide suggestions, report bugs and ask questions asissuesProvide examples we can useContribute to the codeContributorsBarry Byford(project maintainer)
Package: libspg
Python library for interacting with Brazil NPAC SPGOnly BDO functions are implemented for nowThe XML schema (Brazil LNP Schema vX.Y.xsd) must be copied to the package
directory with the file name “schema.xsd”Licensing:Licensed under ISC license:Copyright (c) 2013 Andre Sencioles Vitorio Oliveira <andre@bcp.net.br>Permission to use, copy, modify, and distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.THE SOFTWARE IS PROVIDED “AS IS” AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
Package: libsps
libSps is a versatile C++ library designed for efficiently analyzing n-dimensional data. Specifically, it implements constant-time hyperrectangle count queries using a sparse prefix sum index. libSps is available as a header-only library for C++ as well as a Python 3 module.The library is ideal for processing interactome data (https://en.wikipedia.org/wiki/Chromosome_conformation_capture), and is therefore used in Smoother (https://github.com/Siegel-Lab/BioSmoother).libSps’s documentation is available athttps://libsps.readthedocs.io/.
Package: libsql-client
Python SDK for libSQLAPI reference|Github|PyPIThis is the source repository of the Python SDK for libSQL. You can either connect to a local SQLite database or to a remote libSQL server (sqld).Installationpip install libsql-clientGetting StartedConnecting to a local SQLite database:importasyncioimportlibsql_clientasyncdefmain():url="file:local.db"asyncwithlibsql_client.create_client(url)asclient:result_set=awaitclient.execute("SELECT * from users")print(len(result_set.rows),"rows")forrowinresult_set.rows:print(row)asyncio.run(main())To connect to a remote libSQL server (sqld), just change the URL:url="ws://localhost:8080"Supported URLsThe client can connect to the database using different methods depending on the scheme (protocol) of the passed URL:file:connects to a local SQLite database (using the builtinsqlite3package)file:/absolute/pathorfile:///absolute/pathis an absolute path on local filesystemfile:relative/pathis a relative path on local filesystem(file://pathis not a valid URL)ws:orwss:connect to sqld using WebSockets (the Hrana protocol).http:orhttps:connect to sqld using HTTP. Thetransaction()API is not available in this case.libsql:is equivalent towss:.Synchronous APIThis package also provides a synchronous version of the client, which can be created by callingcreate_client_sync(). It supports the same methods as the defaultasyncioclient, except that they block the calling thread:importlibsql_clienturl="file:local.db"withlibsql_client.create_client_sync(url)asclient:result_set=client.execute("SELECT * from users")print(len(result_set.rows),"rows")forrowinresult_set.rows:print(row)The synchronous client is just a thin wrapper around the asynchronous client, but it runs the event loop in a background thread.Contributing to this packageFirst, please install Python andPoetry. To install all dependencies for local development to a
virtual environment, run:poetry install --with devTo run the tests, use:poetry run pytestTo check types with MyPy, use:poetry run mypyLicenseThis project is licensed under the MIT license.ContributionUnless you explicitly state otherwise, any contribution intentionally submitted for inclusion inlibsql-clientby you, shall be licensed as MIT, without any additional terms or conditions.
Package: libsql-experimental
libSQL API for PythonlibSQL is an open source, open contribution fork of SQLite. We aim to evolve it to suit many more use cases than SQLite was originally designed for.This source repository contains libSQL API bindings for Python, which aim to be compatible with thesqlite3module.InstallYou can install the current release(MacOS and Linux):$ pip install libsql-experimentalDocumentationAPI referenceGetting StartedTo try out your first libsql program, start the Python interpreter:$pythonand then:>>>importlibsql_experimentalaslibsql>>>con=libsql.connect("hello.db")>>>cur=con.cursor()>>>cur.execute("CREATE TABLE users (id INTEGER, email TEXT);")<builtins.Resultobjectat0x102dcf8d0>>>>cur.execute("INSERT INTO users VALUES (1, 'alice@example.org')")<builtins.Resultobjectat0x102dcf4b0>>>>cur.execute("SELECT * FROM users").fetchone()(1,'alice@example.org')Connecting to a databaseimportlibsql_experimentalaslibsqlcon=libsql.connect("hello.db")cur=con.cursor()Remote databaseimportlibsql_experimentalaslibsqlurl=os.getenv("LIBSQL_URL")auth_token=os.getenv("LIBSQL_AUTH_TOKEN")con=libsql.connect(database=url,auth_token=auth_token)cur=con.cursor()Embedded replicaimportlibsql_experimentalaslibsqlurl=os.getenv("LIBSQL_URL")auth_token=os.getenv("LIBSQL_AUTH_TOKEN")con=libsql.connect("hello.db",sync_url=url,auth_token=auth_token)con.sync()Creating a tablecur.execute("CREATE TABLE users (id INTEGER, email TEXT);")Inserting rows into a tablecur.execute("INSERT INTO users VALUES (1, 'alice@example.org')")Querying rows from a tableprint(cur.execute("SELECT * FROM users").fetchone())DevelopingSetup the development environment:python3-mvenv.envsource.env/bin/activate
pip3installmaturinpyperfpytestOr you can use NIX to drop you into a shell with everything installednix-shellBuild the development version and use it:maturin develop && python3 example.pyRun the tests:pytestRun the libSQL benchmarks:python3perf-libsql.pyRun the SQLite benchmarks for comparison:python3perf-sqlite3.pyLicenseThis project is licensed under theMIT license.ContributionUnless you explicitly state otherwise, any contribution intentionally submitted
for inclusion in libSQL by you, shall be licensed as MIT, without any additional
terms or conditions.
Package: libsrg
Namelibsrg -- count calls to python logging at each logging severity levelDescriptionlibsrg provides the following classes:libsrg.LoggingCounterextends logging.Handler with count of logs at each severity levelcounts on output, so logs suppressed by current logging level do not get countedatexit hook used to print statistics on program exitlibsrg.LoggingAppBaseapplication base class with LoggingCounter installedargparse.ArgumentParser--verbose sets logging level to DEBUG--logfile  directs logging to a fileDerived classes can add application specific options to ArgumentParserlibsrg.Runnerrun command line in a subprocesscapture stdout, stderrtry catch block for exceptionsexceptions can optionally be raised back to calling programI write a lot of smallish command line utilities for internal use, and factored out some common
repetitive boilerplate code into this package. Published for my own installation convenience,
but might be useful to others as well.Example outputLibrary uses atexit hook to summarize logging activity counts and total execution time.
Counts are also available to the program at runtime.2022-02-22 12:46:22,568 INFO     (libsrg.LoggingCounter:61) __log_atexit 
Logging Summary:
Logging at Level INFO       occurred         13 times
Logging at Level DEBUG      occurred          1 times
Logging at Level WARNING    occurred          1 times
Logging at Level ERROR      occurred          2 times
Logging at Level CRITICAL   occurred          1 times
Elapsed time was 0.087 secondsInternal notes on updating/GNAS/PROJ/PycharmProjects/libsrg/publish.bash#! /bin/bash

cd /GNAS/PROJ/PycharmProjects/libsrg
rm -rf dist
python3 -m build --wheel
python3 -m twine check dist/*
python3 -m twine upload dist/*Installation from pypi via pippip3 install libsrgpip3 install libsrg --updateInstallation from Gitlab or local repositorypip3 install git+ssh://git@gitlab.com/SRG_gitlab/libsrg.gitpip3 install /GNAS/PROJ/PycharmProjects/libsrgTestingPytest performs its own logging setup before calling any user supplied tests, so it
doesn't work well testing these classes logging setup. Ad-hoc test code is supplied
at the end of the classes and executes if the class is loaded asmain.RoadmapMy intention is to keep this library small. It is not expected to evolve into an all-purpose framework.
Output is geared towards developers, not end users.LicenseMITProject statusCore functionality appears solid, but naming and packaging may be fluid for a while.This is my first attempt at publishing to pypi, so there may be surprises.I will bump version to 1.x when out of beta.
Package: libss
libssIndependent-component-analysis-based blind audio source separation library.Installationpip install libssAvailable algorithmsAuxiliary-function-based independent vector analysis (AuxIVA)Coming soon...Online AuxIVAIndependent low-rank matrix analysis (ILRMA)Fast multichannel nonnegative matrix factorization (FastMNMF)ExampleAuxIVA