Saravanan666/pypi-org huggingface dataset:
Package: bpy-optix
blenderpyBlender as a python module with easy-installAboutMeant for installation into a virtualenv or wherever, for unit testing of Blender extensions being authored, or developement of a Blender 3d-enabled Python application.Depends upon thebpy-buildmodule to make sure the Blenderbpymodule environment is correct.For more information, please see:bpy-build repositoryGetting StartedPrebuilt wheels are provided for popular Platforms (MacOS, Windows, and Ubuntu). Prebuilds include "normal" installation (bpy), CUDA (bpy-cuda) and Optix (bpy-optix). Choosing the correct version depends on your use-case and hardware but in generalbpyshould be just fine for non-rendering automation tasks whilebpy-optixhas the best performance but requires a NVIDIA RTX Card and up to date drivers.InstallingInstalling a prebuilt on these platforms is simple.pip install bpy && bpy_post_installSelf BuildingBuilding the Blender API for your own platform can be difficult, however this repo should make it easy enough for you to create your own builds by hand.Build fromsdistYou can build from a source distribution usingpip.PrerequisitesPerforming a build fromsdistrequires at least the prerequisites for building Blender. See the wiki forthe list of prerequisite applications.Windowspy-3.7-64-mpipinstall--upgradepipwheelfuture-fstringsOtherpython3.7-mpipinstall--upgradepipwheelfuture-fstringsBuildWindowspy-3.7-64-mpipinstallbpy--no-binaryOtherpython3.7-mpipinstallbpy--no-binaryBuild from repoYou can also build after cloning the repository, this is helpful during development.Prerequisitespython3-mpipinstall--upgradepipwheelfuture-fstrings
gitclonehttps://github.com/TylerGubala/blenderpy.gitBuildIf you have a specific version ofbpyyou want, you have to change theVERSIONstring at the beginning of thebpy_<optional extra>_setup.pyfile.To build, run the below command.Windowspy bpy_setup.py sdist bdist_wheelOtherpython3 bpy_setup.py sdist bdist_wheelThe resultant wheel in the dist folder can be installed using pip.Post any errors you have as an issue.FAQQ. I am gettingfailed to find 'bpy_types' moduleA. Please seeissue #13Q. I am gettingImportError: DLL load failed: The specified module could not be foundA. Please seeissue #15Q. How do I import addons?A. Addons (Blender internal and third party) can be imported using the codereferenced here.Q. How can I use Blender inmultiprocessing?A. Blender runtime usage and compatibility withmultiprocessingis limited, seethe documentation.Q. What about my operating system of choice?A.MacOS support is on its way. After that is Ubuntu.Q. What about my Python version of choice?A. Some builds you will have to make yourself if you have a specific version of the API you want. Likewise, if you are contrained to a specific Python version (especially those that aren't shipped by python.org) then you may have to try and build yourself.GotchasI have not tested this for platforms other than Windows Python 3.6.x at the moment. More to come soon.
Package: bpyshell
pyshellA Shell class to exectue shell commands as object methods.Installpip install bpyshellHow to useImportfrompyshell.coreimport*Create a shell objectsh=Shell()Call shell commands as object methodsprint(sh.ls())00_core.ipynb
autocomplete.png
bpyshell
bpyshell.egg-info
build
conda
CONTRIBUTING.md
dist
docker-compose.yml
docs
env
index.ipynb
LICENSE
Makefile
MANIFEST.in
manpage.png
pyshell
pyshell.egg-info
README.md
settings.ini
setup.pyUse theflagskwarg for single dash argumentsprint(sh.ls('.giti*',flags='a')).gitignoreUse kwargs for double dash argumentsprint(sh.du('.',max_depth=0))361548	.You can use tab to autocomplete:If there is a man page, it becomes the method's docstringLimitationsEach command is executed as a different process.
Package: bpystubgen
BPY Stub GeneratorA utility to generate PythonAPI stubsfrom
documentation files inreStructuredTextformat.IntroductionThe main usage of the program is to create Python API stubs from the documentation generated
during the build process ofBlenderorUPBGEso that an IDE can provide autocompletion support and type hints for relevant modules likebpyorbge.There are already a number of tools created with a similar goal in mind, notablyfake-bpy-modulewhich can be a good alternative
to this project.However,bpystubgenhas a few advantages over the others:It's very fast - Some of those tools may take over an hour to generate the entire stubs
for Blender. Butbpystubgencan do it under a minute (1,593 source documents).The generated stub modules preserve most of the source documentation, so you can use them
as a manual as well.It generatesPEP-561compliant stub modules, so it's safe to include them in your runtime
module path.Along with its fast execution speed, the project also provides well-organised API and test
suites to make it easier to fix bugs or improve the output quality.ScreenshotsAuto-completion at work in PyCharm:Pop-up documentation support in VSCode:InstallationThe library can be installed usingpipas follows:$pipinstallbpystubgenUsageGenerating StubsIf you want to generate the API stubs yourself, you can usebpystubgenmodule which
can be invoked with the following options:$python-mbpystubgen-h

