Saravanan666/pypi-org huggingface dataset:
Package: blm
Backlash Model with Linear Decision Boundaries (blm)A simple model to describe the backlash effect in physics simulations based on numpyThe model implemented in this package was published as:J. Vörös, "Modeling and identification of systems with backlash", Automatica, 2008,link to pdfSupportIf you use code or ideas from this repository for your projects or research,please cite it.@misc{Muratore_blm,
  author = {Fabio Muratore},
  title = {blm - A simple model to describe the backlash effect in physics simulations},
  year = {2021},
  publisher = {GitHub},
  journal = {GitHub repository},
  howpublished = {\url{https://github.com/famura/blm}}
}InstallationTo install the core part of the package runpip install blmFor (local) development install the dependencies withpip install -e .[dev]Getting StartedPlay around with the model's parameters in thedemo.pyscirptcd examples
python demo.py
Package: bln
Python client for the biglocalnews.org APILinksDocumentation:bln-python-client.readthedocs.ioRepository:github.com/biglocalnews/bln-python-clientPackaging:pypi.org/project/blnAboutThe project is sponsored byBig Local News, a program at Stanford University that collects data for impactful journalism. The code is maintained by Stanford LecturerSerdar TumgorenandBen Welsh, a visiting data journalist from the Los Angeles Times.
Package: bln-converter
BLN-ConverterWhat is it?A simple CLI utiliy tool for converting BLN files (a extension used on GIS software like Surfer) toESRI shapeorGeoJSON files.Where to get itThe source code is currently hosted on GitHub at:https://github.com/ericmiguel/bln-converterBinary installers for the latest released version are available at thePython Package Index (PyPI).pipinstallbln-converterHow to use itBLN converter offers a very simple CLI. Although under development, it is already functional.Convert BLN to ESRI shape:bln-converterbln2shp-p{bln_folder}-crs{CRS}or use bln2geojson command to get a GeoJSON output.bln-converterbln2geojson-p{bln_folder}-crs{CRS}BLN converter will find and process all BLN files in a given folder. The resultant files will be output to the origin folder.Other commands or instructions can be found using the help commandbln-converter--helpDependenciesGeopandasClickLicenseMIT LicenseContributingAlthough BLN Converter is a simple and dirty utility script, all contributions are welcome.
Package: blns-recovery
Minimalistic python tool to recover blns paper backup.Paper backup consists of two parts: - part 1 is sent together with the
card, starts withblns1keyword - part 2 is produced after signup
flow on the phone, starts withblns2keywordRecovery tool returns root seed and itsBIP-39mnemonic representation.For more information on Bitcoin keys generation please refer toBitcoin
bookorlearnmeabitcoin.com on extended
keys.For a web browser-based recovery tool, visit therecovery
tool, sources onhttps://github.com/blns-ltd/blns-recovery.Pip installationBoolTest is available viapip:pip3 install blns-recoveryIf the package is uploaded on Pypi. If it is not the case, use local pip
installation below.Local installationFrom the local dir:pip3 install --upgrade --find-links=. .UsageEnter part1 and part2 as command line arguments. The tool computes your
master seed and outputs it as a hex-coded string. Use it to recover your
funds to a newly created wallet. After the recovery, do not use
recovered seed anymore.$> blns-recovery --part1 'blns1 road there connect clap divert nothing hunt angle slush lesson glide lunar vocal scrub bubble clean unique hammer charge wreck satoshi glare surge urge memory gather' \
  --part2 'blns2 quit exchange miracle winter cupboard solve wing zero this leader auction result firm manage they total mimic stadium host borrow spray list canyon brick refuse april'

Recovered master seed: c166420301445f404a92acf30b39370aa0ed39991a5b27b7116ef7546bcc9936
BIP-39 mnemonic: scrap craft liar action echo parent clean few vessel flush evidence best attract orphan good enter chicken review forum upgrade effort town gospel shellUsage:usage: blns-recovery [-h] [--part1 PART1] [--part2 PART2]
                     [--part1-hex PART1_HEX] [--part2-hex PART2_HEX]
                     [--bip-language BIP_LANGUAGE] [--show-btc-secret]

BLNS paper backup recovery

optional arguments:
  -h, --help            show this help message and exit
  --part1 PART1         Part 1 of the paper backup
  --part2 PART2         Part 2 of the paper backup
  --part1-hex PART1_HEX
                        Part 1 of the paper backup in the hexadecimal form
  --part2-hex PART2_HEX
                        Part 2 of the paper backup in the hexadecimal form
  --bip-language BIP_LANGUAGE
                        BIP39 mnemonic language to use
  --show-btc-secret     Show BTC master private keysKey derivation schemeInputs: - paper backuppart1- paper backuppart2seed = HMAC-SHA512(key=0xFE42EF, msg=part1 || part2)Theseedis a root seed that can be used to recover your wallets.
Package: blo
Blo(blog + bro) - yet another static site generator for personal
blogs. The aim is to make a really easy tool for creating new notes and
customizing your site. Do less actions and have much opportunity to make
a unique site.FeaturesComfortable cli control.Easy config edit in JSON files.Drafts templates: default content for new notes, useful for planning
new posts.Page templates: easy HTML/Jinja2 customize and improve.SEO friendly (as I could make it).Microformats for better snippets in Google/Bing/etc.Markdown with use of meta-tags to customize pages more with different
data.Code highlight with Pygments.RSS feed generationPaginationInstallationpip install bloOr download repo and execute:python setup.py installUsageCreate a new blog:blo create myblog
cd myblogCreate a new page or post:blo post hello-worldYou can also use pipe with your favorite editor:blo post hello-world | xargs sublBuild blog:blo buildRun blog locally:blo serveConfigureGlobal site variables and technical paths are indefault.json.Templates for diffirent types of content are indraft_templates.jsonCustomizeAdding a custom type of contentYou can add you page HTML templates for diffirent types of content.Add new HTML template totemplatesfolder with a name of post
type (ex.book.html)Add new draft template todraft_templates.json, you can also set
an URL template and default content for new type of pageNow you can make new type of posts:blo postjust-for-fun--typebook
Package: bloark
Blocks Architecture (BloArk)Blocks Architecture (BloArk) is a powerful Python package designed to process the extensive edit history of Wikipedia pages into easily manageable and memory-friendly blocks. The package is specifically developed to enable efficient parallelization and composition of these blocks to facilitate faster processing and analysis of large Wikipedia datasets. The original design of this package is to build other Wikipedia-oriented datasets on top of it.The package works by dividing the Wikipedia edit history into temporal blocks, which are essentially subsets of the complete dataset that are based on time intervals. These blocks can then be easily processed and analyzed without the need to load the entire dataset into memory.InstallationThe package is available on PyPI and can be installed using pip:pipinstallbloarkBenefitsEfficient: The package is designed to be memory-friendly and can be easily parallelized to process large datasets.Fast: The package is designed to be fast and can be easily optimized to process large datasets.Flexible: The package is designed to be flexible and can be easily extended to support other types of blocks.Composable: The package is designed to be composable and can be easily combined with other packages to build other datasets.SpecificationDefault compression method: ZStandard.
Package: bloatier
Bloatier - A String Bloater/Debloater AlgorithmDescription: My customformatalgorithmwithloosyRAM allocation
andterriblyhugetime and space complexity thatbloatsanddebloatsstring and string-like types.SampleUsing bloat/debloat for basic stage format:# Importing the packagefrombloatierimportbloatierstring_="This is a string"# Our string to be bloatedbloated_string=bloatier.bloat(string_)# Bloated string# Print the bloated stringprint("Bloated String:\n",bloated_string)# Print the debloated stringprint("Debloated String\n",bloatier.debloat(bloated_string))Note: You can also use bloats/debloats for multi-stage format. (if you have enough RAM :>)The string being used by the algorithm and the outputs are all stored
in a dictionary "obtain" and can be acquired by using theacquiredfunction.There is a mainbloatierclass and5local functions related to the main class.bloatierclassbloatmethodbloatsmethoddebloatmethoddebloatsmethodacquiremethodbloatfunctionbloatsfunctiondebloatfunctiondebloatsfunctionacquirefunction
Package: blob-az
Azure BlobInstallationpipinstallblob-azAuthorizationBoth required fields can be obtained from the Azure Portal, within the Storage account, "Access keys" tab:BLOB_CONN_STR(Connection string in the portal)BLOB_KEY(KEY in the portal):<random base64 string>Environment (.env)For convenience, you can setos.environ["BLOB_CONN_STR"]andos.environ["BLOB_KEY"]. If you do, you can skip specifying them on every call.E.g., create a.envfile:BLOB_CONN_STR="<BLOB_CONN_STR>"BLOB_KEY="<BLOB_KEY>"Then load it before importingfromdotenvimportload_dotenvload_dotenv()importblob_azasbzbz.client()# just works!APIAsynchronous (everything is a coroutine)Single calls or multiple using a same client:# single callawaitbz.list.containers(conn_str=CONN_STR)# ain't necessary with a .env file# multiple callsasyncwithbz.client()asclient:# idem.awaitbz.container.create("<container-name>",client=client)cs=awaitbz.list.containers(client=client)Functionsaz_blobdefclient(...)->BlobServiceClientlistasyncdefcontainers(...)->list[dict]asyncdefblobs(...)->list[dict]containerasyncdefcreate(...)asyncdefdelete(...)blobasyncdefupload(...)asyncdefdownload(...)->bytesdefurl(...)->str# generate SAS url for blob
Package: blobber
BlobberDescriptionBLobber is an cathodic spots imaging analysing software that is specifically written for the Hamamatsu framing streak camera C4187 at the Applied and Plasma Physics laboratory at the University of Sydney.Blobber is supported in all OS system, and can be run independently in a python script or used in conjunction with Jupyter Notebook.InstallationTo install Blobber, simply run the following command line in the terminal:python3 -m pip install blobberAlternatively, one can find the complete source code of Blobber at its Github repository athttps://github.com/jojounderscorejo/base-blobber.gitUseagePlease refer to theexample providedfor sample usage of Blobber.LicenseCopyright ©2022Jiongyu LiangPermission 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: blobBgone
A simple tool to remove blobs from 2D/3D point cloud data as produced by MINFLUXPlease, find the Data used in the work inExample_Data, the source code inblobBgoneand all Figures appearaing in the main text inFigures.Dependencies:Python 3NumpyScipyMatplotlibScikit-learnseabornPandas (Only for Evaluation)TkInter (If on Windows)More precise dependencies will come once the original article is published.
Technically, this should run on both Windows and Linux.
Package: blobcli
blobcliThis is a command line interface for easy operation with blobs in Azure Blob Storage.Installation$pipinstallblobcliUsageSet connection string to environment variable$exportAZURE_STORAGE_CONNECTION_STRING="<yourconnectionstring>"$blobcli
Usage:blobcli[OPTIONS]COMMAND[ARGS]...blobstorageeasyoperationcli(v*.*.*)Options:--helpShowthismessageandexit.

Commands:cpCopyblob.lsListcontainersorblobs.mvMoveblob.rmDeleteblob.List containers or blobs$blobclils<target>Show list of containers$blobclils2021-04-0412:41:09+00:00samplecontainer012021-04-0412:41:19+00:00samplecontainer022021-04-0412:41:26+00:00samplecontainer03Show list of blobs for the specified container$blobclilssamplecontainer01PREsample-dir01/PREsample-dir02/2021-04-0412:43:49+00:000Bsample01.txt2021-04-0412:43:54+00:000Bsample02.txt2021-04-0412:43:58+00:000Bsample03.txt$blobclilssamplecontainer01/sample-dir01/2021-04-0412:56:27+00:000Bsample04.txt2021-04-0412:57:27+00:000Bsample05.txtDelete blob$blobclirm<target>Delete the specified blob$blobclirmblob://samplecontainer01/sample03.txt
delete:blob://samplecontainer01/sample03.txtMove blob$blobclimv<source><target>Move blob from local to container$blobclimvsample05.txtblob://samplecontainer01/sample-dir01/
move:sample05.txttoblob://samplecontainer01/sample-dir01/container to local$blobclimvblob://samplecontainer01/sample-dir01/sample05.txt.
move:blob://samplecontainer01/sample-dir01/sample05.txtto.container to container$blobclimvblob://samplecontainer01/sample01.txtblob://samplecontainer02/sample11.txt
move:blob://samplecontainer01/sample01.txttoblob://samplecontainer02/sample11.txtCopy blob$blobclicp<source><target>Copy blob from local to container$blobclicpsample05.txtblob://samplecontainer01/sample-dir01/
copy:sample05.txttoblob://samplecontainer01/sample-dir01/container to local$blobclicpblob://samplecontainer01/sample-dir01/sample05.txt.
copy:blob://samplecontainer01/sample-dir01/sample05.txtto.container to container$blobclicpblob://samplecontainer01/sample01.txtblob://samplecontainer02/sample11.txt
copy:blob://samplecontainer01/sample01.txttoblob://samplecontainer02/sample11.txtLicenseThis project are released under theMIT License
Package: blob-cli
blob-cli: Azure Blob Shell CommandOverviewWapper azure-storage-blob for help you operate blobOperate blob by set environment variables(AZURE_STORAGE_ACCOUNT, AZURE_CONTAINER_NAME, AZURE_ACCESS_KEY)AZURE_ACCESS_KEY can be Access Key or Shared Access Signatureprovide shell commands: blob_list, blob_tier, blob_upload, blob_download, blob_delete$ export AZURE_STORAGE_ACCOUNT=azureblobcliaccounttest$ export AZURE_CONTAINER_NAME=azureblobclicontainertest$ export AZURE_BLOB_KEY=azureblobcliaccounttest_SAS_token$ blob_list$ # upload and set archive tier$ ls -l | awk ‘NR>3{print $9}’ | xargs -n 1 -P 4 -I filename blob_upload -f filename -bf archive_folder -t archiveLicenseblob-cli is distributed under theMIT license.
Package: blob-creator
Blob Dataset CreatorBlobs are little monsters that you can use to demonstrate data analysis procedures. They have a size, a weight, a color and a cuteness level. As you can see, a blob dataset contains all types of variables that you can find in the wild (nominal, ordinal and metric).Generator OutputThis generator creates a population of blobs. It delivers (a) an Excel data frame with every blob's properties, (b) a population plot that visualizes all blobs for presentation purposes and (c) a set of visualizations of the population data.Thepopulation plotdisplays all blobs with color and size. In addition to that, it shows blob names. There are three different kinds of base images that can be used to visualize blobs.Thevisualization plotinklude a histogram of blob size and blob weights, as well as a bar chart with cuteness level counts and a scatter plot of size and weight.Use the GeneratorBlob populations can either have large (12) or small (1)variability, determined by the population's scatter index. Moreover, they can consist of a largenumberof monsters or can also be small, determined by the population's n.You cangenerate a new populationby calling:fromblob_creator.coreimportBlobFactory# This instantiates a new blob factoryblob_factory=BlobFactory(n=20,scatter=12,kind="monster")# This will create the blobsblob_factory.create_blobs()# This will export your dataset and your population plot to diskblob_factory.export_data()# Upload the csv file of the popoulation to share# it with your studentsblob_factory.upload_dataset()# Finally, the output directory can be cleaned-upblob_factory.delete_individual_pngs()Package InstallationThis package can be installed using Python's package index. Use the following command to do this:pipinstallblob-creator
Package: blobhub
BlobHub Python SDKOverviewBlobHub is a service offering versioned storage of structured data.BlobHub SDKprovides developers with convenient access to the functionality ofBlobHubplatform.BlobHub PortalRegistrationFreeBlobHubaccount needs to be created in order to make use of the SDK.Follow these steps to get started withBlobHub:Create free BlobHub account at:https://blobhub.io/Create new organization to store your blobs:https://blobhub.io/p/me/org/createCreate blob of desired type (see the section onPresetslibrary below for examples).Under blob's Settings create API key withwriteaccess to the blob.Access ControlSome of the principles in the foundation ofBlobHubaccess model:Blob (and organization holding it) can remainprivateuntil it is ready to be exposed for public consumption.Private Blobs can be shared withBlobHubmembers directly.API keys provide ability to enable mutable access to blob data (via API and SDK).Blob TypesBlob type defines the structure of the data stored within the blob.
It also determines the set of available operations.The following blob types are supported at the moment:ONNX ModelProvides storage of deep neural network computational graphs inONNXformat.InstallationTo install, use:pipinstallblobhubUsageAuthenticationUse the following snippet to get access to the blob:fromblobhub.blobimportBlob,Revisionblob=Blob(org_id="<< organization alias or id >>",blob_id="<< blob alias or id >>",api_key="<< API key from blob settings >>")revision=blob.revisions.latest()assertblob[Blob.FIELD_STATUS]==Blob.STATUS_READYassertrevision[Revision.FIELD_STATUS]==Revision.STATUS_READYassertrevision[Revision.FIELD_PHASE]==Revision.PHASE_DRAFTPresets LibraryPresets library is created to simplify operating with blobs of various types (ONNX, OrientDB Graph, etc.).ONNX ModuleONNX Modelblobs are designed to store deep neural network models exported inONNXformat.Follow these steps to make use of the module:Initialize preset:fromblobhub.presets.onnximportOnnx,Modelonnx=Onnx(revision=revision)Upload local model:local_model=Model.from_local_file(onnx=onnx,path="/path/to/local/model.onnx")success=onnx.upload(model=local_model)assertTrue==successDownload model:downloaded_model=onnx.download()assertNone!=downloaded_model(Optional) Confirm that downloaded model is identical to the original one:assertdownloaded_model.is_identical(model=local_model)
Package: blobkeeper
BlobKeeperBlobKeeper is a lightweight Python library for managing binary data blobs efficiently and persistently using SQLite and a contiguous binary data file. It's designed for scenarios where you need to store and retrieve binary data associated with keys.FeaturesEfficient storage and retrieval of binary data blobs.Using SQLite for locking & metadata.Support for integer or text keys.Optional data file read-only mode.Data integrity checks using CRC32 checksums.Written in pure-Python with zero dependencies.InstallationYou can install BlobKeeper using pip:pip3installblobkeeperQuick StartHere's how to get started with BlobKeeper:fromblobkeeperimportconnect# Create a connection with default settings (integer keys, read-only mode).connection=connect('my_blobs')# Storing binary dataconnection['my_key']=b'Hello, BlobKeeper!'# Retrieving binary datadata=connection['my_key']# Checking the number of items storedcount=connection.count()# Closing the connectionconnection.close()Documentationconnect(path: str, keytype: Keytype = str, ro: bool = False) -> Connectionpath: The base file name for the BlobKeeper storage (without extension).keytype: The type of keys used (int for integer keys or str for text keys).ro: Read-only mode. If set toTrue, the Connection won't allow file modifications.ConnectionClassget(key: Key) -> Optional[bytes]Retrieve binary data associated with a key or None.__getitem__(key: Key) -> bytesRetrieve binary data associated with a key. KeyError is not exists.__setitem__(key: Key, value: bytes) -> NoneStore binary data associated with a key.__delitem__(key: Key) -> NoneDelete key rendering data inaccessible.count() -> intReturn number of items stored.size() -> intReturn the size of the data file in bytes.commit() -> NoneCommit changes to disk.close() -> NoneCommit changes & close connection.ContributingPull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.LicenseThis project is licensed under the MIT License - see theLICENSEfile for details.
Package: blob-masks
Blob MasksBlob Masksis a Python package that allows you to generate white, potato-shaped blobs on a black background. It's perfect for creating random mask patterns, image placeholders, or unique artistic effects.InstallationInstall the package using pip:pipinstallblob-masksUsageHere's a basic example of how to use theblob-maskspackage:fromblob_masksimportblob_mask# Generate a blob mask with default parametersmask=blob_mask()# Save the generated mask as an imagemask.save("blob.png")You can customize the generated blobs by specifying additional parameters:fromblob_masksimportblob_mask# Generate a blob mask with custom parametersnumber_seed_blob=generate_blob(seed=42)text_seed_blob=generate_blob(seed="Magnus",size=256)You can also obtain the borders of the blob.fromblob_masksimportblob_mask,borders_of_blobblob=blob_mask()borders=borders_of_blob(blob,border_width=10)ParametersParametersblob_mask:seed: Seed of the blob, either a string or an integer (default: Random)size: Height and width of the output image in pixels (default: 512)borders_of_blob:blob: The blob to get the borders ofborder_width: Width of the border in pixels (default: 20)LicenseThis project is licensed under the WTFPL License - see theLICENSEfile for details.