Saravanan666/pypi-org huggingface dataset:
Package: bookio-fetchfox
book.io / fetchfoxCollection of API services to fetch information from several blockchains.Supported BlockchainsAlgorandimportosfromfetchfox.blockchainsimportAlgorandalgorand=Algorand(nftexplorerapp_api_key=os.getenv("NFTEXPLORER_API_KEY"),)# Brave New Worldcreator_address="6WII6ES4H6UW7G7T7RJX63CUNPKJEPEGQ3PTYVVU3JHJ652W34GCJV5OVY"forassetinalgorand.get_assets(creator_address):print(asset)Servicesget_asset (algonode.cloud)get_assets (algonode.cloud)get_holdings (algonode.cloud)get_snapshot (algonode.cloud)get_campaigns (book.io)get_listings (randgallery.com/algoxnft.com)get_floor (randgallery.com/algoxnft.com)get_sales (nftexplorer.app¹)Cardanoimportosfromfetchfox.blockchainsimportCardanocardano=Cardano(blockfrostio_project_id=os.getenv("BLOCKFROST_PROJECT_ID"),)# Gutenberg Biblepolicy_id="477cec772adb1466b301fb8161f505aa66ed1ee8d69d3e7984256a43"forassetincardano.get_collection_assets(policy_id):print(asset)Servicesget_asset (blockfrost.io²)get_assets (blockfrost.io²)get_holdings (blockfrost.io²)get_campaigns (book.io)get_snapshot (blockfrost.io²)get_listings (jpg.store)get_floor (jpg.store)get_sales (jpg.store)get_ranks (cnft.tools)EVM (Ethereum and Polygon)importosfromfetchfox.blockchainsimportEthereum,Polygonethereum=Ethereum(geckodriver_path=os.getenv("GECKODRIVER_PATH"),moralisio_api_key=os.getenv("MORALIS_API_KEY"),openseaio_api_key=os.getenv("OPENSEA_API_KEY"),)polygon=Polygon(geckodriver_path=os.getenv("GECKODRIVER_PATH"),moralisio_api_key=os.getenv("MORALIS_API_KEY"),openseaio_api_key=os.getenv("OPENSEA_API_KEY"),)# Alice in Wonderlandcontract_address="0x919da7fef646226f88f70305201de392ff365059"forassetinethereum.get_assets(contract_address):print(asset)# Art of Warcontract_address="0xb56010e0500e4f163758881603b8083996ae47ec"forassetinpolygon.get_assets(contract_address):print(asset)Servicesget_asset (moralis.io³)get_assets (moralis.io³)get_holdings (moralis.io³)get_snapshot (moralis.io³)get_campaigns (book.io)get_listings (opensea.io⁴)get_floor (opensea.io⁴)get_sales (opensea.io⁴)¹nftexplorer.appservices require anapi key.²blockfrost.ioservices require aproject id.³moralis.ioservices require anapi key.⁴opensea.iosome services also require anapi key.fetch, the fox
Package: bookirds3
This is the code repository forPricing and Trading Interest Rate Derivatives (3rd Edition). This repository
is minimalist for pedagogical purposes. It does not contain documentation or code comments since all explanation
and every step of the construction process is discussed in relevant sections of the text material. This code
is released under a GNU Public License v3. Please review this with particular regard to sections 15 and 16 on
warranty and liability, of which the author offers none and assumes none respectively.Structure of this repositorymodules: this folder contains the code files that are discussed and created within the text.notebooks: this folder contains Jupyter Notebooks that can be executed to recreate many of the examples documented in the text, often with additional aids.files: this folder contains files that are cited in the bibliography of the text.previous_edition_material: this folder contains legacy files from previous editions of the book, mostly Excel workbooks with former examples.tests: this folder contains test scripts to ensure the functions continue to operate correctly as development occurred. Tests should not be considered exhaustive.requirement.txt: this file contains the Python packages and their versions that were used in the creation of this repository.How to use this repositoryThere are three ways I envisage any user will want to use this repository:As aCasual Readerwho is interested in using the book's material and examples but not necessarily in the codebase itself.As aNew Learnerfollowing along with the code creation and examples in the text.As aDevelopertaking the codebase in the repository and repurposing it entirely.The Casual ReaderThe casual reader who does not want to download or clone this repo can install the
code package here from PyPI into their own Python environment usingpip:~$ pip install bookirds3This is enough to execute the code examples in the book. For example the
first instance, of chapter 11 can be replicated as followsfrombookirds.curvesimportCurvefromdatetimeimportdatetimecurve=Curve(interpolation="log_linear",nodes={datetime(2022,1,1):1.00,datetime(2022,4,1):0.9975,datetime(2022,7,1):0.9945,})print(curve)Additionally, the casual reader can download any of the Jupyter Notebooks
and themodule_loader.pyfile in the same directory and execute them,
provided the installed dependencies are installed,(yourpythonenv) ~$ pip install pandas matplotlib jupyterlabDevelopers and New LearnersDevelopers and new learners should eitherdownloadorclonethis repo~$ git clone https://github.com/attack68/book_irds3.gitIt is advisable to create and activate a virtual python environment, and to install of the
necessary (and optional) dependencies.book_irds3$ python3 -m venv venv
book_irds3$ . venv/bin/activate
(venv) book_irds3$ pip install -r requirements.txtAll of the example notebooks should then be executable without errors, having started
Jupyter Lab,(venv) book_irds3$ jupyter labFor a developer to run the test suite simply execute(venv) book_irds3$ pytest tests
Package: book.isbn
`book.isbn` is a package for book ISBN.======setup======easy_install=============Make environmen::$ easy_install book.isbnpip====Make environmen::$ pip install book.isbnHistory========Version 0.0.2--------------(released Jun 3th 2011)- Added author- Divided functionsVersion 0.0.1--------------(released May 29th 2011)- Initial release
Package: bookish
About the libraryThe project performs a word count of the text you enter. This can be attached in .txt, .epub and .mobi format. In addition, it currently works with both English and Spanish text.The count can be performed taking into account words such as articles, conjunctions and prepositions or omitting them.FunctionalitiesRead textsClean text and omit articles, conjunctions and prepositions.Count wordsDependenciesepub_conversion: Processing of epub filesmobi: Processinf of mobi filesHow to get itThe source code is hosted on:https://github.com/iratigaritano/bookish.The installers for the latest released version are available at:https://pypi.org/project/bookish/Command to install the package:# InstallpipinstallbookishCommand to update the package:# Updatepipinstallbookish--upgradeAuthorsJavier Ortega (javier.ortega@alumni.mondragon.edu)Irati Garitano (irati.garitano@alumni.mondragon.edu)
Package: bookit
bookitDoc site generatorOverviewThis Python program converts all files in a Git repository to markdown files. It's useful for creating doc sites of your code.The converted markdown files are placed in a.bookitsubdirectory. The directory structure inside.bookitis an exact mirror of the original repository.Usagepython-mbookit/path/to/your/repoHow it worksEach file is converted into a markdown file, with the file name being the#titleof the markdown file and the contents of the original file placed inside a code block, highlighted according to the original file's language.Here's an example of the directory structure transformation:Before:repo/
├──README.md
├──file1.py
├──file2.jsAfter:repo/
├──.bookit/
│├──file1.py.md
│└──file2.py.md
├──README.md
├──file1.py
└──file2.jsDEVSetupmakeinstallThis will setup a virtualenv, upgrade pip, install dependencies, and install pre-commitnote: This does not activate your virtualenv! You must runsource env/bin/activateto use the venv.TestmaketestFormatmakeformatmakelintVersion & Releasemakeversion-<major/minor/patch>makereleasenoteDon't forget togit pushwith--tagspre-commitSetupmakeinstall-pre-commitRun allmakepre-commit
Package: booklet-splitter
Booklet splitting toolFor a given large PDF file, bind a book.InstallationOn your python environment, just issue this pip install command:pipinstallbooklet_splitterUsageusage:booklets[-h][--max_sizeMAX_SIZE][--logLOG][--targetdirTARGETDIR][--no-layout][--cover]input_pdf