usage:bpystubgen[-h][--verbose][--quiet]inputoutput

GeneratePythonAPIstubsfromBlenderdocumentation.

positionalarguments:inputSourcedirectorywhere*.rstfilesarelocatedoutputOutputdirectorywheregeneratedmoduleswillbesaved

optionalarguments:-h,--helpshowthishelpmessageandexit--verbosePrintdebugmessages--quietPrintonlyerrormessagesUsing StubsIf you just want to use the API stubs, you can install them from PyPI without having to generate
them yourself.There are two variants of the API stubs, one for Blender and the other for UPBGE. For Blender,
you can installblender-stubsmodule with an appropriate version qualifier as follows:$pipinstallblender-stubs==3.1.*This will install the latest module for Blender 3.1, and for now stubs are provided for Blender
2.80 and onwards. You can also specify the next unreleased version as3.2.*to get the latest
snapshot of the module.As for UPBGE, stubs are available for the 0.3 release, which you can install as follows:$pipinstallupbge-stubs==0.3.0.*And for the latest snapshot version,$pipinstallupbge-stubs==0.3.1.*You can also install it usingPipenv. Note that it is required to setallow_preleasesoption
in case the target application has no stable release (i.e. UPBGE 0.3 branch). You can use the
following content as a template for yourPipfile:[[source]]name="pypi"url="https://pypi.org/simple"verify_ssl=true[packages]"upbge-stubs"="==0.3.1.*"[requires]python_version="3.10"[pipenv]allow_prereleases=trueAlso, it would be more correct to use[dev-packages]instead of[packages], in which
case you can install or update the stubs using the-dflag likepipenv update -d.LicenseThis project is provided under the terms ofGNU General Public License v3 (GPL3).
Package: bpyth
bpythSome boring Python Tools, seejupyterdirectory.Try outThe directoryjupytercontains many notebooks with examples. They are very easy to try out interactively online, with Google Colab. Just click the link at the top of the page and then select Runtime/Run all from the menu in Colab.Installpip install bpythFiles Toolsdump_pickle: open, dump, closeload_pickle: open, load, closeStreamFiles: Iterable, returns all filenames of a parent directoryStreamLines: Iterable, returns all lines of a text fileHuman Toolshuman_readable_number: Rounds a number to a fixed number of significant digits.human_readable_seconds: Converts seconds to human readable timehuman_readable_bytes:   Converts Bytes to human readable sizeIterable Toolsminivenn: Compare two setsflatten: Yield all items from any nested iterableremove_dups: Remove dups from a list whilst-preserving-ordersort_by_priority_list: Sort a list by a list or tuple of prioritized objectscut_counter: Truncates rare values of a counterranking_from_counter: Converts a counter into a rankingObject Analysis Toolsrtype: Recursive type. Parses an n-dimensional object and returns a tuple of stype for the scalar in the top left corner.shape: Recursive len. Parses an n-dimensional object and returns a tuple of sizes.has_shape: Does an object have additional dimensions? (Skalars: No, Strings: No, Empty Iterables: No,
Other Iterables: Yes)memory_consumption: Returns the memory consumption of Python objects.String Toolssuperstrip: Removes Unicode whitespacesremove_words: Removes stopwordsremove_dupwords: Removes dup words from a string whilst-preserving-orderlongest_substr: Finds the longest common substring in a list of stringsrandom_str: Returns a random string
Package: bpython-django
bpython-djangoThis project is based onbpythonREPL, I liked it very much but it missed some features for Django, likeAutocomplete the constructor for the model,Autocomplete the attribute name on ModelManager functions like 'filter()' and 'get()'ExampleInstallpip install bpython-djangoUsagepython manage shellorpython manage shell -i bpython
Package: bpyutils
bpyutilsA collection of various common Python utilities.Table of ContentsFeaturesQuick StartUsageLicenseFeaturesPython 2.7+ and Python 3.4+ compatible.Quick Start$pipinstallbpyutilsCheck outinstallationfor more details.UsageApplication Interface>>>importbpyutilsCommand-Line Interface$bpyutilsUsage: bpyutils [OPTIONS] COMMAND [ARGS]...A collection of various common Python utilities.Options:--version   Show the version and exit.-h, --help  Show this message and exit.Commands:help     Show this message and exit.version  Show version and exit.LicenseThis repository has been released under theMIT License.Made with ❤️ usingboilpy.
Package: bq-airflow-dag-generator
bq-airflow-dag-generatorUtility package to generate Airflow DAG from DOT language to execute BigQuery efficiently mainly forAlphaSQL.Installpipinstallbq-airflow-dag-generatorUsage# You can set SQL_ROOT if your SQL file paths in dag.dot are not on current directory.os.environ["SQL_ROOT"]="/path/to/sql/root"dagpath="/path/to/dag.dot"dag=generate_airflow_dag_by_dot_path(dagpath)You can add tasks to existing DAG likedagpath="/path/to/dag.dot"existing_airflow_daggenerate_airflow_dag_by_dot_path(dagpath,dag=existing_airflow_dag)You can pass how to create Aiflow tasks likedefgen_task(sql_file_path,dag):sql_root=os.environ.get("SQL_ROOT")sql_file_path=os.path.join(sql_root,sql_file_path)ifsql_rootelsesql_file_pathwithopen(sql_file_path,"r")asf:query=f.read()task=PythonOperator(task_id=sql_file_path.replace("/",""),python_callable=get_bigquery_callable(query),dag=dag,)task.doc=f"""\# BigQuery Task Documentation:{sql_file_path}This is automatically generated.Query:{query}"""returntaskdagpath="/path/to/dag.dot"dag=generate_airflow_dag_by_dot_path(dagpath,get_task_by_sql_path_and_dag=gen_task)Testpython-munittesttests.test_dags
Package: bqclient
BumbleBeeBotQueue’s client ‘bumblebee’. This software is used to
remotely control a 3d printer. If you have a printer that
isn’t currently supported with this software, please let
us know on the github issues page.System RequirementsMac OS X, Linux, or Raspberry PIPython 2.7 or above, untested on Python 3Links:
-https://botqueue.com/-https://github.com/Hoektronics/BotQueue-https://github.com/Hoektronics/enginesAuthorsZach ‘Hoeken’ SmithJustin Nesselrotte
Package: bqcon
bqconA wrapper that allows to perform basic operations of fetching insertion and updation in google big query. Enabling you to work with datasets and tables using python modules.Using this package you can perform the following operations in google big query:InsertFetch oneFetch manyCustomqueryDelete DatasetDetete tableUpdateFor Detailed Documenation :https://iyappan24.github.io/bqcon/Code Repository :https://github.com/iyappan24/bqconUse Cases and Examples :https://www.iyappanatwork.info/post/python-wrapper-for-google-big-query-bqcon
Package: bqemulatormanager
BiqQueryEmulator Managerthis package is wrapper ofbigquery-emulatorwhich provides us BigQuery mock working in local machine.using this package, you cando unit test of your sqldownload the schema of big query, and use it to make test datausagefollowinginstruction,  downloadbigquery-emulatorcommand.install this package.pip install bqemulatormanagertest your sql.importbqemulatormanagerasbqemimportpandasaspdmanager=bqem.Manager(project='test',schema_path='resources/schema_example.yaml')withmanager:data=pd.DataFrame([{'id':1,'name':'sato'},{'id':2,'name':'yamada'}])manager.load(data,'dataset1.table_a')sql='SELECT id, name FROM `dataset1.table_a`'df=manager.query(sql)print(df)unit test example ishere.automatically detect schemaWhen calledManager.load,SchemaManagersearch correspond table schema fromschema_path(default isbqem_master_schema.yaml).If schema definition cannot be found,SchemaManagerrequest it from BigQuery in production environment and update master schema file.
Package: bq-estimator
bq-estimatorEstimates the data usage of SQL queries executed in BigQuery.Returns the estimated usage in KB, MB, GB, or TB dependent on the closest multiplier.Installationpip install bq-estimatorGoogleApplication Default Credentialsmust be set up for this tool to function.UsageReady to execute SQL queries.bq-estimator query.sql [query2.sql query3.sql …]Options--dbtTakes any model selection command that is compatible with dbtbq-estimator --dbt [dbt model selection]--verbose -vIf errors are present the error details from BigQuery will be printed to the terminal.
Package: bq-etl
A Simple Google BigQuery ETLTired of messy execution pipelines? Drop a few .sql files into a
directory, e.g. foo.sql, bar.sql and call executeTemplates() with some
parameters. It will resolve dependencies between these SQL statements,
execute them in correct order sending the output to a table with a
unique name which includes the hash of the SQL. If the table already
exists, it will not be executed again. Tables will eventually expire
so you do not need to worry about deleting them.For more details seeexampledirectory.The only dependencies of this package are google-cloud-bigquery and
google-cloud-storage.It is purposely made bare-bones. If you want a feature such as a
specific export format other than .csv.gz, etc. - pull requests are
more than welcome.Installationpip install bq_etlDescriptionA module to execute BigQuery ETL jobs comprising of multiple
interdependent SQL statements with no configuration other than the SQL
itself. It can infer dependencies, execute the SQL in correct order,
and optionally extract and download the table data.Similarly to how compilers compile programs, if any of the steps
(execution, extract or download) are already completed, they are not
repeated again. This module does not need any external tools or
configuration to keep track of its state - it is entirely based on
what is in BigQuery, GCS or your local filesystem.The key hack is that the actual BigQuery output table names are
postfixed with short hashes of the SQL statements thereby making them
unique and specific to the tables. Changing the SQL will result in a
different table name.LicenseApache 2.0
Package: bq-fake-pii-table-creator
bq_fake_pii_table_creatorLibrary for creating BQ tables with fake pii data.The drive and use case to create this library, was when you need a lot of data to validate if your org complies with regulations like
CCPA, HIPAA, GDPR.1. Environment setup1.1. Get the codegitclonehttps://.../bq_fake_pii_table_creator.gitcdbq_fake_pii_table_creator1.2. Auth credentials1.2.1. Create a service account and grant it below rolesThe Service Account authenticated must have administrator privileges for Cloud Storage and BigQuery.1.2.2. Download a JSON key and save it as<YOUR-CREDENTIALS_FILES_FOLDER>/bq_fake_pii_table_creator-credentials.jsonPlease notice this folder and file will be required in next steps.1.3. VirtualenvUsingvirtualenvis optional, but strongly recommended unless you use Docker or a PEX file.1.3.1. Install Python 3.6+1.3.2. Create and activate avirtualenvpipinstall--upgradevirtualenv
python3-mvirtualenv--pythonpython3envsource./env/bin/activate1.3.3. Install the dependenciespipinstall--editable.1.3.4. Set environment variablesReplace below values according to your environment:exportGOOGLE_APPLICATION_CREDENTIALS=credentials_file_path1.4. DockerSee instructions below.2. Sample application entry point2.1. Run main.pyVirtualenvOnly the project-id argument is required.pythonmain.py--project-idyour_project--bq-dataset-nameyour_dataset--bq-table-nameyour_table--num-rows5000--num-cols10--obfuscate-col-namestrue2.2. Or using Dockerdockerbuild-tbq_fake_pii_table_creator.
dockerrun--rm--tty-vCREDENTIALS_FILES_FOLDER:/data\bq_fake_pii_table_creator\--project-idyour_projectHistory0.0.1 (2020-04-30)First release on PyPI.
Package: bqgcs
BQGCS===================================| Google Cloud Storage Connector for Google BigQuery.Getting Started--------.. code:: bashpip install bqgcsHow to Use--------.. code:: pythonimport bqgcsfrom google.cloud import bigquery, storagegcs = storage.Client()blob = gcs.bucket("<<bucket_name>>").blob("<<blob_name>>")bqgcs.query_to_gcs("SELECT * FROM 'project.dataset.table'", blob)bq = bigquery.Client()table = bq.dataset("<<dataset>>").table("<<table>>")bqgcs.gcs_to_bq(blob, table)License--------MIT
Package: bqhus
bqhusBigQuery helper utils for PythonHow to useSelect from tableimport bqhus
bqhus.select("SELECT * FROM `foo.bar.purchases` LIMIT 20").as_dicts()
bqhus.select("SELECT * FROM `foo.bar.purchases` ORDER BY created_at LIMIT 1", client=bigquery.Client(project="foobar")).first_as_dict()
bqhus.select("SELECT * FROM `foo.bar.purchases` LIMIT 20").to_dataframe()Create table from querybqhus.select("SELECT * FROM `some.source.table`").to_table("foo.bar.new_table")Create temp table from querybqhus.select("SELECT * FROM `some.source.table`").to_table("foo.bar.new_table").expires_in(days=7)Export table to GCS as csvbqhus.export_table("foo.bar.sample").as_csv(gzip=True).to_gcs("my-bucket", "exported-table.csv.gz")Generate random table namebqhus.random_table_name("prefix-here")DevelopmentRun testsdocker compose run bqhus
Package: bq-iterate
IntroductionThis project serves as a BigQuery helper that allows you to query data from BigQuery, without worrying about memory limitation concerns, it makes working with BigQuery data as easy as working with lists in pythonInstallation :python3.8 -m pip install  bq-iterateUsagefrombq_iterateimportBqQueryRowIterator,batchify_iteratorquery="select * from <project_id>.<dataset_id>.<table_id>"row_itrator=BqQueryRowIterator(query=query,batch_size=2000000)#  choose a batch_size that will fit into your memorybatches=batchify_iterator(row_itrator,batch_slice=50000)#  choose a batch_slice that will fit into your memorydata=[]forbatchinbatches:# do your batch processing heredata.append(len(batch))print(sum(data))What happens behind the scenes :bq_iterate provide two functionalities :2 classes BqQueryIterator and BqTableRowIterator, they behave like an iterator, where they hold only <batch_size> elements in memory and when you want to access the element <batch_size + 1> the iterator calls in memory the next batch_size + 1 elementsA function batchify_iterator, what this function does, it takes an iterator and yields slices of it, the <batch_slice> can be bigger than the <batch_size> even if by common sens it's supposed to be smaller, it doesn't matter, since batchify_iterator will create in memory at each batch it yields, a list of <batch_slice> elements, once the batch consumed it freed from memory, since it's a generator
Package: bqlib
bqlib - BigQuery Python LibraryBigQuery Python LibrarySee:Google BigQueryRequirementsPython 2.6 or later (not support for 3.x)Setup$ pip install bqlibHow to useSingle Query - BQJobBQJob is a class for starting the BigQuery job and fetching the result.You can use either run_sync(synchronous) or run_async(asynchronous) method.from bqlib import BQJob

