Saravanan666/pypi-org huggingface dataset:
Package: calysto_chatbot
You can install Calysto Chatbot with Python:` pip install--upgradecalysto_chatbot `or in the system kernel folder with:` sudo pip install--upgradecalysto_chatbot `Use it in the console, qtconsole, or notebook with IPython:` ipython console--kernelcalysto_chatbot ipython qtconsole--kernelcalysto_chatbot ipython notebook `Requires:aimlipython-3.0Python2 or Python3metakernel (installed automatically)
Package: calysto-hy
# Calysto HyCalysto Hy is a Hy kernel for Jupyter based on [Metakernel](https://github.com/Calysto/metakernel). [Hy is a language](https://github.com/hylang/hy) that converts Lisp-like syntax to Python semantics.This kernel is based on [bollwyvl/hy_kernel/](https://github.com/bollwyvl/hy_kernel/) That kernel treats Hy as a Python preprocessor, and can therefore use the standard IPython tools. Calysto Hy treats Hy as a full language. Because of this, it uses the MetaKernel to gain magics, shell, parallel processing, etc.## InstallIf you want to enjoy full code completion by [kaschalk/jedhy](https://github.com/ekaschalk/jedhy) you have
use bleeding edge and install hy master (> 0.13.1), jedhy and toolz first because jedhy is using new hy syntax.
Otherwise calysto_hy falls back to is normal completion.`shell pip3 installgit+https://github.com/ekaschalk/jedhy.gitpip3 installgit+https://github.com/Calysto/calysto_hy.gitpython3-mcalysto_hy install `If installing into the system, you may want to:`shell sudo pip3 installgit+https://github.com/ekaschalk/jedhy.gitsudo pip3 installgit+https://github.com/Calysto/calysto_hy.gitsudo python3-mcalysto_hy install `Or into your personal space:`shell pip3 installgit+https://github.com/ekaschalk/jedhy.git--userpip3 installgit+https://github.com/Calysto/calysto_hy.git--userpython3-mcalysto_hy install--user`Or into a virtualenv, when it is already activated:`shell pip3 installgit+https://github.com/ekaschalk/jedhy.gitpip3 installgit+https://github.com/Calysto/calysto_hy.gitpython3-mcalysto_hy install--sys-prefix`## Use`shell jupyter console--kernelcalysto_hy `You can use Calysto Hy in Jupyter notebook by selecting the “Calysto Hy” kernel. See example [notebooks](https://github.com/Calysto/calysto_hy/tree/master/notebooks).
Package: calysto_lc3
# calysto_lc3Calysto Little Computer - LC3 Assembly Language for JupyterAn Jupyter kernel for LC3This requires IPython 3.To install::pip install calysto_lc3python -m calysto_lc3.installTo use it, run one of:* ipython notebook* In the notebook interface, select 'Calysto LC3' from the 'New' menu* ipython qtconsole --kernel calysto_lc3* ipython console --kernel calysto_lc3Typing `?` to the kernel gives:```This is the Calysto LC3 Jupyter kernel.LC3 Interactive Magic Directives:%bp [clear | SUSPENDHEX]           - show, clear, or set breakpoints%cont                              - continue running%dis [STARTHEX [STOPHEX]]          - dump memory as program%dump [STARTHEX [STOPHEX]]         - list memory in hex%exe                               - execute the program%mem HEXLOCATION HEXVALUE          - set memory%pc HEXVALUE                       - set PC%reg REG HEXVALUE                  - set register REG to HEXVALUE%regs                              - show registers%reset                             - reset LC3 to start state%step                              - execute the next instruction, increment PCHEX values begin with an 'x' and are composed of 4 0-F digits or letters.```Additional help is available with `%help ITEM` such as `%help pc`.
Package: calysto_processing
**Calysto Processing** is the merging of [ProcessingJS](http://processingjs.org/) with [Project Jupyter](http://jupyter.org/) (aka IPython). Processing Sketches are entered into Jupyter notebook cells, and even run in rendered notebooks. Sketches can be paused, and stepped one draw() at a time.Because Calysto Processing uses [MetaKernel](https://github.com/Calysto/metakernel/blob/master/README.rst), it has a fully-supported set of "magics"---meta-commands for additional functionality. A list of magics can be seen at [MetaKernel Magics](https://github.com/Calysto/metakernel/blob/master/metakernel/magics/README.md).Calysto Processing in use:* [CS110: Introduction to Computing](http://jupyter.cs.brynmawr.edu/hub/dblank/public/CS110%20Intro%20to%20Computing/2015/Syllabus.ipynb)* [Video](https://www.youtube.com/watch?v=V4TzARh-ClY)You can install Calysto Processing with:```pip install --upgrade calysto-processing```or in the system kernels with:```sudo pip install --upgrade calysto-processing```Next, install Processing 2 from https://processing.org/download/You will need to make sure that you have installed and access to the `processing_java` command. Mac users will need to install it from Processing by selecting 'Install "processing_java"' under the Tools menu.Finally, edit the installed `calysto_processing/kernel.js` to include the full path to the `processing_java` command. That might look like:```javascript{"argv":["/usr/bin/python3","-m", "calysto_processing","-f", "{connection_file}"],"display_name": "Calysto Processing","env": {"PROCESSING_JAVA": "/home/dblank/Desktop/processing-2.2.1/processing-java"},"language": "java","name": "calysto_processing"}```Use it in the notebook with:```ipython notebook```and then select `Calysto Processing` for a new notebook.Calysto Processing also has an enhancement: Tables, and some related functions:```java/* @pjs includeTable="true"; */Table table;void setup() {table = loadTable("test.csv", "header");println(table.getRowCount() + " total rows in table");}long findMax() {int retval = 0;for (TableRow row : table.rows()) {int pop = row.getInt("Population");if (pop > retval)retval = pop;}return retval;}```Table-related classes and methods:* loadTable(CSV_FILNAME, "header");* Table class* TableRow class* table.rows() - returns iterator for use with for(TableRow row : table.rows()) {...}* row.getInt(COLUMN_NAME)* row.getString(COLUMN_NAME)* row.getFloat(COLUMN_NAME)See source for more details.Example notebooks can be found in https://github.com/Calysto/calysto_processing/tree/master/notebooksRequires:* ipython-3.0* Python2 or Python3* metakernel (installed with pip)* calysto (installed with pip)Calysto Processing supports:* MetaKernel Magics* All of ProcessingJS, plus pause/restart and stepper
Package: calysto_prolog
**Calysto Prolog**Because **Calysto Prolog** uses [MetaKernel](https://github.com/Calysto/metakernel/blob/master/README.rst), it has a fully-supported set of "magics"---meta-commands for additional functionality. See all of the [MetaKernel Magics](https://github.com/Calysto/metakernel/blob/master/metakernel/magics/README.md).## InstallationYou can install Calysto Prolog in two steps:```pip3 install --upgrade calysto_prolog```OR in the system kernel folder with:```sudo pip3 install --upgrade calysto_prolog```Then, you need to install the kernelspec:```python3 -m calysto_prolog install```Add `--user` to the above commands to put in your private environment.## UseUse Calysto Prolog in the console, qtconsole, or notebook:```jupyter console --kernel calysto_prologjupyter qtconsole --kernel calysto_prologjupyter notebook --kernel calysto_prolog```### Example Facts```child(stephanie).child(thad).mother_child(trude, sally).father_child(tom, sally).father_child(tom, erica).father_child(mike, tom).sibling(X, Y)      :- parent_child(Z, X), parent_child(Z, Y).parent_child(X, Y) :- father_child(X, Y).parent_child(X, Y) :- mother_child(X, Y).```### Example Queries```child(NAME)?sibling(sally, erica)?father_child(Father, Child)?```## Requires* Jupyter* Python2 or Python3* metakernel (installed automatically)
Package: cam2file
cam2fileSave the document in real world as the file using webcam.Installation% python -m pip install cam2fileUsageImport packageimportcam2fileasc2fCapture paperfromcam2fileimporthandle_imagepath='./result.png'handle_image(path)# Image will be saved on the pathGet the paper frame in the codefromcam2fileimportcapturePaperimportcv2res=capturePaper()# Return frame of paper imagecv2.imshow('Result',res)cv2.waitKey()cv2.destroyAllWindows()When you callcapturePaper(), The webcam will be activated as below:If the paper is detected, Yellow border indicates it. Pressathen it will be captured.
The result is transformed as A4 size, so it can be distorted if you capture paper which size is not A4.capturePaper('x')capturePaper(ok_key='x')# same as aboveIf you want to change the confirm key, pass a character as an argumentok_key.Referencesvyom_garg, "Python | Detect Polygons in an Image using OpenCV", GeeksforGeeks, 19. 10. 13.,https://www.geeksforgeeks.org/python-detect-polygons-in-an-image-using-opencv/, 22. 12. 04.Daehee Yun, "Python OpenCV 강좌 : 제 21강 - 윤곽선 검출", Daehee YUN Tech Blog, 19. 02. 09.,https://076923.github.io/posts/Python-opencv-21/, 22. 12. 04.KIDO, "Python Package 생성 및 배포하기", DEVOCEAN, 22. 01. 12.,https://devocean.sk.com/blog/techBoardDetail.do?ID=163566, 22. 12. 13.
Package: camanager
CAManager stands for Certificate Authority Manager. With to this tool, you can :list and view the metadata of all your certificatesgenerate a new certificatesign a Certificate Signing Requestexport a certificate in PEM or PCKS#12 format (.p12)renew a certificatemake a backup or a restore of the CA vaultInstallationpip3 install camanagerSecurityIf you generate a certificate with the tool, the private key is kept in the vaultThe vault is a SQLite3 DB, all private keys are encrypted with AES-256. The master key is encrypted with a derived password of the user (PBKDF2-SHA512)Passwords are requested via secure inputNo network communicationInitial setup for the first usageThis tool doesn't generate the Certificate Authority. You must already have one or generate a new one
(step by step guide).Once you have the Certificate Authority private and public keys, runcamanager setup:$ python -m camanager setup
Enter the password that will be used to encrypt the CA vault : [secure input, nothing will appear]
Confirm it : [same]
Paste your CA certificate in PEM format :
[paste here]
Paste your CA key in PEM format :
[paste here]
The vault has been successfully created.The tool verifies that the keys match. If the private key is encrypted using a passphrase, you will be prompted for it.The vault is saved in the "ca.vault" file of the directory you are in. You must therefore runcamanagereach time
from the same directory if you want to use the same vault.UsageYou can still provide information via arguments. If information is missing, an interactive prompt will occur.Backup the vaultpython -m camanager backupRestore a backup vaultpython -m camanager restoreList certificatespython -m camanager [--all | --soon-expired]--all: show also the revoked/expired/renewed certificates--soon-expired: show only soon expired (less than 1 month) certificatesGenerate a new certificateWarning :normally, a certificate is generated on the server and a Certificate Signing Request is generated for
the CA.python -m camanager --newcert [--cn CN] [--san SAN] [--keysize <1024|2048|4096>] [--hash <sha1|sha256|sha512>]--cn: the Command Name--san: the Subject Alternative Name--keysize: the keysize : 2014, 2048 or 4096--hash: the hash algorithm : sha1, sha256 or sha512Sign a CSRpython -m camanager --sign [--cn CN] [--san SAN] [csr_file]--cn: the overridden Command Name--san: the overridden  Subject Alternative Namecsr_file: the Certificate Signin Request fileExportpython -m camanager --export --pem|--p12 [--out output_file] [certificate CN or ID]--pemor--p12: the output format--out: the output filecertificate CN or ID: the Common Name or certificate ID that you want to export
Package: camaraPy
camaraPyO pacote camaraPy é um wrapper, ainda em estágio inicial de desenvolvimento, para as APIs daCâmara dos Deputados.Agora, em vez de montar a requisição manualmente usando pacotes comourrlibourequests, você pode simplesmente instalar ocamaraPye fazer tudo em poucas linhas de código:from camaraPy.api_original import proposicoes

# Define parâmetros para a consulta
params = {
    "Tipo"   : "PEC",
    "Numero" : "666",
    "Ano"    : "2019"
}

# Acessa as votações da proposta
dados = proposicoes.ObterVotacaoProposicao(params)Por enquanto, o módulo funciona apenas com aAPI original, que é mais estável e inclui o resultado das votações em plenário, dado que ainda não está disponível no novo serviço.Como usar?Todas as requsições descritas nadocumentação da Câmaraforam implementadas, exatamente com a mesma grafia. O nome dos webservices, porém, é grafado seguindo um padrãolowercase_com_underlines.Assim, para acessar o métodoListarDiscursosPlenariodo WebserviceSessoesReunioes, o usuário precisa executar o seguinte código, no qual a variávelparamsé um dicionário com os parâmetros que deseja passar para a requisição.from camaraPy.api_original import sessoes_reunioes

params = { "DataIni" : "10/10/2018", "DataFim" : "13/10/2018" }
dados = sessoes_reunioes.ListarDiscursosPlenario(params)De maneira semelhante, para acessar o métodoObterDeputadosdo WebserviceDeputados, o código seria o seguinte:from camaraPy.api_original import deputados

dados = deputados.ObterDeputados()Os dados já vêm parseados em um dicionário no estilo JSON, embora a API retorne os valores em formato XML. Isso é possível porque ocamaraPyusa o fenomenal pacotexmltodictpara fazer a conversão. :heart:OcamaraPyfunciona só para o Python 3.6 ou superior.Como instalar?pip install camaraPy✨Coisas técnicas:O código consiste, basicamente, em um script genérico que faz solicitações variadas para a API. Ele está disponível no diretóriocore. A partir desse programa, foram criadas funções encapsuladoras emdeputados.py,orgaos.py,sessoes_reunioes.pyevotacoes.py. Elas apenas chamam as funções definidas emcore.pycom os parâmetros corretos.
Package: camazing
camazingEasy-to-use machine vision library for GenICam-compliant cameras.FeaturesFully Pythonic operation (no messing with C structures)Data acquisition (with rich metadata for scientific use cases)Advanced camera setting control (including saving and loading settings, proper checks for valid values, etc.)Free software (MIT licensed)Getting startedSee the documentation athttps://camazing.readthedocs.io.
Package: camazotz
camazotzC code in Python codeintroductionCamazotz compiles and loads C code in Python code. Specifically, it
enables insertion of C code directly into Python files, which can be
dynamically linked and called via ctypes.setuppipinstallcamazotzusageexportCC="gcc"importcamazotzlibrary=camazotz.C("""
    #include <stdio.h>

    int factorial(int x){
        int result = 1;
        while (x > 1){
            result *= x;
            x--;
        }

        return result;
    }
    """)function_factorial=library["factorial"]print("5! =",function_factorial(5))print("4! =",function_factorial(4))
Package: camb
CAMB:Code for Anisotropies in the Microwave BackgroundAuthor:Antony Lewis and Anthony ChallinorHomepage:https://camb.info/DescriptionCAMB is a cosmology code for calculating cosmological observables, including
CMB, lensing, source count and 21cm angular power spectra, matter power spectra, transfer functions
and background evolution. The code is in Python, with numerical code implemented in fast modern Fortran.See theCAMB python example notebookfor a
quick introduction to how to use the CAMB Python package.To install the CAMB python package on your computer run:pip install camb [--user]The –user is optional and only required if you don’t have write permission to your main python installation.
You will need gfortran 6 or higher installed to compile. Binary files for Windows are also provided, so these are used instead if no
gfortran installation is found on Windows machines.The python wrapper provides a module called “camb” documented in the PythonCAMB documentation.
Package: cambak
CamBakThis small tool automate the derushing process of your SD Cards for all your
cameras.CamBak sort all your files from your SD Card per date, camera and per type of
media and copy it to your computer or on a network volume. Here's is the
destination architecture:/ *destination_folder*
├── *date_of_shots (example: 2020-02-13)*
│   └── *camera_name*
│       ├── Pictures
│       ├── RAW
│       └── VideosSupported cameras architecturesSony (tested with NEX6 and HDR-AS series, a6400 and AS100V)If a camera is not supported, you can create a new file on thecamerasfolder with the brand name, add a class inherited ofCameraand add each
paths and extensions for each type of medias (glog can be used for paths).Here's is an example for Sony NEX cameras (fileSony.py):classSonyNex(Camera):"""General support for Sony NEX cameras (Alpha 5, 6, 7 and 9)"""img_folders=["DCIM/*MSDCF"]raw_folders=img_foldersvid_folders=["PRIVATE/M4ROOT/CLIP"]img_extensions=[".JPG"]raw_extensions=[".ARW"]vid_extensions=[".MP4"]Usage➜ python cambak --help
usage: cambak [-h] -t TYPE -n NAME [-f] src dest

positional arguments:
  src                   Source folder (mounted card/usb camera volume)
  dest                  Destination folder (local, network volume)

optional arguments:
  -h, --help            show this help message and exit
  -t TYPE, --type TYPE  Type of camera
  -n NAME, --name NAME  Name of the camera
  -f, --force           Override if file already exists in the dest folderExample:cambak/mnt/sd-card/mnt/moon-smb/cam-backups-tSonyNex-nA6400InstallationWIP
Package: cambd
cambdCambridge dictionarycli appFeaturesAutosuggest related words on typo.Interactive suggestion menu to select words from in the above case.Handles past and past-particle words. Returns the original word definition.No API/database involved.A Persistent caching mechanism. This avoids looking up already searched words; hence fast results.Uses python's integratedsqlite3for maintaning a persistent cache.InstallationpipinstallcambdUsageUsage:cambd[OPTIONS]WORD

Options:-a,--show-allShowallthedefinitionsofaword.-d,--dictionaryTEXTDeterminewhichdictionaryregiontouse(uk,us)[default:uk]-v,--verboseShowextrawordinfoie,wordcodes&labels.[ex:A2informal]-c,--clear-cacheClearallthestoredcachefromsystem.--versionShowtheversionandexit.--helpShowthismessageandexit.By default it caches words in$HOME/.cambd-cache.db. To clear the cache if neededruncambd --clear-cache. It is strongly recommended to not modify this file manually.LICENSEMITLicense ©Rocktim Saikia2022
Package: cambio
cambioChange Python Source Code Filesmethodsremove_commentsremove_importsdeclare_variablereplace_classreplace_variable_declarationremove_class_instantiation_parameteradd_param_to_class_instantiationremove_class_definitionusageRemove Commentsfromcambioimportremove_commentswithopen("example.py")asf:text=f.read()text=remove_comments(text)withopen("example_without_comments.py","w")asf:f.write(text)cambioexample.pyremove-commentsRemove Importsfromcambioimportremove_importswithopen("example.py")asf:text=f.read()text=remove_imports(text)withopen("example_without_imports.py","w")asf:f.write(text)cambioexample.pyremove-importsDeclare Variablefromcambioimportdeclare_variablefromdjango.utils.cryptimportget_random_stringwithopen("settings.py")asf:text=f.read()text=declare_variable(text,"SECRET_KEY",get_random_string())withopen("settings.py","w")asf:f.write(text)cambiosettings.pydeclare-variable"SECRET_KEY""$(uuidgen)"Replace Classfromcambioimportreplace_classcode="my_fruit = Apple()"new_code=replace_class(code,"Apple","Orange")print(new_code)# my_smoothie = Orange()cambiojuicer.pyreplace-class"Apple""Orange"Replace Variable Declarationfromcambioimportreplace_variable_declarationcode="HTTP_ORIGIN = 'http://localhost:8000'"new_code=replace_variable_declaration('HTTP_ORIGIN','http://localhost:4200')print(new_code)# HTTP_ORIGIN = 'http://localhost:4200'cambiosettings.pyreplace-declaration'HTTP_ORIGIN''http://localhost:4200'Remove Class Instantiation Parameterfromcambioimportremove_class_instantiation_parameterold_code="my_drink = Wine(age=100)"new_code=remove_class_instantiation_parameter(old_code,'Wine','age')print(new_code)# my_drink = Wine()cambiosettings.pyConditionally Remove Class Instantiation Parameterfromcambioimportremove_class_instantiation_parameterold_code="bottle_1 = Wine(age=100)\nbottle_2 = Wine(age=1)"# removes all bottles under 10 years of agenew_code=remove_class_instantiation_parameter(old_code,'Wine','age',lambdaage:age<10)print(new_code)# bottle_1 = Wine(age=100)\ncambiosettings.pyAdd Parameter to Class Instantiationfromcambioimportadd_param_to_class_instantiationold_code="[Food(type='Cereal')\n, Fruit(type='Cheese')]"defget_expiration(instantiation):text=instantiation['text']if'Cereal'intext:return10elif'Cheese'intext:return1# age cars by one yearadd_param_to_class_instantiation(old_code,"Fruit","expiration",get_expiration)Remove Class Definitionfromcambioimportremove_class_definitionold_code='''class OldCar():a = 1b = 2class NewCar():a = 1b = 2'''new_code=remove_class_definition(old_code,"OldCar")cambioexample.pyremove-class-definition'OldCar'TestingTo test the package runpython3 -m unittest cambio.tests.testSupportContact the Library Author, Daniel J. Dufour, or post an issue athttps://github.com/danieljdufour/cambio/issues
Package: cambot
CamBot is a Slack bot for viewing snapshots from a UniFi Video Camera System.
It utilizes the NVR API interface to query and retrieve stills from cameras.To start, you’ll need to create an API key on the NVR, and a Slack API Token.UsageRun the bot:export NVR_URL='https://172.17.0.1:7443'
export NVR_API_KEY='XXXX'
export SLACKBOT_API_TOKEN='xoxb-XXXX-XXXX'
cambotInstallationYou’ll need to create a Slack Bot and create a Slack Bot API Token, then:pip install cambotSourceGithub:https://github.com/ampledata/cambotAuthorGreg Albrechtoss@undef.nethttp://ampledata.org/CopyrightCopyright 2017 Greg AlbrechtLicenseApache License, Version 2.0. See LICENSE for details.
Package: cambriantools
Cambrian Tools 🔧InstallationTo install the package run the following script:pipinstallcambriantoolsHow to useTo executemaster_run.shjust run the following command in the terminal:bashmaster_run.shDataPublic data:https://drive.google.com/drive/folders/19q3OVxoATB-UaoIsvjp07su9Uy2XJQnT?usp=sharingReferenceshttps://github.com/oscarpimentel/fuzzy-tools
Package: cambridict
Cambridge DictionarySearch the meaning of the word from Cambridge Dictionary online, and get the result in JSON formatInstallationYou can install thecambridictfrom PyPI:pip install cambridictHow to useimportjsonfromcambridictimportCambridged=Cambridge('EV')word='take'data=d.search(word)result='{0}.json'.format(word)withopen(result,'w')asfp:json.dump(data,fp,indent=4)Sample outputtake.jsonSupported dictionariesNameDictionaryEEEnglishEVEnglish-Vietnamese
Package: cambrinary
UsageFrom PyPI:pip3 install cambrinaryLook up 'hello' for example:cambrinary -w hellomulti-languages supportin chinese(traditional)cambrinary -w world -t chineseSupported language listenglishfrenchgermanchinesejapaneseitalianrussiankoreanmulti-words supportpowered by coroutine, support as many as words you like,cambrinary -w hello wordorcambrinary -w hello word -t chineseeven or morecambrinary -w one two three four five -t frenchSupport phrasecambrinary -w kick-offorcambrinary -w kick-off -t japaneseCustomize your color schemeYour cambrinary, you design.Useconf.jsonto customize the color scheme, for instance,
settingpronunciation,definitionorexample_sentenceas you like. They could be inboldformat,blueforeground  andblackbackground, or any supported format and colors.
All supported color please refer tocolor_const.py.For develop modeYou can change and test locally by, git clone the repo,cdin the repo folder, run:python3 -m venv venv
source venv/bin/activate
pip3 install .  (try `curl https://bootstrap.pypa.io/get-pip.py | python3` to update pip3 if any error)
# and then
cambrinary -w worldOnce you change the code, re-runpip3 install .Loglogs is written into~/.local/share/cambrinary/dict.login the append way.Road mapmore development plan, please refer toWikiHelpcambrinary --help