Foragivenpdf,buildsbookletstobeprinted,foldedandeventualyassembledasabook

positionalarguments:input_pdfPDFfiletobeslicedasbooklets

optionalarguments:-h,--helpshowthishelpmessageandexit--max_sizeMAX_SIZEMaxsizeforabooklet,mustbemultipleof4--logLOGLoglevelatexecution--targetdirTARGETDIRDirectorywherethebookletsPDFarewritten--no-layoutOnlysplitsyourdocumentinbooklets--coverAddsapageattheverybeginningandattheveryend,topasteacoverUseful commands to print pdf filesFor a given pdf, print odd/even pages:lpr-opage-set=odd<file>
lpr-opage-set=even<file>For a given pdf, print recto/versolpr-osides=one-sided<file>
lpr-osides=two-sided-long-edge<file>
lpr-osides=two-sided-short-edge<file>Print black and whitelpr-osaturation=percent<file>
Package: bookmaker
desc:Book orientated CMS.BookMakerOverviewBookmaker is a fairly short Content Management System.  I did not
really intend to build one, but it looks like I have.  Originally I
wanted a way to convert ReSt based files into a website, and the then
new Sphinx project from Python looked a good idea.  But it was a bit
too complex for me, I did not spend enough time getting my head around
its config stuiff (I now know why it is complex, there is no easy
solution) and so I built my own.  It grew a bit.So, we have a script that will take a directory, assume that directory
holdshierachy of folders and ReSt based text files that represent the
content to be managed.meta folder that holds templates and config infomrationcss - seems simple enough.  might need to enforce docutils css
globallyimgs (well, media) for the whole hierarchy.  Yes that could be
better.  Well I think that hardly matters - each page refs its own
imgs so they can be put anywhere as long as the pages keep the right
refs.Desired Featuresallowing collaboration with git - so for example having someone push comments and spelling changes.
Package: bookmaker-mc
BookMakerA Book Authoring Application in Python - inspired by Gitbook-LegacyBookMaker is a book authoring application in Python.IntroductionBookMaker facilitates authoring using MarkDown, with a live preview.Handles a complete book with a live tree display of chapters, sections and subsections.Exporting to EPUBExporting to PDF (generating suitable HTML and CSS for Prince)How to install it?Using poetry (https://python-poetry.org/)git clone https://github.com/marcris/bookmaker_mc.git
cd bookmaker_mc
poetry build
pip3 install dist/*.whlRun using the command 'bm'.LinksBookMaker GitHub repository including documentation (in preparation)https://github.com/marcris/BookMaker_mc
Package: bookman
# bookmanbookman is a non-webapp, standalone bookmark managing software. It gives you the ability to store any link you want and open it instantly.## DependenciesPython 3Python 3 - GTK3Python 3 - YamlPython 3 - SQL Alchemy## Building packagesTo build bookman you will need:
* A private GPG-Key
* Make
* Python 3
* [stdeb](https://pypi.org/project/stdeb/)### Building for Debian`bash make deb `### Building for Fedora/Redhat`bash make rpm `The package created stores everything under /usr/local. Therefore you might add
following to your ~/.bashrc file to actually use bookman:`bash exportPYTHONPATH=$PYTHONPATH:/usr/local/lib/python3.5/dist-packages`## AuthorRichard Baeck <richard.baeck@free-your-pc.com>## LicenseMIT License
Package: bookmark-archiver
bookmarkarchiverPython script that archives all of your bookmarks on the Internet Archive. Supports all major browsers. Contributions welcome!bookmarkarchiver uses the official Save Page NowAPI. Anonymous users are limited to 4,000 requests per day, which should be enough to save around 200 websites. If you create a free account to theInternet Archiveand log in with a Chromium-based browser (e.g. Google Chrome) or Firefox, your single-day request limit increases to 100,000 and you should be able to save approximately 5000 websites. This may be significant overestimate if you also choose to captire outlinks. Due to API limitations, each bookmark should take around 10 seconds to archive.bookmarkarchiver uses thebrowser_cookie3module.UsageTo use bookmarkarchiver, you need a bookmark file. You can get one by exporting them from a browser—instructions vary by browser and are readily available online. Typically, you have to export them through your browser's bookmarks page.The easiest way to install bookmarkarchiver is to runpip3 install bookmarkarchiver.$ pip3 install -r requirements.txt
$ python3 bookmarkarchiver.py --help
usage: bookmarkarchiver.py [-h] [--no_capture_all] [--capture_outlinks] [--capture_screenshot] [--delay_wb_availability] [--force_get]
                           [--no_skip_first_archive] [--email_result] [--quit_immediately] [--api_wait_seconds API_WAIT_SECONDS]
                           bookmark_file

Archives your bookmarks with the Wayback Machine.

positional arguments:
  bookmark_file         A Netscape format bookmarks file

optional arguments:
  -h, --help            show this help message and exit
  --no_capture_all, -n  Don't capture error pages
  --capture_outlinks, -c
                        Capture all outlinks
  --capture_screenshot, -s
                        Capture a screenshot
  --delay_wb_availability, -d
                        Delay uploading capture
  --force_get, -f       Force a GET request
  --no_skip_first_archive, -a
                        Don't recapture pages
  --email_result, -e    Email results to user
  --quit_immediately, -q
                        Don't show end results
  --api_wait_seconds API_WAIT_SECONDS, -w API_WAIT_SECONDS
Package: bookmark-box
My ProjectDescribe what your package is aboutPackage DistributionInstallationpip install my-projectUsepython ./src/main.pyDocker DistibutionInstallationdocker pull docker_user/project_name:latestUsedocker run -p 5000:5000 project_nameor for detached mode:docker run -d -p 5000:5000 project_name
Package: bookmarkd
# bookmarkdA tool to convert IPython Notebooks to markdown and back.## markdown -> notebook
$ bookmarkd convert foo.md foo.ipynb
## notebook -> markdown, not done yet
$ bookmarkd convert foo.ipynb foo.md# receive markdown via stdin
$ bookmarkd convert - foo.ipynb
# output notebook on stdout
$ bookmarkd convert foo.md -The conversion process isn’t lossless. For example, the notebook cell numbers
and stored results aren’t preserved.# LicenseBookmarkd is made available under the GNU Affero General Public License, see
LICENSE.txt for details.
Package: bookmarkdown
bookmarkdownParse your browser's exported HTML bookmark file to Markdown.Supported browsers: Brave.InstallationpipinstallbookmarkdownUsageCLI# Convert "bookmarks.html" to markdown and output to STDOUTbtmbookmarks.html# Convert "bookmarks.html" to markdown and write to "bookmarks.md"btm--output=bookmarks.mdbookmarks.html# Alternativelybtmbookmarks.html>bookmarks.mdPythonTheBookmarkHTMLParseris an instance of the Python standard library'sHTMLParserand thus supports all its
methods.frombookmarkdownimportbtmparser=btm.BookmarkHTMLParser()parser.feed(html_content)# Access the dataparser.dataFAQConcernsMinimal dependencies.bookmarkdownis likely to be installed on the system level Python to make
use of thebtmscript.Correctness. No one likes to lose a bookmark nor a different ordering.Future ideasThe current application solves my needs pretty well, but there are additional applications I can
think of. Such as merging multiple bookmark files.Add functionality to the CLI and Python codebase to support the following:# Merge bookmark html-file into existing markdown file.btm--merge=[md-file][html-file]btm[html-file]# already implemented# Read the `-r` as "reverse", i.e. instead of bookmark to markdown it# becomes markdown to bookmark.btm-r[md-file]btm-r--merge=[md-file][html-file]Project structureThe project structure was automatically set up usingcookiecutterand my Python template:cutter-py.
Package: bookmarklets
BookmarkletsA tool for developing bookmarklets.Inspired byhttps://github.com/mrcoles/bookmarklet, but designed to support multiple bookmarklets, and to also export as html.Develop bookmarklets based on javascript files, eg. so that you can commit the source files to git.InstallationIt is recommended to install usingpipx, but you can also usepip. Seehttps://pypi.org/project/pipx/.pipxinstallbookmarkletTo convert them to bookmarklets, either start the server or generate a bookmarks.html file.Serverrunbookmarklet server [FOLDER]specify the folder with the javascript files, otherwise the current folder is useduse-o/--opento automatically open the webpageuse-p/--portto serve the port other than the default (8000)use--publicto allow other devices on your network to access the page, otherwise only on localhoston the webpage drag each bookmarklet to your bookmarks barHTMLrunbookmarklet html [FOLDER]specify the folder with the javascript files, otherwise the current folder is useduse-o/--outputto specify the output file, otherwise it defaults tobookmarks.htmlimport thebookmarks.htmlinto your browserMetadataYou can include some metadata in a comment block at the top of the source file.The fields that you can use are:name: the name of the bookmarklet (if not provided, the file name will be used)in the server this will be the name of the buttonin the html this will be the name of the bookmark, and included in a commentauthor : the author of the bookmarkletin the server this will be mentioned next to the buttonin the html this will be included in a commenturl: link to the authorin the server this will be linked to the authorin the html this will be included in a commentscript: script to load before running the bookmarkletspecify it multiple times to use multiple scriptsstyle: style to load before running the bookmarkletspecify it multiple times to use multiple stylesSee the examples in this repo.
Package: bookmarks2markdown
bookmarks2markdownConvert HTML bookmarks to Markdown.Installationpip3 install bookmarks2markdownUsagebookmarks2markdown --in bookmarks.html --out bookmarks.mdReferencesNetscape Bookmark File Format (Internet Explorer)LICENSECopyright 2019 Nikola Trubitsyn

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Package: bookmarks-converter
Bookmarks ConverterBookmarks Converter is a package that converts the webpage bookmarks
fromDataBase/HTML/JSONtoDataBase/HTML/JSON. It can be used as amoduleor using theCLI.The Database files supported are custom sqlite database files created by the SQLAlchemy ORM model found in the.models.py.The HTML files supported are Netscape-Bookmark files from either Chrome or Firefox. The output HTML files adhere to the firefox format.The JSON files supported are the Chrome.jsonbookmarks file, the Firefox.jsonbookmarks export file, and the custom json file created by this package.To see example of the structure or layout of theDataBase,HTMLorJSONversions supported by the packege, you can check the corresponding file in the data folder found in thegithub page dataor thebookmarks_file_structure.md.Table of ContentsTable of ContentsPython and OS SupportDependenciesInstallTestUsage as ModuleUsage as CLILicensePython and OS SupportThe package has been tested on Github Actions with the following OSs and Python versions:OS \ Python3.123.113.103.9macos-latest✓✓✓✓ubuntu-latest✓✓✓✓windows-latest✓✓✓✓DependenciesThe package relies on the following libraries:BeautifulSoup4: used to parse the HTML files.SQLAlchemy: used to create and manager the database files.InstallBookmarks Converter is available onPYPIpython-mpipinstallbookmarks-converterTestTo test the package you will need to clone thegit repository.# Cloning with HTTPSgitclonehttps://github.com/radam9/bookmarks-converter.git# Cloning with SSHgitclonegit@github.com:radam9/bookmarks-converter.gitthen you create and install the dependencies usingPoetry.# navigate to repo's foldercdbookmarks-converter# install the dependenciespoetryinstall# run the testspoetryrunpytestUsage as Modulefrombookmarks_converterimportBookmarksConverter# initialize the class passing in the path to the bookmarks file to convertbookmarks=BookmarksConverter("/path/to/bookmarks_file")# parse the file passing the format of the source file; "db", "html" or "json"bookmarks.parse("html")# convert the bookmarks to the desired format by passing the fomrat as a string; "db", "html", or "json"bookmarks.convert("json")# at this point the converted bookmarks are stored in the 'bookmarks' attribute.# which can be used directly or exported to a file.bookmarks.save()Usage as CLI# Activate the virtual environment if the "bookmarks-converter" package was installed inside one.# run bookmarks-converter with the desired settings# bookmarks-converter input_format output_format filepathbookmarks-converterdbjson/path/to/file.db# use -h for to show the help message (shown in the code block below)bookmarks-converter-hThe help message:usage:bookmarks-converter[-h][-V]input_formatoutput_formatfilepath

Convertyourbrowserbookmarksfilefrom(db,html,json)to(db,html,json).

positionalarguments:input_formatFormatoftheinputbookmarksfile.oneof(db,html,json).output_formatFormatoftheoutputbookmarksfile.oneof(db,html,json).filepathPathtobookmarksfiletoconvert.

optionalarguments:-h,--helpshowthishelpmessageandexit-V,--versionshowprogram'sversionnumberandexitLicenseMIT License
Package: bookmarks-parser
bookmarks-parserParsing Netscape bookmark (Google Chrome, Firefox, ... export files) .Installation$ pip install bookmarks-parserUsageimportpprintimportbookmarks_parserbookmarks=bookmarks_parser.parse("bookmarks.html")pprint.pprint(bookmarks)output exampleDevelopmentInstallPoetry$ poetry installrun tests$ poetry run pytest --cov=bookmarks_parserLicenseMIT