Saravanan666/pypi-org huggingface dataset:
Package: cexpl
cexplCommand-line tool to interact withCompiler Explorer.Overviewcexplis able to query all available languages, compilers, build and execute your source code. You can also give some extra arguments, like compiler flags, command-line arguments and STDIN.The Compiler Explorer API host can be specified with the-H/--hostoption.List available languagesThe--list-langsoption lists all languages and their IDs:$ cexpl --list-langs
ada - Ada
analysis - Analysis
assembly - Assembly
c - C
c++ - C++
carbon - Carbon
circle - C++ (Circle)
circt - CIRCT
clean - Clean
cpp2_cppfront - Cpp2-cppfront
...The language ID can be used with the-l/--langoption.List available compilersThe--list-compilersoption lists all compilers and their IDs:$ cexpl --list-compilers
386_gl114 - 386 gc 1.14
386_gl115 - 386 gc 1.15
386_gl116 - 386 gc 1.16
386_gl117 - 386 gc 1.17
386_gl118 - 386 gc 1.18
386_gl119 - 386 gc 1.19
386_gltip - 386 gc (tip)
6g141 - amd64 gc 1.4.1
aarchg54 - ARM64 gcc 5.4
arduinomega189 - Arduino Mega (1.8.9)
...It is also possible to list the compilers for a specific language. For example,cexpl --list-compilers pythonwill list all available Python compilers.The compiler ID can be used with the-c/--compileroption.Compilation and executionIn order to compile, you need to pass the file containing the source code.cexplwill try to figure out the language and its default compiler based on the file extension. You can specify the language and/or the compiler with--langand/or--compileroption, as said above.$ cexpl love.c
.LC0:
        .string "<3"
main:
        push    rbp
        mov     rbp, rsp
        mov     edi, OFFSET FLAT:.LC0
        call    puts
        mov     eax, 0
        pop     rbp
        retThe source code:#include<stdio.h>intmain(){printf("<3\n");return0;}You can pass options to the compiler with the--cflagsoption.Comparing source code and assemblyUse the-C/--compareoption to compare the source code with the assembly:$ cexpl --compare --cflags=-Ofast love.c
.LC0:
        .string "<3"
main:
3 int main() {
        sub     rsp, 8
4 printf("<3\n");
        mov     edi, OFFSET FLAT:.LC0
        call    puts
6 }
        xor     eax, eax
        add     rsp, 8
        retExecutionThe-e/--execoption executes the code:$ cexpl --exec --skip-asm love.c
