Saravanan666/pypi-org huggingface dataset:
Package: binstruct
The binstruct library allows you to access binary data using a predefined
structure. The binary data can be provided in any form that allows an indexed
access to single bytes. This could for example be an mmaped file. The data
structure itself is defined in way similar to Django database table definitions
by declaring a new class with its fields.Simple ExampleFirst you have to define the structure which you want to use to access your
binary data. This is done by specifying all desired fields with their types and
their position inside a new class. As an example let’s take the first of the
ELF header which in C would look like this#define EI_NIDENT 16typedefstruct{unsignedchare_ident[EI_NIDENT];uint16_te_type;uint16_te_machine;uint32_te_version;// rest of the fields omitted for simplicity}ElfN_Ehdr;Using binstruct you now declare the following Python classfrombinstructimport*classElfN_Ehdr(StructTemplate):e_ident=RawField(0,16)e_type=UInt16Field(16)e_machine=UInt16Field(18)e_version=UInt32Field(20)Note that you have to specify the offset of the fields even though it would be
possible to derive that from the size of the previous fields. I opted for this
solution because it makes the implementation easier and because it allows for
easier skipping of irrelevant or reserved fields.Now we can create an instance of this class by providing the constructor an
indexable data structure and an offset. The indexable data structure is any
Python object representing binary data to which you want to have “structured
access”. The offset allows you to place the structure at any place inside the
indexable data structure.For this example lets just use a simple list for the binary databinary_data=24*[0]header=ElfN_Ehdr(binary_data,0)Now you can simply read and write any of the fieldsheader.e_type=0x0header.e_ident[0]=0x7fheader.e_ident[1]=ord('E')header.e_ident[2]=ord('L')header.e_ident[3]=ord('F')print(header.e_type)print(header.e_ident[1])The current implementation provides signed and unsigned fields for 8-bit,
16-bit and 32-bit integers, strings, raw data fields and even nested
structures. For some ideas of how to use them, also checkout the unit tests.ContributingThe library is fully standalone and only requires py.test to run the unit
tests. To contribute any changes simply clone the project on GitHub:https://github.com/Jokymon/binstruct, push your changes to your own GitHub
project and send a pull request. For any changes please make sure you have good
unit tests.
Package: bintablefile
Binary Table File formatBinary Table File - efficient binary file format to store and retrieve tabular dataThis library is written in Cython for speed efficiency.is basically a typed CSV, but binary and indexed,
supporting only a subset of the types:int, float, bool, Decimal.The table is backed by a file on disk, and isNOTmemory-mapped.
This class just interfaces the reading/writing of the file through alistinterface.All the data is indexed and can be accessed as the list of records, where each record is a tuple of values.It's main purpose are big files that don't fit into memory, or the files that are read partially. Ex. a few records from the middle of the file.It can efficiently slice through the file and read just last N records, or just the first N records.The footprint of the file is quite small as the data is binary encoded.It can be used with a seek-able compression format without losing efficiency on indexing, likeidzipInstallationpipinstallbintablefileThe library can be found onPyPi:https://pypi.org/project/bintablefile/Note: We release directly v2.0 as v1.0 was used just internally and was not released to PyPI. The major improvement of V2 is a full-featured header, that allows to store metadata about the table, as well as store the number of records for ReadOnly compression formats likeidzip.
Package: bintang-buddy
The easiest way to view 🏸 court reservations in the Bay AreaEver wanted to play badminton at a certain time? Have you tried looking at court reservations onhttps://bintangbadminton.org/court-reservations/? If yes, you've probably seen this:No experience parallels looking for courts and when they're free, only to click through this nightmare: 😱🙀That's OK, with a few easy steps, you can be viewing court schedules with buttery smoothness:Command line toolInstallationpip install bintang-buddyUsageThe steps are straightforward and very human.Try running the commands below:bintang-buddy -d "2022-01-13" -g "milpitas" -g "sunnyvale"This script has two arguments:-d: Date string, in the form ofYYYY-MM-DD-g: The names of the gyms you'd like to load court schedules for. If you leave this empty you'll get every court for every gym, and you'll be waiting for a while. Your choices:campbell, dublin, milpitas, san carlos, sunnyvale.
Package: bintest
BintestBintest is a extension forunitest, it will provide a way to run a command and assert the output.InstallationpipinstallbintestUsageCreate a file in your project: testcase.py for examplefrombintestimportbintestimportunittestclassMyTestCase(unittest.TestCase,bintest.BinTest):__test__=TruedefsetUp(self):self.set_env(env="./output",# temp dirinput="./tests_case.yml",# yml file)# This worksdeftest_simple_cat(self):output,err=self.run_bin(name="SimpleCAT")# two ways of test, this both will do exactly the sameself.assertEqual(output,"test\n")# this one is more auto because is reading from the ymlself.assertOutput(name="SimpleCAT",output=output)# This Failsdeftest_simple_cat_fail(self):output,err=self.run_bin(name="SimpleCATFail")# this one will failself.assertOutput(name="SimpleCATFail",output=output)if__name__=="__main__":unittest.main()Create the config file: tests_case.yml---# Example test file# required: bin, output# everything in the middle will be passing as paramters to the binary: only the valuesSimpleCAT:bin:/bin/catpath:/Users/artur.gomes/projects/pybintest/examples/test.txtoutput:"test\n"SimpleCATFail:bin:/bin/catpath:/Users/artur.gomes/projects/pybintest/examples/test.txtoutput:"nottest\n"In this case we are testing the cat command, using a file test.txt as argument and expecting the outputCreate the test.txt filetestThen run:python3-munittestdiscover-vvvUnittest will find yout test and run it for you.test_simple_cat(testcase.MyTestCase)...ok
test_simple_cat_fail(testcase.MyTestCase)...FAIL======================================================================FAIL:test_simple_cat_fail(testcase.MyTestCase)----------------------------------------------------------------------
Traceback(mostrecentcalllast):File"/Users/artur.gomes/projects/test_bintest/testcase.py",line26,intest_simple_cat_failself.assertOutput(name="SimpleCATFail",output=output)File"/Users/artur.gomes/Library/Caches/pypoetry/virtualenvs/test-bintest-LukI1uz2-py3.9/lib/python3.9/site-packages/bintest/bintest.py",line34,inassertOutputraiseself.failureException(msg)AssertionError:Error:nottest!=test----------------------------------------------------------------------
Ran2testsin0.011s

FAILED(failures=1)ContributionIf this helps you consider help me to improve.
Package: bintray-python
# Bintray Python![logo](logo.png)[![codecov](https://codecov.io/gh/uilianries/bintray-python/branch/master/graph/badge.svg)](https://codecov.io/gh/uilianries/bintray-python)
[![Maintainability](https://api.codeclimate.com/v1/badges/eb7ea878f71e2a464172/maintainability)](https://codeclimate.com/github/uilianries/bintray-python/maintainability)
[![Build Status](https://travis-ci.com/uilianries/bintray-python.svg?branch=master)](https://travis-ci.com/uilianries/bintray-python)
[![Download Pypi](https://img.shields.io/badge/pypi-download-blue.svg)](https://pypi.org/manage/project/bincrafters-conventions)#### AboutThe Python wrapper for Bintray API#### DocumentationPlease, read the official documentation from Bintray:https://bintray.com/docs/api#### License
[MIT](LICENSE)
Package: bin-tree
bin_treeA python module that provides mutable mappings and sets implemented with binary trees.Current statusThis package is distributed in PyPI starting with version 0.2.0. It is a full
implementation of MutableSet and MutableMapping for both AVL and Red-Black
trees. Test coverage is > 90%, but it should be considered at beta quality
because it still lacks real world application testing.Starting with version 0.3.0, it is tested onTravis-CI,
for Python versions >= 3.5 and <=3.9Its full source is available fromGitHUB.GoalsThis module intends to be used as a normal mapping. It provides various
implementations, a non balancing one, an AVL one, and a red-black
one.Portability is very important here:few dependencies: a Python 3 (tested for version >= 3.5)no additional module requirementsUsage:To be doneInstallingEnd user installationWith pip:pip install bin_tree.Developer installationIf you want to contribute or integratebin_treein your own code, you should get a copy of the full tree fromGitHUB:git clone https://github.com/s-ball/bin_tree [your_working_copy_folder]Running the testsAs the project only uses unittest, you can simply run tests from the main folder with:python -m unittest discoverContributingAs this project is developed on my free time, I cannot guarantee very fast feedbacks. Anyway, I shall be glad to receive issues or pull requests on GitHUB.VersioningThis project uses a standard Major.Minor.Patch versioning pattern. Inside a major version, public API stability is expected (at least after 1.0.0 version will be published).LicenseThis project is licensed under the MIT License - see the LICENSE.txt file for details
Package: bintropy
BintropyDetect packers on PE/ELF/Mach-O files using entropy.This tool is an implementation in Python of Bintropy, an analysis tool presented inthis paperin the scope of packing detection based on entropy. It implements both modes of operation and an additional one, respectively on the entire binary, per section or per segment. It uses the entropy values mentioned in thepaperfor deciding whether the binary contains compressed/encrypted bytes.It relies onlieffor abstracting eitherPE,ELForMach-Oexecutables. This tool thus supports these three formats.$pipinstallbintropy$bintropy--helpModes of operationUse the-m/--modeoption.0: full binary (default)1: per section2: per segmentNote that mode 2 will logically give results very similar to mode 0.$bintropybinary<<<boolean>>>

$bintropybinary--dot-not-decide<<<highestblockentropy,averageblockentropy>>>$bintropybinary--mode[1|2]<<<boolean>>>

$bintropybinary-m[1|2]--do-not-decide<<<highestblockentropy,averageblockentropy>>>BenchmarkingUse the-b/--benchmarkoption to get one more value, the processing time in seconds.$bintropybinary-b<<<boolean,processingtime>>>

$bintropybinary-b--do-not-decide<<<highestblockentropy,averageblockentropy,processingtime>>>Overriding default entropy valuesThereference paperuses 6.677 for the average block entropy and 7.199 for the highest block entropy (obtained by analyzing a dataset of PE files and using the first mode of operation). These values can be overriden with the dedicated options.$bintropybinary--threshold-average-entropy5.678--threshold-highest-entropy6.789[...]PlottingThis tool features plot generation for drawing binary's sections and the entropy within.$bintropybinary--plot<<<boolean>>>Example of generated figures:Related ProjectsYou may also like these:Awesome Executable Packing: A curated list of awesome resources related to executable packing.Dataset of packed ELF files: Dataset of ELF samples packed with many different packers.Dataset of packed PE files: Dataset of PE samples packed with many different packers (fork ofthis repository).Docker Packing Box: Docker image gathering packers and tools for making datasets of packed executables.DSFF: Library implementing the DataSet File Format (DSFF).PEiD: Python implementation of the well-known Packed Executable iDentifier (PEiD).PyPackerDetect: Packing detection tool for PE files (fork ofthis repository).REMINDer: Packing detector using a simple heuristic (inspired fromthis paper).
Package: binusmayapy
binusmaya_pyPython wrapper for Binusmaya web APIUsageInstall packagepipinstallbinusmayapyExamplefrombinusmayapyimportbimayimportdotenvimportosdotenv.load_dotenv()bm=Bimay(token=os.getenv("BIMAY_TOKEN"))print(bm.get_schedule_date(date_start=datetime.datetime.now()))output:[{"class_id":"[redacted]","class_session_id":"[redacted]","course_name":"[redacted]","course_class":"[redacted]","session_number":7,"delivery_mode":"VC","join_url":"[redacted]","location":{"location":null,"location_value":null},"date_start":"[redacted]","date_end":"[redacted]","topic":"[redacted]","subtopic":["[redacted]"],"resources":[{"resource_id":"[redacted]","resource_name":"Video Conference","resource_type":null,"resource_url":null,"resource_is_open":true},{"resource_id":"[redacted]","resource_name":"[redacted]","resource_type":null,"resource_url":"[redacted]","resource_is_open":true},{"resource_id":"[redacted]","resource_name":"[redacted]","resource_type":"pptx","resource_url":"[redacted]","resource_is_open":true},{"resource_id":"[redacted]","resource_name":"[redacted]","resource_type":null,"resource_url":"[redacted]","resource_is_open":true},{"resource_id":"[redacted]","resource_name":"[redacted]","resource_type":null,"resource_url":"[redacted]","resource_is_open":true},{"resource_id":"[redacted]","resource_name":"Javascript Introduction","resource_type":null,"resource_url":"[redacted]","resource_is_open":true}],"is_ended":true}]Disclaimer: This project is not affiliated, associated, authorized, endorsed by, or in any way officially related to "Bina Nusantara University" and or "BinusMaya" and it is used for personal use only. The author is not liable for any damage that may occur from the use of this project.contact@radityaharya.me
Package: binutils
Copyright (c) 2022 Jérémie DECOCK (www.jdhp.org)Web site:http://www.jdhp.org/software_en.html#binutilsOnline documentation:https://jdhp.gitlab.io/binutilsExamples:https://jdhp.gitlab.io/binutils/gallery/Notebooks:https://gitlab.com/jdhp/binutils-notebooksSource code:https://gitlab.com/jdhp/binutilsIssue tracker:https://gitlab.com/jdhp/binutils/issuesPytest code coverage:https://jdhp.gitlab.io/binutils/htmlcov/index.htmlbinutils on PyPI:https://pypi.org/project/binutilsbinutils on Anaconda Cloud:https://anaconda.org/jdhp/binutilsDescriptionPython Binary ToolsNote:This project is still in beta stage, so the API is not finalized yet.DependenciesC.f. requirements.txtInstallationGnu/LinuxPosix (Linux, MacOSX, WSL, …)From the binutils source code:conda deactivate         # Only if you use Anaconda...
python3 -m venv env
source env/bin/activate
python3 -m pip install --upgrade pip
python3 -m pip install -r requirements.txt
python3 setup.py developWindowsFrom the binutils source code:conda deactivate         # Only if you use Anaconda...
python3 -m venv env
env\Scripts\activate.bat
python3 -m pip install --upgrade pip
python3 -m pip install -r requirements.txt
python3 setup.py developDocumentationOnline documentation:https://jdhp.gitlab.io/binutilsAPI documentation:https://jdhp.gitlab.io/binutils/api.htmlExample usageExamples:https://jdhp.gitlab.io/binutils/gallery/Build and run the Python Docker imageBuild the docker imageFrom the binutils source code:docker build -t binutils:latest .Run unit tests from the docker containerFrom the binutils source code:docker run binutils pytestRun an example from the docker containerFrom the binutils source code:docker run binutils python3 /app/examples/hello.pyBug reportsTo search for bugs or report them, please use the binutils Bug Tracker at:https://gitlab.com/jdhp/binutils/issuesLicenseThis project is provided under the terms and conditions of theMIT License.
Package: binvox
binvoxBinvox is a file-format developed by Patrick Min that helps to store
the 3D binary-volume (e.g. occupancy grid) in compact manner.
This repository contains a library for loading &amp; saving the Binvox files.A popular script to load/save binvox files has been published
athere. However, the code is
almost 10 years old now and every project duplicated the script file
when using it.This project is based on the available code-base. The main aim is to
re-implement binvox file I/O as a library while taking OOP structure and
easy distribution (packaging) into account.InstallationPip can be used to install the library:pip install binvoxUnderstanding the binvox file-formatInformation regarding the format can be found here:patrickmin.com/binvox
Package: bin-wrapper
py-wrappersPython wrapper for binary filesUsageimportwrapperclassHelm(wrapper.ExecWrapper):"""helm binary wrapperhelm = Helm(o='json')resp = helm.ls() => `helm ls -o=json`resp.raise_for_status()print(resp.json)helm = Helm()helm.repo.add.bitnami('https://charts.bitnami.com/bitnami')helm = Helm()resp = helm.upgrade.redis('bitnami/redis', install=None, o='json')# helm upgrade redis bitnami/redis --install -o json# or sameresp = helm('upgrade', 'redis', 'bitnami/redis', '--install', o='json')# helm upgrade redis bitnami/redis --install -o json# orresp = helm.upgrade.redis('bitnami/redis', i=None, o='json')# helm upgrade redis bitnami/redis -i -o json"""def__init__(self,**kwargs):super().__init__('helm',**kwargs)def__getattr__(self,item):h=Helm(**self._parent_kwargs)h._parent_attrs=self._parent_attrs.copy()h._parent_attrs.append(item.replace('_','-',-1))returnhdef_pre(self,args,parent_kwargs,kwargs):ns_short=parent_kwargs.pop('n',None)parent_kwargs.setdefault('namespace',ns_short)out_short=parent_kwargs.pop('o',None)out=parent_kwargs.pop('output',out_short)out_short=kwargs.pop('o',out)kwargs.setdefault('output',out_short)
Package: binx-og-image-generator
Binx image generatorThe binx-og-image-generator is a tool to generate images for your blog.Usage: binx-og-image-generator [OPTIONS] IMAGE

  generate an og image for blog

Options:
  --title TEXT     of the blog  [required]
  --subtitle TEXT  of the blog  [required]
  --author TEXT    of the blog  [required]
  --output TEXT    filename of the image  [required]
  --help           Show this message and exit.To generate an images, type:docker run --rm \-v $PWD:$PWD \-w $PWD \ghcr.io/binxio/og-image-generator \--title "foo" \--subtitle "bar" \--author "binx consultant" \./banner.jpgThe generated image can be found in your current directory and is namedog-banner.jpg.PipenvIf you which to install the binx-og-image-generator on your host machine follow these steps.PrerequisitesPython 3.9PipenvSteps to use the OG Image Generatorpip install pipenvpipenv shellpipenv installbinx-og-image-generator --title "foo" --subtitle "bar" --author "binx consultant" banner.jpg
Package: binypt-cli
Binypt - Cryptocurrency Chart Data DownloaderOverviewBinyptis a versatile Python command-line utility tool that allows you to effortlessly download historical cryptocurrency chart data from the Binance exchange. Whether you're a trader, researcher, or just a crypto enthusiast, Binypt simplifies the process of collecting and exporting candlestick data for your preferred trading pairs and time intervals.InstallationBefore using Binypt, make sure you have the required dependencies installed:pipinstallbinypt-cliUsageBinypt offers a range of options to tailor your data collection. Here's how to use it:$binypt-p<TRADING_PAIR>-i<INTERVAL>-od<OPEN_DATE>-cd<CLOSE_DATE>[OPTIONS]Required Arguments-p,--trading-pair: Specify the trading pair symbol (e.g., BTCUSDT).-i,--interval: Set the candlestick interval (e.g., 1h, 1d, 1w).-od,--open-date: Define the start date for data collection (YYYY-MM-DD/HH:mm:ss).-cd,--close-date: Define the end date for data collection (YYYY-MM-DD/HH:mm:ss).Optional Arguments-o,--output-path: Path to the output file for data storage. Supported formats: .csv, .excel, .pkl. (Default: binypt_data.csv)-hr,--add-hr-time: Include human-readable time format in the output data.-v,--verbose: Enable verbose logging for debugging purposes.ExamplesBasic UsageDownload 1-hour candlestick data for the BTCUSDT trading pair from January 1, 2023, to January 10, 2023, and save it as "btc_data.csv":$binypt-pBTCUSDT-i1h-od2023-01-01/00:00:00-cd2023-01-10/23:59:59-obtc_data.csvVerbose ModeEnable verbose logging to get detailed information during data retrieval:$binypt-pBTCUSDT-i1h-od2023-01-01/00:00:00-cd2023-01-10/23:59:59-vHuman-Readable Time FormatInclude human-readable time format in the output data:$binypt-pBTCUSDT-i1h-od2023-01-01/00:00:00-cd2023-01-10/23:59:59-hrOutputBinypt will download the requested data and save it in the specified format and file path. The data will be ready for further analysis or visualization.LicenseThis software is distributed under the MIT License. You are free to use, modify, and distribute it as needed. Please refer to the LICENSE file for more details.Happy trading, and may your charts always be green!🚀💰
Package: binypt-lib
Binypt: A Python Library for Cryptocurrency Data Retrieval and ProcessingOverviewBinyptis a Python library designed for retrieving historical cryptocurrency price data from the Binance exchange. It allows you to specify trading pairs, time intervals, and date ranges to download and work with historical price data efficiently. This library is a helpful tool for anyone interested in analyzing or visualizing cryptocurrency price trends.FeaturesRetrieve historical cryptocurrency price data from Binance.Specify trading pairs, time intervals, and date ranges.Export data in various formats such as CSV, Excel, or Pickle.Added human readable dates to the chart.InstallationYou can install Binypt usingpip:pipinstallbinypt-libUsageHere's a brief overview of how to use Binypt:frombinyptimportBinypt# Initialize Binyptbinypt=Binypt()# Set data retrieval parametersbinypt.set_arguments("BTCUSDT","1h","01/09/2023-00:00:00","10/09/2023-23:59:59")# Fetch cryptocurrency price databinypt.retrieve_data()# Export data to a CSV filebinypt.export("crypto_data.csv")# Add human-readable timestampsbinypt.add_human_readable_time()# Show progress bar and log messagesbinypt.set_verbosity(show_bar=True,show_log=True)# Access the data as a Pandas DataFrameprice_data=binypt.get_data()# You can now perform various data analysis or visualization tasks with the price_data DataFrameContributionsContributions to this project are welcome. Feel free to submit bug reports, feature requests or pull requests!DocumentationTo deep dive in on how this library functions, please refer to thedocumentation
Package: bio2bel
Bio2BEL is a project aimed at bringing biological databases and other structured knowledge sources in a wide variety
of schemata into the unified framework of theBiological Expression Language[1].Two important places to look:How to make a Bio2BEL RepositoryHow to use the CLIInstallationDownload the latest stable code fromPyPIwith:$python-mpipinstallbio2belor get the latest from GitHub with:$gitclonehttps://github.com/bio2bel/bio2bel.git$cdbio2bel$python-mpipinstall-e.or check theinstallation instructions.CitationIf you find Bio2BEL useful for your work, please consider citing:[1]Hoyt, C. T.,et al.(2019).Integration of Structured Biological Data Sources using Biological Expression Language.bioRxiv, 631812.
Package: bio2bel-adeptus
Converts ADEPTUS disease-differential gene expression signatures to BEL.Big thanks to Daniel Himmelstein for preprocessing this data in his repository at:https://github.com/dhimmel/adeptusInstallationbio2bel_adeptuscan be installed easily fromPyPIwith the following code in your favorite terminal:$python3-mpipinstallbio2bel_adeptusor from the latest code onGitHubwith:$python3-mpipinstallgit+https://github.com/bio2bel/adeptus.gitSetupThis repository does not currently cache the data, but only wraps conversion to BEL.Python REPL>>>importbio2bel_adeptus>>>adeptus_manager=bio2bel_adeptus.Manager()>>>graph=adeptus_manager.to_bel()
Package: bio2bel-chebi
Convert the ChEBI ontology and related chemical information to BEL.Installationbio2bel_chebican be installed easily fromPyPIwith
the following code in your favorite terminal:$python3-mpipinstallbio2bel_chebior from the latest code onGitHubwith:$python3-mpipinstallgit+https://github.com/bio2bel/chebi.git@masterSetupChEBI can be downloaded and populated from either the Python REPL or
the automatically installed command line utility.Python REPL>>>importbio2bel_chebi>>>chebi_manager=bio2bel_chebi.Manager()>>>chebi_manager.populate()Command Line Utilitybio2bel_chebipopulate