project_id = 'example_project'
query = 'SELECT foo FROM bar'
http = authorized_http

bqjob = BQJob(http, project_id, query=query)

# run synchronously
job_result = bqjob.run_sync()

# or run asynchronously
bqjob.run_async()
# ... do other things ...

job_result = bqjob.get_result()

print job_result # [{u'foo': 10}, {u'foo': 20}, ...]Multiple Queries - BQJobGroupBQJobGroup is a class for putting multiple BQJobs into an one group.Each BQJob in that group are executed concurrently.from bqlib import BQJob, BQJobGroup

bqjob1 = BQJob(http, project_id, query=query)
bqjob2 = BQJob(http, project_id, query=query)

job_group = BQJobGroup([bqjob1, bqjob2])
# synchronously
results = job_group.run_sync()

# or asynchronously
job_group.run_async()
# ... do other things ...

results = job_group.get_results()

print results # [[{'foo': 10}, {'foo': 20}], [{'bar': 'test'}]]NoteConcurrent Requests to BigQUeryConcurrent requests to BigQuery is restricted to 20 requests byQuota Policy.If you want to set up concurrent requests to 20, you also have to set up at traffic controls inapi-consolepage.LicenseThis library is disributed as MIT license.History2013-10-22 bqlib 0.0.1First release2014-03-18 bqlib 0.0.2Bug fixes
Package: bq-loader
bq_loader - Interactive Command Line Interface for Google BigQueryInstallpipinstallbq_loaderAuthenticationThis package is built on top of Google libraries. To use this package you need to authenticate with your google account. For more information see:https://cloud.google.com/storage/docs/authentication.You can use the packagegcloudto authenticate yourself.gcloudauthUsageCommand Line InterfacebqloaderAPICreate a table from a local file or directoryfrombq_loaderimportcreate_table_from_localcreate_table_from_local(table_id='snapshot',project_id='subugoe-collaborative',dataset_id='resources',file_path='test_data/*',schema_file_path='test_schema/schema_crossref.json',source_format='jsonl',write_disposition='WRITE_APPEND',table_description='Test Table generated by bq_loader',ignore_unknown_values=True)Create a table from a Google Bucketfrombq_loaderimportcreate_table_from_bucketcreate_table_from_bucket(uri='gs://bigschol/tests/*',table_id='bq_loader_test',project_id='subugoe-collaborative',dataset_id='resources',schema_file_path='test_schema/schema_crossref.json',source_format='jsonl',write_disposition='WRITE_EMPTY',table_description='Test Table generated by bq_loader',ignore_unknown_values=True)Upload local files to a Google Bucketfrombq_loaderimportupload_files_to_bucketupload_files_to_bucket(bucket_name='bigschol',file_path='test_data/*',gcb_dir='tests')
Package: bq-lookml-gen
bq_lookml_generator v.0.1.1This automatic generator is buit over Josh Temples looker parser [https://github.com/joshtemple/lkml]. Building out lkml, it allows you to generate lookml from BigQuery metadata.Getting startedmake sure you are working in a venv.head to /lookml/bq_lookml_genset up your bq_lookml_gen service accountinput your secrect path in here lookml/bq_lookml_gen/config.pyservice_account = service_account.Credentials.from_service_account_file(
      ['path_to_file.json'],
  )input your warehouse schema target in here lookml/bq_lookml_gen/warehouse_target.pytype bq_lookml_gen into terminal and watch the base explore generate...troubleshootingrun pip install -r requirements.txt if you are running into dependency issuesyou can run bq_lookml_gen.py from terminal if needed
Package: bqmail
BQMailBQMailis a Python module for sending mails to apply for seismic data from theIRIS DMC. It is a front-end API of theBREQ_fast.ForChinese users, please refer to ourchinese blog.InstallationBQMailcan currently run on Linux and MAC OSX.BQMailis running and testing on Python 3.9/3.10/3.11.Installation via PyPIpip install bqmailInstallation from source codeThe latest version of theBQMailis available on Gitlab:git clone https://github.com/xumi1993/bqmail.git bqmailThen you can install this version:cd bqmail
pip install .A quick example:frombqmail.mailimportBQMailfromobspyimportUTCDateTimebq=BQMail('xxx@xxx.com',server='smtp.xxx.com',password='xxx',username='bqmail')bq.query_events(starttime=UTCDateTime(2017,1,1),endtime=UTCDateTime(2018,1,1),minmagnitude=5.5,catalog='GCMT')bq.query_stations(network='CB',station='LZH')bq.send_mail(time_before=0,time_after=1000)