STDOUT:
<3If you don't want to see the generated assembly, use the-s/--skip-asmoption.Arguments and inputYou can pass a list of arguments with the-a/--argsoption. For example,cexpl --args one two three --exec main.c. The same applies to the--stdinoption:$ cexpl --skip-asm --exec --stdin "Gustavo Costa" 20 -- hi.py
STDOUT:
Gustavo Costa, 20 years oldThe source code:name=input()age=input()print(f'{name},{age}years old')Saving your resultsYou can generate a short link for the compilation with the-L/--linkoption.LicenseCopyright (c) 2022 Gustavo Costa. Distributed under the MIT license.
Package: c-extra
Notice:Since most of the potential users of this tool are French
speaking, the following document is written in French.DescriptionC-Extraest un client non-officiel en ligne de commande pour le système
d’extranet Crypto-Extranet, utilisé par certaines sociétés de gestion de
syndic. Ce client permet de lister et de télécharger les fichiers mis à
disposition dans l’extranet, ainsi que de consulter le solde et
l’historique des appels de fonds. Il gère plusieurs comptes, chaque
compte pouvant être fourni par un syndic différent.Ce projet n’est ni supporté ni affilié en aucune façon à la
plate-forme Crypto-Extranet, à son éditeur ou à aucun des syndics
l’utilisant.DémarrageCréez un fichier~/.config/c-extra/configde la façon suivante:[copro1]syndic=XXX# le XXX dans l'url d'accès https://XXX.crypto-extranet.comlogin=LOGINpassword=PASSWORDIl faut commencer par se connecter au site, avec la commande$c-extraloginSi la connexion réussi, les commandes suivantes sont disponibles:Afficher la liste les documents disponbiles$c-extradocumentsTélécharger les documents disponbiles (dans le répertoire courant)$c-extradownloadAfficher le solde et l’historique des appels de fonds$c-extraaccountVoirUtilisationpour plus de détails.DépendancesModules Python:requeststabulateInstallationLa dernière version publiée peut être installée avec la commande:$pip3installc-extraEn utilisant une archive des sources, il suffit d’utiliser:$pythonsetup.pyinstallUtilisationCommandesToutes les commandes peuvent prendre en argument le nom du compte à
utiliser (copro1dans l’exemple plus haut).Par exemple, pour ne lister que les documents du comptecopro2$c-extradocumentscopro2c-extradocumentsaffiche toujours tous les documents disponibles,
préfixés par le nom du compte.c-extradownloadn’affiche que les nouveaux documents téléchargés.ConfigurationVoici un exemple de configuration avec deux comptes:[appartement1]syndic=XXXlogin=LOGINpassword=PASSWORDdirectory=~/Documents/appartement1[maison]syndic=YYYlogin=LOGINpassword=PASSWORDdisabled=Trueexclude=*SOMETHING*Les documents du compteappartement1seront téléchargés dans le
répertoire indiqué pardirectory.Le comptemaisonest désactivé (disabled = True) c’est à dire
qu’il ne sera pas pris en compte à moins d’être donné explicitement en
argument d’une commande (par exemplec-extradownload maison).Pour le comptemaison, les fichiers correspondants au motif indiqué
parexcludene seront pas téléchargés.TéléchargementsVersion 0.2.2:http://chadok.info/c-extra/c-extra-0.2.2.tar.gzVersion 0.1.0:http://chadok.info/c-extra/c-extra-0.1.0.tar.gzDépôt Git:https://gitlab.com/oschwand/c-extraBugs et commentairesLes bugs doivent être déposés sur lesystème de suivi.LicenceC-Extra is free software, released under the term of the GPLv3+.Copyright 2017 Olivier Schwander <olivier.schwander@chadok.info>
Package: cf2tf
Cloudformation 2 TerraformConvert your Cloudformation templates to Terraform.Report Bug·Request Feature·Table of ContentsAbout The ProjectGetting StartedPrerequisitesInstallationUsageRoadmapContributingContactAcknowledgementsAbout The Projectcf2tfis a CLI tool that attempts to convert Cloudformation to Terraform. We say attempt because it's not really possible to make the conversion with 100% accuracy (currently) because of several reasons mostly around converting a Map value in Cloudformation to thecorrect value in HCL.Getting StartedPrerequisitesCloudformation 2 Terraform requires python >= 3.8Installationcf2tf is available as an easy to install pip package.pipinstallcf2tfIf you are aHomebrewuser, can you install via brew:$ brew install cf2tfUsageTo convert a template to terraform.cf2tfmy_template.yamlThis above command will dump all the terraform resources to stdout. You might want to save the results:cf2tfmy_template.yaml>main.tfIf you prefer to have each resource in its own file then:cf2tfmy_template.yaml-osome_dirIfsome_dirdoesn't exist, then it will be created for you. Then each resource type will be saved to a specific file (variables.tf, outputs.tf etc.).RoadmapBetter conversion of Cloudformation Maps to Terraform (Maps, Block and json)Allow overides for specific resourcesHandle more advanced Cloudformation parameter types like SSM/Secrets managerBetter handling of Recources/Properties that failed conversionOnly download files needed, not entire terraform source code (200MB)See theopen issuesfor a list of proposed features (and known issues).ContributingContributions are what make the open-source community such an amazing place to learn, inspire, and create. Any contributions you make aregreatly appreciated.This project uses poetry to manage dependencies and pre-commit to run formatting, linting and tests. You will need to have both installed to your system as well as python 3.11.Fork the ProjectSetup the environment.
This project uses vscode devcontainer to provide a completly configured development environment. If you are using vscode and have the remote container extension installed, you should be asked to use the devcontainer when you open this project inside of vscode.If you are not using devcontainers then you will need to have python installed. Install thepoetry,nox,nox_poetryandpre-commitpackages. Then runpoetry installandpre-commit installcommands.Most of the steps can be found in theDockerfile.Create your Feature Branch (git checkout -b feature/AmazingFeature)Commit your Changes (git commit -m 'Add some AmazingFeature')Push to the Branch (git push origin feature/AmazingFeature)Open a Pull RequestContactLevi -@shady_cuzAcknowledgementsCloud-Radar- A unit/functional testing framework for Cloudformation templates.cfn_tools from cfn-flip- Used to convert template from yml to python dict.Best-README-Template- The name says it all.
Package: cf3
CF3Fingerprinting censors, one blockpage at a time.WhatThis tool attempts to extract unique features in blockpages in a compact way.❯ for f in corpus/*; do cf3 $f hash; done > hashes
❯ wc -l hashes
136 hashes
❯ uniq hashes | wc -l
135
# almost! but there are two blockpages that are essentially the same :)Installpip3 install cf3Hashcurl -L --silent https://example.com | cf3Verbose❯ cf3 corpus/prod_comodo_securedns_warning.html
title size: 17
meta: 2
script: 2
head size: 2048
body size: 1024
total size: 4096
tag vector summary: 88
tag vector: html,head,title,link,style,meta,meta,body,div,img,div,img,div,button,div,div,h1,h2,p,br,ul,li,a,img,br,br,p,a,div,div,p,script,script

CF3: 17-2-2-33-88-2048-1024-4096
md5: 12c27a55433b1813c02a8a92dd4b3bffDynamic contentThe algorithm tries to be invariant under pages that share a well-defined structure but for which dynamic content, js nonces and other quirks result in highly variable content. YMMV.❯ for i in {1..10}; do curl -L --silent https://youtube.com | cf3; done
9a0edf442a37fbb0fb6e28a122d33e56
9a0edf442a37fbb0fb6e28a122d33e56
9a0edf442a37fbb0fb6e28a122d33e56
9a0edf442a37fbb0fb6e28a122d33e56
9a0edf442a37fbb0fb6e28a122d33e56
9a0edf442a37fbb0fb6e28a122d33e56
9a0edf442a37fbb0fb6e28a122d33e56
9a0edf442a37fbb0fb6e28a122d33e56
9a0edf442a37fbb0fb6e28a122d33e56
9a0edf442a37fbb0fb6e28a122d33e56NotesUnder development! The fingerprinting algorithm might change.LicenseThis code is deposited in the public domain.
Package: cfanalysis
A Combinatorial Fusion Analysis (CFA) to enhance Absorption, Distribution, Metabolism, Excretion, and Toxicity (ADMET) performance of ML models. CFA models show superior performance compared to most of the individual ML models. The CFA model architecture and the performance of CFA models on TDC and other internal datasets is presented on the GitHub repo. Significant enhancement suggests that CFA is a viable tool for improving ADMET ML model performance, offering promise for faster and more cost-effective drug development pipelines. Refer to the GitHub repo for more information on the package:https://github.com/F-LIDM/CFA4DD
Package: cfaster
CFasterCFaster is a tool to easily set all you need to start a contest problem as fast as possible.Get CFasterIf you want to install CFaster all you need ispipfor Python 3 and runningpipinstallcfasterUsageUsage:cfaster[OPTIONS]COMMAND[ARGS]...

Options:-v,--verboseOutputINFOlevellogs.-d,--debugOutputDEBUGlevellogs.--helpShowthismessageandexit.

Commands:scrapeScrapestheproblemandsavesinputsandoutputs.ExampleThis command will scrape the problem from the link and get all the inputs and outputs in.txtfiles.cfasterscrapehttps://codeforces.com/contest/1174/problem/AIn the future we will have acfaster testcommand for running your code, testing the inputs, comparing with the outputs and giving you the results.Getting StartedThese instructions will get you a copy of the project up and running on your local machine for development and testing purposes.PrerequisitesFor the default isolated development environment used by the maintainers you will need:DockerDocker Compose(optional)Make(optional)If you prefer not using Docker feel free to use any other you prefer, but the CI integration will be running with Docker images so this is the best way to replicate the production environment.InstallingThis project usesDockerfor creating the isolated development environment.You can run the Dockerfile build and run the container manually withdockerbuild-tcfaster.
dockerrun-it--rm-v$(pwd):/cfastercfasterbashor you can use Make and docker-compose to easily get everything runningmakedevReading the Makefile shows what each target does.UsingYou will have two options on how to execute from source codepython-mcfasterorpythonsetup.pyinstall
cfasterRunning the testsAutomated testsThe tests for the CFaster are yet to be implemented, the software still in early alpha version.Coding style testsCFaster uses PEP8, for running a verification if your code is according to the rules usepycodestyle .which will recursively run through all files and find any mistakes.For fixing them automatically we useautopep8autopep8-r--diff.# this will show the diff after the fixingautopep8-r--in-place.# and this will fix in place the filesWe recommend always checking the diff first.DeploymentFor now we don't have a deployment pipeline, but in the future it will be automated usingCIandCDdeploying the package topypi.Built WithPython 3- The coding language usedClick- The command line interface packageBeautiful Soup- Used to help scrapping the pages.ContributingIf you want to contribute to the project please readCONTRIBUTINGVersioningWe useSemVerfor versioning. For the versions available, see thetags on this repository.AuthorsVitor Falcão-Starter and main maintainer-vitorfhcAs soon as we get out first contribution we will start the file with contributors.LicenseThis project is licensed under the GPL-3.0 - see theLICENSE.mdfile for details
Package: cfat
# codeforces-auto-testerA simple tool to help you save time during a codeforces contest.Given a contest number it fetches all the testcases and expected output for it. For each problem a new folder is created with sub-folders input/ and output/ which contain the example inputs and outputs respectively.Ask it to test and it will run the program on the sample inputs and check whether your output matches the expected output.NOTE : You can add your own test cases into the folders and that will also be tested happily.Bonus :Keep your template code astemplate.cppin the same folder asmain.pyand it will automatically populate your template for every problem.## See it work
- Download or Clone this repository
- Identify a codeforeces contest number (Need not be a current contest)Eg. 703 (Codeforces Round #365 (Div. 2))- To fetch testcases type :python main.py fetch 703- To test your code for a problem (say A)  :python main.py test A- If multiple answers are possible :python main.py test A multiple## Dependencies
- [Beautiful Soup] (https://www.crummy.com/software/BeautifulSoup/bs4/doc/)## TODO
- [x] Create basic POC for C/C++ code
- [x] Added support for multiple answers
- [ ] Add support for Java and Python
- [ ] Create a command line tool for Mac and Linux
Package: cfb
CfbIO provides access to internal structure of Microsoft Compound File Binary
File Format.Module operates with input file like standard IO module in Python. You can
seek, read and maybe one day write those files, like all other file-like
objects. Also module grants access to internal directory structure containing
Entries, which are also standard readable/seekable objects.So, your work with this module is very simple:from cfb import CfbIO
from cfb.directory.entry import SEEK_END

doc = CfbIO("tests/data/simple.doc")

root = doc.root
print(root.read())  # Read whole root entry buffer

some_entry = doc.directory[1].left
some_entry.seek(100, whence=SEEK_END)
print(some_entry.read(100))  # Read last 100 bytes from left siblingAll classes are lazy, so you can read really big files without memory leaks.
All data will be read only, when you will want it.
Package: cfbc
CFB EncodingCFB (Canonical FlatBuffers) is a restricted variant of FlatBuffers for producing unequivocal transfer syntax.UsageInstall the code geneartor as commane line utility:pip install -U cfbcFirst generate bfbs file from fbs:flatc -b --schema example.fbsThen generate rust files from bfbs:cfbc example.bfbsUse Verifier with flatbuffers rustAdd the generated<name>_generated_verifier.rsto the project in the same
directory with the file<name>_generated.rsgenerated byflatc -r.Add crateflatbuffers-verifieras a dependency in Cargo.toml.Use the same version offlatbuffersas inflatbuffers-verifier.flatbuffers-verifier = { git = "https://github.com/nervosnetwork/cfb" }
flatbuffers = { git = "https://github.com/google/flatbuffers", rev = "4f10da8d99c1a7bc8c9c7d06d2092a689f171d29" }The crateflatbuffers-verifierdefines a functionget_root, which is intended to replace the
function with the same name inflatbuffers. This function will verify the
buffer, and returns aResultto indicate whether the buffer is valid.
Package: cfbd-json-py
cfbd-json-pyAllows users to access the CFBD API, and get the resulting data in either a dictionary (think JSON), or in a pandas DataFrame (think spreadsheet).How to InstallThis package is is available through thepippackage manager, and can be installed through one of the following commands in your terminal/shell:pip install cfbd_json_pyORpython -m pip install cfbd_json_pyIf you are using a Linux/Mac instance, you may need to specifypython3when installing.python3 -m pip install cfbd_json_pyAlternatively,cfbd-json-pycan be installed from this GitHub repository with the following command through pip:pip install git+https://github.com/armstjc/cfbd-json-pyORpython -m pip install git+https://github.com/armstjc/cfbd-json-pyORpython3 -m pip install git+https://github.com/armstjc/cfbd-json-pyProject StausYou can view the status of the projectby clicking on this link. It will be updated periodically as more features are implemented into this python package.Bugs/IssuesIf you find an issue/bug while using this python package,please feel free to raise an issue, we're only human, and there will inevitably be issues found!DocsFor the cfbd-json-py docs, they can be found atarmstjc.github.io/cfbd-json-py/
Package: cfbfastR-py
cfbfastR-pySeeCHANGELOG.mdfor details.The goal ofcfbfastR-pyis to provide the community with a python package for working with American Football data as a companion to thecfbfastRR package. Beyond data aggregation and tidying ease, one of the multitude of services thatcfbfastR-pyprovides is for benchmarking open-source expected points and win probability metrics.InstallationcfbfastR-py can be installed via pip:pipinstallcfbfastR-pyor from the repo (which may at times be more up to date):gitclonehttps://github.com/saiemgilani/cfbfastR-pycdcfbfastR-py
pipinstall-e.Our AuthorsSaiem GilaniCitationsTo cite thecfbfastR-pyPython package in publications, use:BibTex Citation@misc{saiemgilani2021cfbfastRpy,author={Gilani, Saiem},title={cfbfastR-py: The SportsDataverse's Python Package for American Football Data.},url={https://cfbfastR-py.sportsdataverse.org},season={2021}}
Package: cfblog
What is cfblog?It is a blog engine with a peculiar CMS feature, that allows very complex
content to be easily created.Installation$pipinstallcfblogContributorsAmit Upadhyay (https://github.com/amitu)Vinay Karanam (https://github.com/vinayinvicible)ChangeLoghttps://github.com/Coverfox/cfblog/blob/master/ChangeLog.rstLICENSEBSD
Package: cfbm
CHIME/FRB Beam ModelModels describing the primary and formed beams for for Canadian Hydrogen Intensity Mapping Experiment FRB backend (CHIME/FRB).InstallationThe package can be installed from PyPI using the following command:pip install cfbmTo use the primary beam model, data for the beam must be downloaded after installation by:Either running the scriptcfbm/bm_data/get_data.py.Or from within python:from cfbm.bm_data import get_data
get_data.main()DocumentationCheck out the user documentation,here
Package: cf_buildpack_dashboard
# CF Buildpack Dashboard## DependenciesIn order to run this application you need the [cf-light-api](https://github.com/SpringerPE/cf-light-api) running ata known endpoint.Each `cf-light-api` endpoint needs to be provided as a value by populating the `CF_BUILDPACK_DASHBOARD_ENVIRONMENT` envvariable.## ConfigurationThe `cf_buildpack_dashboard` application accepts the following configuration parameters passedby env variables:- `CF_BUILDPACK_DASHBOARD_ENVIRONMENT`: a json dictionary mapping different environments to their api endpoints. For example ```{"test": "http://cf-light-api-test.example.com", "prod": "https:cf-light-api-prod.example.com"}```- `PORT`: the port to which the application binds. If running in Cloudfoundry it will be provided by the platform.## Building for pipTo build the `tar.gz` pip package simply run: ```python setup.py sdist```from the project root directory.## Installing and Running### Pip installYou can install the application from `pypi.org` by running `pip install cf_buildpack_dashboard`. This will install anexecutable script that you can call directly `cf_buildpack_dashboard`### Cloudfoundry manifestYou can target as well a Cloudfoundry installation by providing a manifest as in the following example:```applications:- name: cf-buildpack-dashboardinstances: 1memory: 256MBcommand: ./run_app.pyenv:CF_BUILDPACK_DASHBOARD_ENVIRONMENTS: '{"test": "https://cf-api.test.example.com","dev": "https://cf-api.dev.example.com","live": "https://cf-api.live.example.com"}'```and push with `cf push`### Provided scriptThe application can also be run as a simple python application by installing therequirements and using the provided `run_app.py` script.## Running the tests```nosetests -s```
Package: cfc-barpy
This is Python a port of barby library written in Ruby. I couldn’t find
lightweight Python barcode generation library of the same caliber asbarby(elaphe is broken and others don’t support GS1-128andQRCode at the same
time, so I portedbarby).API is basicly the same as ofbarby, but in Python style.The port is very quick and not complete at the moment (I ported only parts
I really need for my project), I will port the rest eventually.Also the port is quite direct, in a sense there are a lot of places in Python
code which have more Rubyish flavour instead of Pythonian (e.g. a lot of@propertydecorators to call methods without parenthesis). I did it to avoid
logic errors during porting process, I will make code more Pythonian in the
future.See also:[barby]:http://toreto.re/barby/[elaphe]:http://code.google.com/p/elaphe/
Package: cfcf
cfcfcollision-free cache folderThis library creates a cache file for a remote resource or a file need additional processing.
The cache will be duplicated, if an another process is creating the files.
If the cache file already created, an interface will return the file path.
This excluding concurrent writing feature makes to avoid the collision.Installationpip install cfcfUsageFollowing example running on '/tmp'handle multiple files (directory mode)import cfcf

def your_cache_getting_impl(arg1, arg2):
    print(arg1)
    import os
    print(os.getcwd())
    print(arg2)

print('#1# ', cfcf.get_dir('cache_name', your_cache_getting_impl, 'arg1', 'arg2'))
print('#2# ', cfcf.get_dir('cache_name', your_cache_getting_impl, 'arg1', 'arg2'))arg1
/tmp/cache_name/01HGAJ22W2DZDCSC23V1A8RT20
arg2
#1#  /tmp/cache_name/01HGAJ22W2DZDCSC23V1A8RT20
#2#  /tmp/cache_name/01HGAJ22W2DZDCSC23V1A8RT20handle a single file (file mode)import cfcf

def your_cache_getting_impl(filename):
    import os
    print('Put a file in this dir. and return the path', os.getcwd())
    import pathlib
    path = pathlib.Path(filename)
    path.touch()
    return path

print('#1# ', cfcf.get_file('cache_name2', your_cache_getting_impl, 'filename.txt'))
print('#2# ', cfcf.get_file('cache_name2', your_cache_getting_impl, 'filename.txt'))Put a file in this dir. and return the path /tmp/cache_name2/01HGAK6QQ516P2536QM38PFZ8M
#1#  /tmp/cache_name2/01HGAK6QQ516P2536QM38PFZ8M/cache_name2
#2#  /tmp/cache_name2/01HGAK6QQ516P2536QM38PFZ8M/cache_name2handle a dict (object mode)import cfcf

def your_cache_getting_impl(arg1, arg2):
    return {'arg1':arg1, 'arg2':arg2}

print('#1# ', cfcf.get_object('cache_name3', your_cache_getting_impl, 'arg1.1', 'arg2.1'))
print('#2# ', cfcf.get_object('cache_name3', your_cache_getting_impl, 'arg1.2', 'arg2.2'))#1#  {'arg1': 'arg1.1', 'arg2': 'arg2.1'}
#2#  {'arg1': 'arg1.1', 'arg2': 'arg2.1'}